working version with bugs

Author: Fr4nc3

src/backend/config_kernel.py

@@ -3,7 +3,13 @@
 import logging
 import semantic_kernel as sk
 from semantic_kernel.kernel import Kernel
-from semantic_kernel.contents import ChatHistory
+# Updated imports for compatibility
+try:
+    # Try newer structure
+    from semantic_kernel.contents import ChatHistory
+except ImportError:
+    # Fall back to older structure for compatibility
+    from semantic_kernel.connectors.ai.chat_completion_client import ChatHistory
 from semantic_kernel.agents.azure_ai.azure_ai_agent import AzureAIAgent
 
 # Import AppConfig from app_config
@@ -54,26 +60,3 @@ def CreateKernel():
     def GetAIProjectClient():
         """Get an AIProjectClient using the AppConfig implementation."""
         return config.get_ai_project_client()
-    
-    @staticmethod
-    async def CreateAzureAIAgent(
-        kernel: Kernel, 
-        agent_name: str, 
-        instructions: str, 
-        agent_type: str = "assistant", 
-        tools=None,
-        tool_resources=None,
-        response_format=None,
-        temperature: float = 0.0
-    ):
-        """Creates a new Azure AI Agent using the AppConfig implementation."""
-        return await config.create_azure_ai_agent(
-            kernel=kernel,
-            agent_name=agent_name,
-            instructions=instructions,
-            agent_type=agent_type,
-            tools=tools,
-            tool_resources=tool_resources,
-            response_format=response_format,
-            temperature=temperature
-        )

src/backend/kernel_agents/agent_factory.py

@@ -23,7 +23,7 @@
 from kernel_agents.product_agent import ProductAgent
 from kernel_agents.planner_agent import PlannerAgent  # Add PlannerAgent import
 from kernel_agents.group_chat_manager import GroupChatManager
-
+from semantic_kernel.prompt_template.prompt_template_config import PromptTemplateConfig
 from context.cosmos_memory_kernel import CosmosMemoryContext
 
 
@@ -108,6 +108,7 @@ async def create_agent(
         user_id: str,
         temperature: float = 0.0,
         system_message: Optional[str] = None,
+        response_format: Optional[Any] = None,
         **kwargs
     ) -> BaseAgent:
         """Create an agent of the specified type.
@@ -174,7 +175,7 @@ async def create_agent(
                     name=agent_type_str,
                     instructions=system_message,
                     temperature=temperature,
-                    response_format=None  # Add response_format if required
+                    response_format=response_format  # Add response_format if required
                 )
                 logger.info(f"Successfully created agent definition for {agent_type_str}")
         except Exception as agent_exc:
@@ -224,57 +225,6 @@ async def create_agent(
 
         return agent
 
-    @classmethod
-    async def create_azure_ai_agent(
-        cls,
-        agent_name: str,
-        session_id: str,
-        system_prompt: str,
-        tools: List[KernelFunction] = None
-    ) -> AzureAIAgent:
-        """Create an Azure AI Agent.
-        
-        Args:
-            agent_name: The name of the agent
-            session_id: The session ID
-            system_prompt: The system prompt for the agent
-            tools: Optional list of tools for the agent
-            
-        Returns:
-            An Azure AI Agent instance
-        """
-        # Check if we already have an agent in the cache
-        cache_key = f"{session_id}_{agent_name}"
-        if session_id in cls._azure_ai_agent_cache and cache_key in cls._azure_ai_agent_cache[session_id]:
-            # If tools are provided, make sure they are registered with the cached agent
-            agent = cls._azure_ai_agent_cache[session_id][cache_key]
-            if tools:
-                for tool in tools:
-                    agent.add_function(tool)
-            return agent
-        
-        # Create a kernel using the AppConfig instance
-        kernel = config.create_kernel()
-        
-        # Await creation since create_azure_ai_agent is async
-        agent = await config.create_azure_ai_agent(
-            kernel=kernel,
-            agent_name=agent_name,
-            instructions=system_prompt
-        )
-        
-        # Register tools if provided
-        if tools:
-            for tool in tools:
-                agent.add_function(tool)
-                
-        # Cache the agent instance
-        if session_id not in cls._azure_ai_agent_cache:
-            cls._azure_ai_agent_cache[session_id] = {}
-        cls._azure_ai_agent_cache[session_id][cache_key] = agent
-        
-        return agent
-        
     @classmethod
     async def _load_tools_for_agent(cls, kernel: Kernel, agent_type: str) -> List[KernelFunction]:
         """Load tools for an agent from the tools directory.
