fixing last part of agent names, removing un use code

Author: Fr4nc3

src/backend/app_config.py

@@ -217,10 +217,14 @@ async def create_azure_ai_agent(
                 else:
                     # Assume these are already proper tool definitions for create_agent
                     tool_definitions = tools
-            
+            logging.info("\n\n\n\n\n")
+            logging.info("Tool definitions: %s", tool_definitions)
+            logging.info("\n\n\n\n\n")
             # Create the agent using the project client
             if response_format is not None:
+                logging.info("\n\n\n\n\n")
                 logging.info("Response format provided: %s", response_format)
+                logging.info("\n\n\n\n\n")
 
 
             agent_definition = await project_client.agents.create_agent(

src/backend/kernel_agents/agent_base.py

@@ -474,14 +474,14 @@ def load_tools_config(filename: str, config_path: Optional[str] = None) -> Dict[
 
             # Normalize filename to avoid issues with spaces and capitalization
             # Convert "Hr Agent" to "hr" and "TechSupport Agent" to "tech_support"
-            logging.debug(f"Normalizing filename: {filename}")
+            logging.info(f"Normalizing filename: {filename}")
             normalized_filename = filename.replace(" ", "_").replace("-", "_").lower()
             # If it ends with "_agent", remove it
             if normalized_filename.endswith("_agent"):
                 normalized_filename = normalized_filename[:-6]
-            logging
+            
             config_path = os.path.join(backend_dir, "tools", f"{normalized_filename}_tools.json")
-            logging.debug(f"Looking for tools config at: {config_path}")
+            logging.info(f"Looking for tools config at: {config_path}")
 
         try:
             with open(config_path, "r") as f:
@@ -540,12 +540,12 @@ def get_tools_from_config(cls, kernel: sk.Kernel, agent_type: str, config_path:
 
                     # Set this parameter in the function's metadata
                     if param_name:
-                        logging.debug(f"Adding parameter '{param_name}' to function '{function_name}'")
+                        logging.info(f"Adding parameter '{param_name}' to function '{function_name}'")
 
                 # Register the function with the kernel
                 kernel.add_function(plugin_name, kernel_func)
                 kernel_functions.append(kernel_func)
-                logging.debug(f"Successfully created dynamic tool '{function_name}' for {agent_type}")
+                logging.info(f"Successfully created dynamic tool '{function_name}' for {agent_type}")
             except Exception as e:
                 logging.error(f"Failed to create tool '{tool.get('name', 'unknown')}': {str(e)}")
 

src/backend/kernel_agents/agent_factory.py

@@ -228,13 +228,13 @@ async def create_agent(
                 if k in valid_keys
             }
             agent = agent_class(**filtered_kwargs)
-            logger.debug(f"[DEBUG] Agent object after instantiation: {agent}")
+            logger.info(f"[DEBUG] Agent object after instantiation: {agent}")
             # Initialize the agent asynchronously if it has async_init
             if hasattr(agent, "async_init") and inspect.iscoroutinefunction(
                 agent.async_init
             ):
                 init_result = await agent.async_init()
-                logger.debug(f"[DEBUG] Result of agent.async_init(): {init_result}")
+                logger.info(f"[DEBUG] Result of agent.async_init(): {init_result}")
             # Register tools with Azure AI Agent for LLM function calls
             if (
                 hasattr(agent, "_agent")
@@ -363,16 +363,15 @@ async def create_all_agents(
         # Create agent name to instance mapping for the planner
         agent_instances = {}
         for agent_type, agent in agents.items():
-            agent_name = (
-                cls._agent_type_strings.get(agent_type).replace("_", "") + "Agent"
-            )
-            agent_name = (
-                agent_name[0].upper() + agent_name[1:]
-            )  # Capitalize first letter
+            agent_name = agent_type.value
+            
+            logging.info(
+                f"Creating agent instance for {agent_name} with type {agent_type}"
+            )   
             agent_instances[agent_name] = agent
 
         # Log the agent instances for debugging
-        logger.debug(
+        logger.info(
             f"Created {len(agent_instances)} agent instances for planner: {', '.join(agent_instances.keys())}"
         )
 

src/backend/kernel_agents/group_chat_manager.py

@@ -553,7 +553,7 @@ async def run_group_chat(self, user_input: str, plan_id: str = "", step_id: str
                 messages = []
                 if isinstance(result, str):
                     # If it's just a string response
-                    logging.debug(f"Group chat returned a string: {result[:100]}...")
+                    logging.info(f"Group chat returned a string: {result[:100]}...")
                     await self._memory_store.add_item(
                         AgentMessage(
                             session_id=self._session_id,

src/backend/kernel_agents/planner_agent.py

@@ -93,7 +93,7 @@ def __init__(
             AgentType.HUMAN.value,
             AgentType.HR.value,
             AgentType.MARKETING.value,
-            AgentType.PRODUCT,
+            AgentType.PRODUCT.value,
             AgentType.PROCUREMENT.value,
             AgentType.TECH_SUPPORT.value,
             AgentType.GENERIC.value,
@@ -105,48 +105,6 @@ def __init__(
         # This will be initialized in async_init
         self._azure_ai_agent = None
 
-    def _get_response_format_schema(self) -> dict:
-        """
-        Returns a JSON schema that defines the expected structure of the response.
-        This ensures responses from the agent will match the required format exactly.
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "initial_goal": {
-                    "type": "string",
-                    "description": "The primary goal extracted from the user's input task",
-                },
-                "steps": {
-                    "type": "array",
-                    "description": "List of steps required to complete the task",
-                    "items": {
-                        "type": "object",
-                        "properties": {
-                            "action": {
-                                "type": "string",
-                                "description": "A clear instruction for the agent including the function name to use",
-                            },
-                            "agent": {
-                                "type": "string",
-                                "description": "The name of the agent responsible for this step",
-                            },
-                        },
-                        "required": ["action", "agent"],
-                    },
-                },
-                "summary_plan_and_steps": {
-                    "type": "string",
-                    "description": "A concise summary of the overall plan and its steps in less than 50 words",
-                },
-                "human_clarification_request": {
-                    "type": ["string", "null"],
-                    "description": "Optional request for additional information needed from the user",
-                },
-            },
-            "required": ["initial_goal", "steps", "summary_plan_and_steps"],
-        }
-
     async def async_init(self) -> None:
         """Asynchronously initialize the PlannerAgent.
 
@@ -331,12 +289,12 @@ async def _create_structured_plan(
         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}")
+            logging.info(f"Input: {input_task}")
+            logging.info(f"Available agents: {self._available_agents}")
 
             # Get template variables as a dictionary
             args = self._generate_args(input_task.description)
-
+            logging.info(f"Generated args: {args}")
             logging.info(f"Creating plan for task: '{input_task.description}'")
             logging.info(f"Using available agents: {self._available_agents}")
 
@@ -355,10 +313,10 @@ async def _create_structured_plan(
             kernel_args = KernelArguments(**args)
             # kernel_args["input"] = f"TASK: {input_task.description}\n\n{instruction}"
 
-            logging.debug(f"Kernel arguments: {kernel_args}")
+            logging.info(f"Kernel arguments: {kernel_args}")
 
             # Get the schema for our expected response format
-            response_format_schema = self._get_response_format_schema()
+    
 
             # Ensure we're using the right pattern for Azure AI agents with semantic kernel
             # Properly handle async generation
@@ -367,10 +325,6 @@ async def _create_structured_plan(
                 settings={
                     "temperature": 0.0,  # Keep temperature low for consistent planning
                     "max_tokens": 10096,  # Ensure we have enough tokens for the full plan
-                    "response_format": {
-                        "type": "json_object",
-                        "schema": response_format_schema,
-                    },
                 },
             )
 
@@ -382,8 +336,9 @@ async def _create_structured_plan(
                 if chunk is not None:
                     response_content += str(chunk)
 
+            logging.info(f"\n\n\n\n")
             logging.info(f"Response content length: {len(response_content)}")
-            logging.debug(f"Response content: {response_content[:500]}...")
+            logging.info(f"\n\n\n\n")
 
             # Check if response is empty or whitespace
             if not response_content or response_content.isspace():
@@ -398,6 +353,9 @@ async def _create_structured_plan(
                 try:
                     parsed_result = PlannerResponsePlan.parse_raw(response_content)
                     logging.info("Successfully parsed response with direct parsing")
+                    logging.info(f"\n\n\n\n")
+                    logging.info(f"Parsed result: {parsed_result}")
+                    logging.info(f"\n\n\n\n")
                 except Exception as parse_error:
                     logging.warning(f"Failed direct parse: {parse_error}")
 
@@ -727,6 +685,7 @@ def _generate_args(self, objective: str) -> any:
         if hasattr(self, "_agent_instances") and self._agent_instances:
             # Process each agent to get their tools
             for agent_name, agent in self._agent_instances.items():
+
                 if hasattr(agent, "_tools") and agent._tools:
                     # Add each tool from this agent
                     for tool in agent._tools:
@@ -814,7 +773,7 @@ def _generate_args(self, objective: str) -> any:
 
                             tools_list.append(tool_entry)
 
-            logging.debug(f"Generated {len(tools_list)} tools from agent instances")
+            logging.info(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:
@@ -833,7 +792,7 @@ def _generate_args(self, objective: str) -> any:
                             # Extract agent name if format is "Agent: AgentName"
                             agent_name = agent_part.replace("Agent", "").strip()
                             if not agent_name:
-                                agent_name = "GenericAgent"
+                                agent_name = AgentType.GENERIC.value
 
                             tools_list.append(
                                 {