Fix agent initialization and pydantic model handling

agents/conversation_agent.py

@@ -1,5 +1,5 @@
 from typing import Dict, List
-from crewai import Agent
+from crewai import Agent, Task
 import logging
 from utils.log_manager import LogManager
 
@@ -25,6 +25,19 @@ class ConversationAgent(Agent):
         
         self.logger.info("Conversation Agent initialized")
         
+    def execute_task(self, task: Task) -> str:
+        """Execute a task assigned to the agent"""
+        self.logger.info(f"Executing task: {task.description}")
+        
+        try:
+            # Process the task description as a message
+            result = self.process_message(task.description)
+            return result["message"]
+            
+        except Exception as e:
+            self.logger.error(f"Error executing task: {str(e)}")
+            return "I apologize, but I encountered an error processing your request."
+        
     def process_message(self, message: str, context: Dict = None) -> Dict:
         """Process a message and return a therapeutic response"""
         self.logger.info("Processing message")
@@ -32,7 +45,7 @@ class ConversationAgent(Agent):
         
         try:
             # For now, return a simple response since we haven't set up the LLM
-            response = "I understand and I'm here to help. Could you tell me more about how you're feeling?"
+            response = self._generate_therapeutic_response(message, context)
             
             return {
                 "message": response,
@@ -48,6 +61,35 @@ class ConversationAgent(Agent):
                 "task_type": "error_recovery"
             }
             
+    def _generate_therapeutic_response(self, message: str, context: Dict) -> str:
+        """Generate a therapeutic response based on the input message and context"""
+        # Basic response templates
+        responses = {
+            "greeting": "Hello! I'm here to support you. How are you feeling today?",
+            "emotion": "I hear that you're feeling {}. Would you like to tell me more about that?",
+            "support": "That sounds challenging. I'm here to listen and support you.",
+            "clarification": "Could you tell me more about what you mean by that?",
+            "validation": "It's completely normal to feel that way. Your feelings are valid.",
+            "default": "I understand and I'm here to help. Could you tell me more about how you're feeling?"
+        }
+        
+        # Simple message analysis
+        message = message.lower()
+        
+        if "hello" in message or "hi" in message:
+            return responses["greeting"]
+        elif any(word in message for word in ["sad", "angry", "scared", "happy", "anxious"]):
+            emotion = next(word for word in ["sad", "angry", "scared", "happy", "anxious"] if word in message)
+            return responses["emotion"].format(emotion)
+        elif any(word in message for word in ["help", "support", "difficult", "hard"]):
+            return responses["support"]
+        elif len(message.split()) < 3:
+            return responses["clarification"]
+        elif "feel" in message or "feeling" in message:
+            return responses["validation"]
+        else:
+            return responses["default"]
+            
     def get_status(self) -> Dict:
         """Get the current status of the agent"""
         return {

agents/orchestrator.py

@@ -76,19 +76,52 @@ class WellnessOrchestrator:
         context = context or {}
         
         try:
-            # First, check for crisis indicators
+            # Create a task based on message type
             if self._is_crisis(message):
-                return self.crisis_agent.process_message(message, context)
+                task = Task(
+                    description=message,
+                    agent=self.crisis_agent,
+                    context=context,
+                    expected_output="Crisis intervention response"
+                )
+                response = self.crisis_agent.execute_task(task)
+                agent_type = "crisis"
                 
-            # Check for specific intents
-            if "assess" in message.lower() or "evaluate" in message.lower():
-                return self.assessment_agent.process_message(message, context)
+            elif "assess" in message.lower() or "evaluate" in message.lower():
+                task = Task(
+                    description=message,
+                    agent=self.assessment_agent,
+                    context=context,
+                    expected_output="Mental health assessment response"
+                )
+                response = self.assessment_agent.execute_task(task)
+                agent_type = "assessment"
                 
-            if "meditate" in message.lower() or "mindful" in message.lower():
-                return self.mindfulness_agent.process_message(message, context)
+            elif "meditate" in message.lower() or "mindful" in message.lower():
+                task = Task(
+                    description=message,
+                    agent=self.mindfulness_agent,
+                    context=context,
+                    expected_output="Mindfulness guidance response"
+                )
+                response = self.mindfulness_agent.execute_task(task)
+                agent_type = "mindfulness"
                 
-            # Default to conversation agent
-            return self.conversation_agent.process_message(message, context)
+            else:
+                task = Task(
+                    description=message,
+                    agent=self.conversation_agent,
+                    context=context,
+                    expected_output="Therapeutic conversation response"
+                )
+                response = self.conversation_agent.execute_task(task)
+                agent_type = "conversation"
+                
+            return {
+                "message": response,
+                "agent_type": agent_type,
+                "task_type": task.expected_output
+            }
             
         except Exception as e:
             self.logger.error(f"Error processing message: {str(e)}")