@@ -310,7 +260,7 @@ async def _load_tools_for_agent(cls, kernel: Kernel, agent_type: str) -> List[Ke
             # For other agent types, try to create a simple fallback tool
             try:
                 # Use PromptTemplateConfig to create a simple tool
-                from semantic_kernel.prompt_template.prompt_template_config import PromptTemplateConfig
+                
 
                 # Simple minimal prompt
                 prompt = f"""You are a helpful assistant specialized in {agent_type} tasks.

src/backend/kernel_agents/group_chat_manager.py

@@ -5,11 +5,30 @@
 from typing import Dict, List, Optional, Any, Tuple
 
 import semantic_kernel as sk
-from semantic_kernel.agents import AgentGroupChat
+from semantic_kernel.functions.kernel_arguments import KernelArguments
+from semantic_kernel.agents import AgentGroupChat  # pylint: disable=E0611
+
 from semantic_kernel.agents.strategies import (
     SequentialSelectionStrategy,
     TerminationStrategy,
 )
+# Updated imports for compatibility 
+try:
+    # Try importing from newer structure first
+    from semantic_kernel.contents import ChatMessageContent, ChatHistory
+except ImportError:
+    # Fall back to older structure for compatibility
+    class ChatMessageContent:
+        """Compatibility class for older SK versions."""
+        def __init__(self, role="", content="", name=None):
+            self.role = role
+            self.content = content
+            self.name = name
+
+    class ChatHistory:
+        """Compatibility class for older SK versions."""
+        def __init__(self):
+            self.messages = []
 
 from kernel_agents.agent_base import BaseAgent
 from context.cosmos_memory_kernel import CosmosMemoryContext
@@ -103,42 +122,46 @@ async def select_agent(self, agents, history):
             
             Args:
                 agents: List of available agents
-                history: Chat history
+                history: Chat history (ChatHistory object)
                 
             Returns:
                 The next agent to take the turn
             """
             # If no history, start with the PlannerAgent
-            if not history:
+            if not history or not history.messages:
                 return next((agent for agent in agents if agent.name == "PlannerAgent"), None)
 
             # Get the last message
-            last_message = history[-1]
+            last_message = history.messages[-1]
 
-            match last_message.name:
-                case "PlannerAgent":
-                    # After the planner creates a plan, HumanAgent should review it
-                    return next((agent for agent in agents if agent.name == "HumanAgent"), None)
-                    
-                case "HumanAgent":
-                    # After human feedback, the specific agent for the step should proceed
-                    # Need to extract which agent should be next from the plan
-                    # For demo purposes, going with a simple approach
-                    # In a real implementation, we would look up the next step in the plan
-                    return next((agent for agent in agents if agent.name == "GenericAgent"), None)
-                    
-                case "GroupChatManager":
-                    # If the manager just assigned a step, the specific agent should execute it
-                    # For demo purposes, we'll just use the next agent in a simple rotation
-                    current_agent_index = next((i for i, agent in enumerate(agents) 
-                                              if agent.name == last_message.name), 0)
-                    next_index = (current_agent_index + 1) % len(agents)
+            # Extract name from the message - in SK ChatMessageContent
+            last_sender = last_message.role
+            if hasattr(last_message, 'name') and last_message.name:
+                last_sender = last_message.name
+            
+            # Route based on the last sender
+            if last_sender == "PlannerAgent":
+                # After the planner creates a plan, HumanAgent should review it
+                return next((agent for agent in agents if agent.name == "HumanAgent"), None)
+            elif last_sender == "HumanAgent":
+                # After human feedback, the specific agent for the step should proceed
+                # For simplicity, use GenericAgent as fallback
+                return next((agent for agent in agents if agent.name == "GenericAgent"), None)
+            elif last_sender == "GroupChatManager":
+                # If the manager just assigned a step, find the agent that should execute it
+                # For simplicity, just rotate to the next agent
+                agent_names = [agent.name for agent in agents]
+                try:
+                    current_index = agent_names.index(last_sender)
+                    next_index = (current_index + 1) % len(agents)
                     return agents[next_index]
-                    
-                case _:
-                    # Default to the Group Chat Manager to coordinate next steps
-                    return next((agent for agent in agents if agent.name == "GroupChatManager"), None)
-    
+                except ValueError:
+                    return agents[0] if agents else None
+            else:
+                # Default to the Group Chat Manager
+                return next((agent for agent in agents if agent.name == "GroupChatManager"), 
+                           agents[0] if agents else None)
+
     class PlanTerminationStrategy(TerminationStrategy):
         """Strategy for determining when the agent group chat should terminate.
         
@@ -154,23 +177,29 @@ def __init__(self, agents, maximum_iterations=10, automatic_reset=True):
                 maximum_iterations: Maximum number of iterations before termination
                 automatic_reset: Whether to reset the agent after termination
             """
-            super().__init__(agents, maximum_iterations, automatic_reset)
+            super().__init__(maximum_iterations, automatic_reset)
+            self._agents = agents
 
-        async def should_agent_terminate(self, agent, history):
-            """Check if the agent should terminate.
+        async def should_terminate(self, history, agents=None) -> bool:
+            """Check if the chat should terminate.
             
             Args:
-                agent: The current agent
-                history: Chat history
+                history: Chat history as a ChatHistory object
+                agents: List of agents (optional, uses self._agents if not provided)
                 
             Returns:
-                True if the agent should terminate, False otherwise
+                True if the chat should terminate, False otherwise
             """
-            # Default termination conditions
-            if not history:
+            # Default termination conditions from parent class
+            if await super().should_terminate(history, agents or self._agents):
+                return True
+                
+            # If no history, continue the chat
+            if not history or not history.messages:
                 return False
 
-            last_message = history[-1]
+            # Get the last message
+            last_message = history.messages[-1]
 
             # End the chat if the plan is completed or if human intervention is required
             if "plan completed" in last_message.content.lower():
@@ -469,35 +498,72 @@ async def run_group_chat(self, user_input: str, plan_id: str = "", step_id: str
         await self.initialize_group_chat()
 
         try:
-            # Run the group chat
-            chat_result = await self._agent_group_chat.invoke_async(user_input)
+            # Run the group chat with Semantic Kernel
+            result = await self._agent_group_chat.invoke_async(user_input)
+            
+            # Process the result which could be a ChatHistory object or something else
+            if hasattr(result, "messages") and result.messages:
+                messages = result.messages
+            elif hasattr(result, "value") and isinstance(result.value, list):
+                messages = result.value
+            else:
+                # Fallback for other formats
+                messages = []
+                if isinstance(result, str):
+                    # If it's just a string response
+                    logging.debug(f"Group chat returned a string: {result[:100]}...")
+                    await self._memory_store.add_item(
+                        AgentMessage(
+                            session_id=self._session_id,
+                            user_id=self._user_id,
+                            plan_id=plan_id,
+                            content=result,
+                            source="GroupChatManager",
+                            step_id=step_id,
+                        )
+                    )
+                    return result
+            
+            # Process the messages from the chat result
+            final_response = None
 
-            # Process and store results
-            messages = chat_result.value
             for msg in messages:
                 # Skip the initial user message
-                if msg.role == "user" and msg.content == user_input:
+                if hasattr(msg, "role") and msg.role == "user" and msg.content == user_input:
                     continue
-                    
-                # Store agent messages in the memory
+                
+                # Determine the source/agent name
+                source = "assistant"
+                if hasattr(msg, "name") and msg.name:
+                    source = msg.name
+                elif hasattr(msg, "role") and msg.role:
+                    source = msg.role
+                
+                # Get the message content
+                content = msg.content if hasattr(msg, "content") else str(msg)
+                
+                # Store the message in memory
                 await self._memory_store.add_item(
                     AgentMessage(
                         session_id=self._session_id,
                         user_id=self._user_id,
                         plan_id=plan_id,
-                        content=msg.content,
-                        source=msg.name if hasattr(msg, "name") else msg.role,
+                        content=content,
+                        source=source,
                         step_id=step_id,
                     )
                 )
+                
+                # Keep track of the final response
+                final_response = content
 
             # Return the final message from the chat
-            if messages:
-                return messages[-1].content
+            if final_response:
+                return final_response
             return "Group chat completed with no messages."
 
         except Exception as e:
-            logging.error(f"Error running group chat: {str(e)}")
+            logging.exception(f"Error running group chat: {e}")
             return f"Error running group chat: {str(e)}"
 
     async def execute_next_step(self, session_id: str, plan_id: str) -> str:

src/backend/kernel_agents/planner_agent.py

@@ -680,23 +680,5 @@ def _generate_instruction(self, objective: str) -> str:
         Limit the plan to 6 steps or less.
 
         Choose from {agents_str} ONLY for planning your 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.
-        
-        Return your response as a JSON object with the following structure:
-        {{
-          "initial_goal": "The goal of the plan",
-          "steps": [
-            {{
-              "action": "Detailed description of the step action",
-              "agent": "AgentName"
-            }}
-          ],
-          "summary_plan_and_steps": "Brief summary of the plan and steps",
-          "human_clarification_request": "Any additional information needed from the human" 
-        }}
         """