fixing planner

Author: Fr4nc3

src/backend/kernel_agents/planner_agent.py

@@ -268,6 +268,10 @@ async def _create_structured_plan(self, input_task: InputTask) -> Tuple[Plan, Li
             # Generate the instruction for the LLM
             instruction = self._generate_instruction(input_task.description)
 
+            # Log the input task for debugging
+            logging.info(f"Creating plan for task: '{input_task.description}'")
+            logging.info(f"Using available agents: {self._available_agents}")
+            
             # Use the Azure AI Agent instead of direct function invocation
             if self._azure_ai_agent is None:
                 # Initialize the agent if it's not already done
@@ -299,6 +303,8 @@ async def _create_structured_plan(self, input_task: InputTask) -> Tuple[Plan, Li
             # Debug the response
             logging.info(f"Response content length: {len(response_content)}")
             logging.debug(f"Response content first 500 chars: {response_content[:500]}")
+            # Log more of the response for debugging
+            logging.info(f"Full response: {response_content}")
 
             # Check if response is empty or whitespace
             if not response_content or response_content.isspace():
@@ -346,12 +352,16 @@ async def _create_structured_plan(self, input_task: InputTask) -> Tuple[Plan, Li
                             logging.info("Using fallback plan creation from text response")
                             return await self._create_fallback_plan_from_text(input_task, response_content)
 
-                # Extract plan details
+                # Extract plan details and log for debugging
                 initial_goal = parsed_result.initial_goal
                 steps_data = parsed_result.steps
                 summary = parsed_result.summary_plan_and_steps
                 human_clarification_request = parsed_result.human_clarification_request
 
+                # Log the steps and agent assignments for debugging
+                for i, step in enumerate(steps_data):
+                    logging.info(f"Step {i+1} - Agent: {step.agent}, Action: {step.action}")
+                
                 # Create the Plan instance
                 plan = Plan(
                     id=str(uuid.uuid4()),
@@ -385,6 +395,10 @@ async def _create_structured_plan(self, input_task: InputTask) -> Tuple[Plan, Li
                     action = step_data.action
                     agent_name = step_data.agent
 
+                    # Log any unusual agent assignments for debugging
+                    if "onboard" in input_task.description.lower() and agent_name != "HrAgent":
+                        logging.warning(f"UNUSUAL AGENT ASSIGNMENT: Task contains 'onboard' but assigned to {agent_name} instead of HrAgent")
+                    
                     # Validate agent name
                     if agent_name not in self._available_agents:
                         logging.warning(f"Invalid agent name: {agent_name}, defaulting to GenericAgent")

src/backend/tests/test_planner_agent_integration.py

@@ -350,6 +350,102 @@ async def test_create_structured_plan(self):
         print(f"\nCreated technical webinar plan with {len(steps)} steps")
         print(f"Steps assigned to: {', '.join(set(step.agent for step in steps))}")
 
+    async def test_hr_agent_selection(self):
+        """Test that the planner correctly assigns employee onboarding tasks to the HR agent."""
+        # Initialize components
+        await self.initialize_planner_agent()
+        
+        # Create an onboarding task
+        input_task = InputTask(
+            session_id=self.session_id,
+            user_id=self.user_id,
+            description="Onboard a new employee, Jessica Smith."
+        )
+        
+        print("\n\n==== TESTING HR AGENT SELECTION FOR ONBOARDING ====")
+        print(f"Task: '{input_task.description}'")
+        
+        # Call handle_input_task
+        args = KernelArguments(input_task_json=input_task.json())
+        result = await self.planner_agent.handle_input_task(args)
+        
+        # Check that result contains a success message
+        self.assertIn("created successfully", result)
+        
+        # Verify plan was created in memory store
+        plan = await self.memory_store.get_plan_by_session(self.session_id)
+        self.assertIsNotNone(plan)
+        
+        # Verify steps were created
+        steps = await self.memory_store.get_steps_for_plan(plan.id, self.session_id)
+        self.assertGreater(len(steps), 0)
+        
+        # Log plan details
+        print(f"\n📋 Created onboarding plan with ID: {plan.id}")
+        print(f"🎯 Goal: {plan.initial_goal}")
+        print(f"📝 Summary: {plan.summary}")
+        
+        print("\n📝 Steps:")
+        for i, step in enumerate(steps):
+            print(f"  {i+1}. 👤 Agent: {step.agent}, 🔧 Action: {step.action}")
+        
+        # Count agents used in the plan
+        agent_counts = {}
+        for step in steps:
+            agent_counts[step.agent] = agent_counts.get(step.agent, 0) + 1
+            
+        print("\n📊 Agent Distribution:")
+        for agent, count in agent_counts.items():
+            print(f"  {agent}: {count} step(s)")
+        
+        # The critical test: verify that at least one step is assigned to HrAgent
+        hr_steps = [step for step in steps if step.agent == "HrAgent"]
+        has_hr_steps = len(hr_steps) > 0
+        self.assertTrue(has_hr_steps, "No steps assigned to HrAgent for an onboarding task")
+        
+        if has_hr_steps:
+            print("\n✅ TEST PASSED: HrAgent is used for onboarding task")
+        else:
+            print("\n❌ TEST FAILED: HrAgent is not used for onboarding task")
+        
+        # Verify that no steps are incorrectly assigned to MarketingAgent
+        marketing_steps = [step for step in steps if step.agent == "MarketingAgent"]
+        no_marketing_steps = len(marketing_steps) == 0
+        self.assertEqual(len(marketing_steps), 0, 
+                         f"Found {len(marketing_steps)} steps incorrectly assigned to MarketingAgent for an onboarding task")
+        
+        if no_marketing_steps:
+            print("✅ TEST PASSED: No MarketingAgent steps for onboarding task")
+        else:
+            print(f"❌ TEST FAILED: Found {len(marketing_steps)} steps incorrectly assigned to MarketingAgent")
+            
+        # Verify that the first step or a step containing "onboard" is assigned to HrAgent
+        first_agent = steps[0].agent if steps else None
+        onboarding_steps = [step for step in steps if "onboard" in step.action.lower()]
+        
+        if onboarding_steps:
+            onboard_correct = onboarding_steps[0].agent == "HrAgent"
+            self.assertEqual(onboarding_steps[0].agent, "HrAgent", 
+                            "The step containing 'onboard' was not assigned to HrAgent")
+            if onboard_correct:
+                print("✅ TEST PASSED: Steps containing 'onboard' are assigned to HrAgent")
+            else:
+                print(f"❌ TEST FAILED: Step containing 'onboard' assigned to {onboarding_steps[0].agent}, not HrAgent")
+            
+        # If no specific "onboard" step but we have steps, the first should likely be HrAgent
+        elif steps and "hr" not in first_agent.lower():
+            first_step_correct = first_agent == "HrAgent"
+            self.assertEqual(first_agent, "HrAgent", 
+                            f"The first step was assigned to {first_agent}, not HrAgent")
+            if first_step_correct:
+                print("✅ TEST PASSED: First step is assigned to HrAgent")
+            else:
+                print(f"❌ TEST FAILED: First step assigned to {first_agent}, not HrAgent")
+                
+        print("\n==== END HR AGENT SELECTION TEST ====\n")
+            
+        return plan, steps
+
     async def run_all_tests(self):
         """Run all tests in sequence."""
         # Call setUp explicitly to ensure environment is properly initialized
@@ -372,6 +468,10 @@ async def run_all_tests(self):
             print("\n===== Testing _create_structured_plan directly =====")
             await self.test_create_structured_plan()
 
+            # Test 5: Verify HR agent selection for onboarding tasks
+            print("\n===== Testing HR agent selection =====")
+            await self.test_hr_agent_selection()
+            
             print("\nAll tests completed successfully!")
 
         except Exception as e: