clean up old code

Author: Fr4nc3

src/backend/app_kernel.py

@@ -35,7 +35,7 @@
     ActionRequest,
     ActionResponse,
 )
-from utils_kernel import initialize_runtime_and_context, get_agents, retrieve_all_agent_tools, rai_success
+from utils_kernel import initialize_runtime_and_context, get_agents, rai_success
 from event_utils import track_event_if_configured
 from models.agent_types import AgentType
 from kernel_agents.agent_factory import AgentFactory
@@ -819,7 +819,7 @@ async def get_agent_tools():
                 type: string
                 description: Arguments required by the tool function
     """
-    return retrieve_all_agent_tools()
+    return []
 
 
 # Initialize the application when it starts

src/backend/kernel_agents/group_chat_manager.py

@@ -47,6 +47,27 @@ def __init__(self):
 from event_utils import track_event_if_configured
 
 
+class GroupChatManagerClass:
+    """A class for service compatibility with Semantic Kernel."""
+    # Defining properties needed by Semantic Kernel
+    service_id = ""
+    
+    def __init__(self, manager):
+        self.manager = manager
+        self.service_id = f"group_chat_manager_{manager._session_id}"
+    
+    async def execute_next_step(self, kernel_arguments: KernelArguments) -> str:
+        """Execute the next step in the plan.
+        
+        Args:
+            kernel_arguments: KernelArguments that should contain session_id and plan_id
+            
+        Returns:
+            Status message
+        """
+        return await self.manager.execute_next_step(kernel_arguments)
+
+
 class GroupChatManager:
     """Group Chat Manager implementation using Semantic Kernel's AgentGroupChat.
     
@@ -83,6 +104,27 @@ def __init__(
         # Initialize the AgentGroupChat later when all agents are registered
         self._agent_group_chat = None
         self._initialized = False
+        
+        # Create a wrapper class for service registration
+        service_wrapper = GroupChatManagerClass(self)
+        
+        try:
+            # Register with kernel using the service_wrapper
+            if hasattr(kernel, "register_services"):
+                kernel.register_services({service_wrapper.service_id: service_wrapper})
+                logging.info(f"Registered GroupChatManager as kernel service with ID: {service_wrapper.service_id}")
+            elif hasattr(kernel, "services") and hasattr(kernel.services, "register_service"):
+                kernel.services.register_service(service_wrapper.service_id, service_wrapper)
+                logging.info(f"Registered GroupChatManager as kernel service with ID: {service_wrapper.service_id}")
+            elif hasattr(kernel, "services") and isinstance(kernel.services, dict):
+                # Last resort: directly add to services dictionary
+                kernel.services[service_wrapper.service_id] = service_wrapper
+                logging.info(f"Added GroupChatManager to kernel services dictionary with ID: {service_wrapper.service_id}")
+            else:
+                logging.warning("Could not register GroupChatManager service. Semantic Kernel version might be incompatible.")
+        except Exception as e:
+            logging.error(f"Error registering GroupChatManager service: {e}")
+            # Continue without crashing
 
     async def initialize_group_chat(self) -> None:
         """Initialize the AgentGroupChat with registered agents and strategies."""
@@ -566,16 +608,22 @@ async def run_group_chat(self, user_input: str, plan_id: str = "", step_id: str
             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:
+    async def execute_next_step(self, kernel_arguments: KernelArguments) -> str:
         """Execute the next step in the plan.
         
         Args:
-            session_id: The session identifier
-            plan_id: The plan identifier
+            kernel_arguments: KernelArguments that should contain session_id and plan_id
             
         Returns:
             Status message
         """
+        # Extract arguments
+        session_id = kernel_arguments.get("session_id", "")
+        plan_id = kernel_arguments.get("plan_id", "")
+        
+        if not session_id or not plan_id:
+            return "Missing session_id or plan_id in arguments"
+        
         # Get all steps for the plan
         steps = await self._memory_store.get_steps_for_plan(plan_id, session_id)
 

src/backend/utils_kernel.py

@@ -96,62 +96,6 @@ async def get_agents(session_id: str, user_id: str) -> Dict[str, Any]:
         logging.error(f"Error creating agents: {str(e)}")
         raise
 
-async def retrieve_all_agent_tools() -> List[Dict[str, Any]]:
-    """
-    Retrieves all agent tools information.
-    
-    Returns:
-        List of dictionaries containing tool information
-    """
-    functions = []
-    
-    try:
-        # Create a temporary session for tool discovery
-        temp_session_id = "tools-discovery-session"
-        temp_user_id = "tools-discovery-user"
-        
-        # Create all agents for this session to extract their tools
-        agents = await get_agents(temp_session_id, temp_user_id)
-        
-        # Process each agent's tools
-        for agent_name, agent in agents.items():
-            if not hasattr(agent, '_tools') or agent._tools is None:
-                continue
-                
-            # Make agent name more readable for display
-            display_name = agent_name.replace('Agent', '')
-            
-            # Extract tool information from the agent
-            for tool in agent._tools:
-                try:
-                    # Extract parameters information
-                    parameters_info = {}
-                    if hasattr(tool, 'metadata') and tool.metadata.get('parameters'):
-                        parameters_info = tool.metadata.get('parameters', {})
-                    
-                    # Create tool info dictionary
-                    tool_info = {
-                        "agent": display_name,
-                        "function": tool.name,
-                        "description": tool.description if hasattr(tool, 'description') and tool.description else "",
-                        "parameters": str(parameters_info)
-                    }
-                    functions.append(tool_info)
-                except Exception as e:
-                    logging.warning(f"Error extracting tool information from {agent_name}.{tool.name}: {str(e)}")
-        
-        # Clean up cache
-        cache_key = f"{temp_session_id}_{temp_user_id}"
-        if cache_key in agent_instances:
-            del agent_instances[cache_key]
-        
-    except Exception as e:
-        logging.error(f"Error retrieving agent tools: {str(e)}")
-        # Fallback to loading tool information from JSON files
-        functions = load_tools_from_json_files()
-    
-    return functions
-
 def load_tools_from_json_files() -> List[Dict[str, Any]]:
     """
     Load tool definitions from JSON files in the tools directory.