Merge branch 'feature/azd-semantickernel' of https://github.com/microsoft/Multi-Agent-Custom-Automation-Engine-Solution-Accelerator into azd-semantickernel-marktayl

Author: marktayl1

src/backend/app_config.py

@@ -219,7 +219,10 @@ async def create_azure_ai_agent(
                     tool_definitions = tools
 
             # Create the agent using the project client
-            logging.info("Creating agent '%s' with model '%s'", agent_name, self.AZURE_OPENAI_DEPLOYMENT_NAME)
+            if response_format is not None:
+                logging.info("Response format provided: %s", response_format)
+
+                
             agent_definition = await project_client.agents.create_agent(
                 model=self.AZURE_OPENAI_DEPLOYMENT_NAME,
                 name=agent_name,

src/backend/kernel_agents/planner_agent.py

@@ -128,12 +128,7 @@ async def handle_input_task(self, input_task: InputTask) -> str:
         # Parse the input task
         logging.info("Handling input task")
 
-        logging.info(f"Parsed input task: {input_task}")
-        
-        # Generate a structured plan with steps
-        
-        logging.info(f"Received input task: {input_task.description}")
-        logging.info(f"Session ID: {input_task.session_id}, User ID: {self._user_id}")
+
         plan, steps = await self._create_structured_plan(input_task)
 
         logging.info(f"Plan created: {plan}")
@@ -268,16 +263,9 @@ async def _create_structured_plan(self, input_task: InputTask) -> Tuple[Plan, Li
         """
         try:
             # Generate the instruction for the LLM
-            logging.info("Generating instruction for the LLM")
-            logging.debug(f"Input: {input_task}")
-            logging.debug(f"Available agents: {self._available_agents}")
 
             instruction = self._generate_instruction(input_task.description)
 
-            logging.info(f"Generated instruction: {instruction}")   
-            # 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:
@@ -587,74 +575,90 @@ def _generate_instruction(self, objective: str) -> str:
         # Create a list of available agents
         agents_str = ", ".join(self._available_agents)
 
-        # Create list of available tools
-        # If _agent_tools_list is empty but we have agent instances available elsewhere,
-        # we should retrieve tools directly from agent instances
-        tools_str = ""
+        # Create list of available tools in JSON-like format
+        tools_list = []
+        
+        # Check if we have agent instances to extract tools from
         if hasattr(self, '_agent_instances') and self._agent_instances:
-            # Extract tools from agent instances
-            agent_tools_sections = []
-            
             # Process each agent to get their tools
             for agent_name, agent in self._agent_instances.items():
                 if hasattr(agent, '_tools') and agent._tools:
-                    # Create a section header for this agent
-                    agent_tools_sections.append(f"### {agent_name} Tools ###")
-                    
                     # Add each tool from this agent
                     for tool in agent._tools:
                         if hasattr(tool, 'name') and hasattr(tool, 'description'):
-                            tool_desc = f"Agent: {agent_name} - Function: {tool.name} - {tool.description}"
-                            agent_tools_sections.append(tool_desc)
-                    
-                    # Add a blank line after each agent's tools
-                    agent_tools_sections.append("")
+                            # Extract function parameters/arguments
+                            args_dict = {}
+                            if hasattr(tool, 'parameters'):
+                                for param in tool.parameters:
+                                    param_type = "string"  # Default type
+                                    if hasattr(param, 'type'):
+                                        param_type = param.type
+                                    
+                                    args_dict[param.name] = {
+                                        'description': param.description,
+                                        'title': param.name.replace('_', ' ').title(),
+                                        'type': param_type
+                                    }
+                            
+                            # Create tool entry
+                            tool_entry = {
+                                'agent': agent_name,
+                                'function': tool.name,
+                                'description': tool.description,
+                                'arguments': str(args_dict)
+                            }
+                            
+                            tools_list.append(tool_entry)
 
-            # Join all sections
-            if agent_tools_sections:
-                tools_str = "\n".join(agent_tools_sections)
-                # Log the tools for debugging
-                logging.debug(f"Generated tools list from agent instances with {len(agent_tools_sections)} entries")
-            else:
-                tools_str = "Various specialized tools (No tool details available from agent instances)"
-                logging.warning("No tools found in agent instances")
-        elif self._agent_tools_list:
-            # Fall back to the existing tools list if available
-            tools_str = "\n".join(self._agent_tools_list)
-            logging.debug(f"Using existing agent_tools_list with {len(self._agent_tools_list)} entries")
-        else:
-            # Default fallback
-            tools_str = "Various specialized tools"
-            logging.warning("No tools information available for planner instruction")
-        
-        # Build the instruction, avoiding backslashes in f-string expressions
-        objective_part = f"Your objective is:\n{objective}" if objective else "When given an objective, analyze it and create a plan to accomplish it."
-        
-        return f"""
+            logging.debug(f"Generated {len(tools_list)} tools from agent instances")
+        
+        # If we couldn't extract tools from agent instances, create a simplified format
+        if not tools_list:
+            logging.warning("No tool details extracted from agent instances, creating simplified format")
+            if self._agent_tools_list:
+                # Create dummy entries from the existing tool list strings
+                for tool_str in self._agent_tools_list:
+                    if ":" in tool_str:
+                        parts = tool_str.split(":")
+                        if len(parts) >= 2:
+                            agent_part = parts[0].strip()
+                            function_part = parts[1].strip()
+                            
+                            # Extract agent name if format is "Agent: AgentName"
+                            agent_name = agent_part.replace("Agent", "").strip()
+                            if not agent_name:
+                                agent_name = "GenericAgent"
+                                
+                            tools_list.append({
+                                'agent': agent_name,
+                                'function': function_part,
+                                'description': f"Function {function_part} from {agent_name}",
+                                'arguments': "{}"
+                            })
+        
+        # Convert the tools list to a string representation
+        tools_str = str(tools_list)
+        
+        # Build the instruction, avoiding backslashes in f-string expressions  
+
+        instruction_template = f"""
         You are the Planner, an AI orchestrator that manages a group of AI agents to accomplish tasks.
 
         For the given objective, come up with a simple step-by-step plan.
         This plan should involve individual tasks that, if executed correctly, will yield the correct answer. Do not add any superfluous steps.
         The result of the final step should be the final answer. Make sure that each step has all the information needed - do not skip steps.
 
         These actions are passed to the specific agent. Make sure the action contains all the information required for the agent to execute the task.
-        
-        {objective_part}
+
+        Your objective is:
+        {objective}
 
         The agents you have access to are:
         {agents_str}
 
         These agents have access to the following functions:
         {tools_str}
 
-        IMPORTANT AGENT SELECTION GUIDANCE:
-        - HrAgent: ALWAYS use for ALL employee-related tasks like onboarding, hiring, benefits, payroll, training, employee records, ID cards, mentoring, background checks, etc.
-        - MarketingAgent: Use for marketing campaigns, branding, market research, content creation, social media, etc.
-        - ProcurementAgent: Use for purchasing, vendor management, supply chain, asset management, etc.
-        - ProductAgent: Use for product development, roadmaps, features, product feedback, etc.
-        - TechSupportAgent: Use for technical issues, software/hardware setup, troubleshooting, IT support, etc.
-        - GenericAgent: Use only for general knowledge tasks that don't fit other categories
-        - HumanAgent: Use only when human input is absolutely required and no other agent can handle the task
 
         The first step of your plan should be to ask the user for any additional information required to progress the rest of steps planned.
 
@@ -664,15 +668,21 @@ def _generate_instruction(self, objective: str) -> str:
 
         If there is a single function call that can directly solve the task, only generate a plan with a single step. For example, if someone asks to be granted access to a database, generate a plan with only one step involving the grant_database_access function, with no additional steps.
 
+        When generating the action in the plan, frame the action as an instruction you are passing to the agent to execute. It should be a short, single sentence. Include the function to use. For example, "Set up an Office 365 Account for Jessica Smith. Function: set_up_office_365_account"
+
+        Ensure the summary of the plan and the overall steps is less than 50 words.
+
+        Identify any additional information that might be required to complete the task. Include this information in the plan in the human_clarification_request field of the plan. If it is not required, leave it as null. Do not include information that you are waiting for clarification on in the string of the action field, as this otherwise won't get updated.
+
         You must prioritise using the provided functions to accomplish each step. First evaluate each and every function the agents have access too. Only if you cannot find a function needed to complete the task, and you have reviewed each and every function, and determined why each are not suitable, there are two options you can take when generating the plan.
         First evaluate whether the step could be handled by a typical large language model, without any specialised functions. For example, tasks such as "add 32 to 54", or "convert this SQL code to a python script", or "write a 200 word story about a fictional product strategy".
-
         If a general Large Language Model CAN handle the step/required action, add a step to the plan with the action you believe would be needed, and add "EXCEPTION: No suitable function found. A generic LLM model is being used for this step." to the end of the action. Assign these steps to the GenericAgent. For example, if the task is to convert the following SQL into python code (SELECT * FROM employees;), and there is no function to convert SQL to python, write a step with the action "convert the following SQL into python code (SELECT * FROM employees;) EXCEPTION: No suitable function found. A generic LLM model is being used for this step." and assign it to the GenericAgent.
-
         Alternatively, if a general Large Language Model CAN NOT handle the step/required action, add a step to the plan with the action you believe would be needed, and add "EXCEPTION: Human support required to do this step, no suitable function found." to the end of the action. Assign these steps to the HumanAgent. For example, if the task is to find the best way to get from A to B, and there is no function to calculate the best route, write a step with the action "Calculate the best route from A to B. EXCEPTION: Human support required, no suitable function found." and assign it to the HumanAgent.
 
+
         Limit the plan to 6 steps or less.
 
         Choose from {agents_str} ONLY for planning your steps.
 
-        """
+        """
+        return instruction_template