clean up tools creation and AzureAIAgent

Author: Fr4nc3

src/backend/app_config.py

@@ -9,6 +9,7 @@
 from semantic_kernel.kernel import Kernel
 from semantic_kernel.contents import ChatHistory
 from semantic_kernel.agents.azure_ai.azure_ai_agent import AzureAIAgent
+from semantic_kernel.functions import KernelFunction
 
 # Load environment variables from .env file
 load_dotenv()
@@ -193,9 +194,7 @@ async def create_azure_ai_agent(
         kernel: Kernel,
         agent_name: str,
         instructions: str,
-        agent_type: str = "assistant",
-        tools=None,
-        tool_resources=None,
+        tools: Optional[List[KernelFunction]] = None,
         response_format=None,
         temperature: float = 0.0,
     ):
@@ -228,7 +227,10 @@ async def create_azure_ai_agent(
 
                 # Create the agent instance directly with project_client and existing definition
                 agent = AzureAIAgent(
-                    client=project_client, definition=existing_definition, kernel=kernel
+                    client=project_client,
+                    definition=existing_definition,
+                    kernel=kernel,
+                    plugins=tools,
                 )
 
                 logging.info(
@@ -248,53 +250,23 @@ async def create_azure_ai_agent(
                         f"Unexpected error while retrieving agent {agent_name}: {str(e)}. Attempting to create new agent."
                     )
 
-            # Tool handling: We need to distinguish between our SK functions and
-            # the tool definitions needed by project_client.agents.create_agent
-            tool_definitions = None
-            kernel_functions = []
-
-            # If tools are provided and they are SK KernelFunctions, we need to handle them differently
-            # than if they are already tool definitions expected by AIProjectClient
-            if tools:
-                # Check if tools are SK KernelFunctions
-                if all(
-                    hasattr(tool, "name") and hasattr(tool, "invoke") for tool in tools
-                ):
-                    # Store the kernel functions to register with the agent later
-                    kernel_functions = tools
-                    # For now, we don't extract tool definitions from kernel functions
-                    # This would require additional code to convert SK functions to AI Project tool definitions
-                    logging.warning(
-                        "Kernel functions provided as tools will be registered with the agent after creation"
-                    )
-                else:
-                    # Assume these are already proper tool definitions for create_agent
-                    tool_definitions = tools
-
-            logging.info(f"Creating new agent with ID: {agent_name}")
-
             # Create the agent using the project client with the agent_name as both name and assistantId
             agent_definition = await project_client.agents.create_agent(
                 model=self.AZURE_OPENAI_DEPLOYMENT_NAME,
                 name=agent_name,
                 instructions=instructions,
-                tools=tool_definitions,
-                tool_resources=tool_resources,
                 temperature=temperature,
                 response_format=response_format,
             )
 
             # Create the agent instance directly with project_client and definition
             agent = AzureAIAgent(
-                client=project_client, definition=agent_definition, kernel=kernel
+                client=project_client,
+                definition=agent_definition,
+                kernel=kernel,
+                plugins=tools,
             )
 
-            # Register the kernel functions with the agent if any were provided
-            if kernel_functions:
-                for function in kernel_functions:
-                    if hasattr(agent, "add_function"):
-                        agent.add_function(function)
-
             return agent
         except Exception as exc:
             logging.error("Failed to create Azure AI Agent: %s", exc)

src/backend/kernel_agents/agent_base.py

@@ -95,7 +95,7 @@ def __init__(
         super().__init__(
             kernel=kernel,
             deployment_name=None,  # Set as needed
-            plugins=None,  # Use the loaded plugins,
+            plugins=tools,  # Use the loaded plugins,
             endpoint=None,  # Set as needed
             api_version=None,  # Set as needed
             token=None,  # Set as needed
@@ -119,9 +119,6 @@ def __init__(
         # Required properties for AgentGroupChat compatibility
         self.name = agent_name  # This is crucial for AgentGroupChat to identify agents
 
-        # Register the handler functions
-        self._register_functions()
-
     # @property
     # def plugins(self) -> Optional[dict[str, Callable]]:
     #     """Get the plugins for this agent.
@@ -140,37 +137,17 @@ async def async_init(self):
 
         This method must be called after creating the agent to complete initialization.
         """
+        logging.info(f"Initializing agent: {self._agent_name}")
         # Create Azure AI Agent or fallback
         self._agent = await config.create_azure_ai_agent(
             kernel=self._kernel,
             agent_name=self._agent_name,
             instructions=self._system_message,
+            tools=self._tools,
         )
         # Tools are registered with the kernel via get_tools_from_config
         return self
 
-    def _register_functions(self):
-        """Register this agent's functions with the kernel."""
-        # Use the kernel function decorator approach instead of from_native_method
-        # which isn't available in SK 1.28.0
-        function_name = "handle_action_request"
-
-        # Define the function using the kernel function decorator
-        @kernel_function(
-            description="Handle an action request from another agent or the system",
-            name=function_name,
-        )
-        async def handle_action_request_wrapper(*args, **kwargs):
-            # Forward to the instance method
-            return await self.handle_action_request(*args, **kwargs)
-
-        # Wrap the decorated function into a KernelFunction and register under this agent's plugin
-        kernel_func = KernelFunction.from_method(handle_action_request_wrapper)
-        # Use agent name as plugin for handler
-        self._kernel.add_function(self._agent_name, kernel_func)
-
-    # Required method for AgentGroupChat compatibility
-
     async def handle_action_request(self, action_request: ActionRequest) -> str:
         """Handle an action request from another agent or the system.
 
@@ -213,9 +190,7 @@ async def handle_action_request(self, action_request: ActionRequest) -> str:
 
             # Call the agent to handle the action
             async_generator = self._agent.invoke(
-                # messages=f"{json.dumps(self._chat_history)}\n\n
                 messages=f"{action_request.action}\n\nPlease perform this action"
-                # messages=action_request.action
             )
 
             response_content = ""
@@ -312,73 +287,11 @@ async def handle_action_request(self, action_request: ActionRequest) -> str:
 
         return response.json()
 
-    async def invoke_tool(self, tool_name: str, arguments: Dict[str, Any]) -> str:
-        """Invoke a specific tool by name with the provided arguments.
-
-        Args:
-            tool_name: The name of the tool to invoke
-            arguments: A dictionary of arguments to pass to the tool
-
-        Returns:
-            The result of the tool invocation as a string
-
-        Raises:
-            ValueError: If the tool is not found
-        """
-        # Find the tool by name in the agent's tools list
-        tool = next((t for t in self._tools if t.name == tool_name), None)
-
-        if not tool:
-            # Try looking up the tool in the kernel's plugins
-            plugin_name = f"{self._agent_name.lower().replace('agent', '')}_plugin"
-            try:
-                tool = self._kernel.get_function(plugin_name, tool_name)
-            except Exception:
-                raise ValueError(
-                    f"Tool '{tool_name}' not found in agent tools or kernel plugins"
-                )
-
-        if not tool:
-            raise ValueError(f"Tool '{tool_name}' not found")
-
-        try:
-            # Create kernel arguments from the dictionary
-            kernel_args = KernelArguments()
-            for key, value in arguments.items():
-                kernel_args[key] = value
-
-            # Invoke the tool
-            logging.info(f"Invoking tool '{tool_name}' with arguments: {arguments}")
-
-            # Use invoke_with_args_dict directly instead of relying on KernelArguments
-            if hasattr(tool, "invoke_with_args_dict") and callable(
-                tool.invoke_with_args_dict
-            ):
-                result = await tool.invoke_with_args_dict(arguments)
-            else:
-                # Fall back to standard invoke method
-                result = await tool.invoke(kernel_args)
-
-            # Log telemetry if configured
-            track_event_if_configured(
-                "AgentToolInvocation",
-                {
-                    "agent_name": self._agent_name,
-                    "tool_name": tool_name,
-                    "session_id": self._session_id,
-                    "user_id": self._user_id,
-                },
-            )
-
-            return str(result)
-        except Exception as e:
-            logging.error(f"Error invoking tool '{tool_name}': {str(e)}")
-            raise
-
     @staticmethod
     def create_dynamic_function(
         name: str,
         response_template: str,
+        description: Optional[str] = None,
         formatting_instr: str = DEFAULT_FORMATTING_INSTRUCTIONS,
     ) -> Callable[..., Awaitable[str]]:
         """Create a dynamic function for agent tools based on the name and template.
@@ -409,7 +322,10 @@ async def dynamic_function(**kwargs) -> str:
         dynamic_function.__name__ = name
 
         # Create a wrapped kernel function that matches the expected signature
-        @kernel_function(description=f"Dynamic function: {name}", name=name)
+        logging.info(f"Creating dynamic function: {name} {len(name)}")
+        logging.info(f"Description: {description} {len(description)}")
+
+        @kernel_function(description=f"Dynamic function {name}", name=name)
         async def kernel_wrapper(
             kernel_arguments: KernelArguments = None, **kwargs
         ) -> str:

src/backend/kernel_agents/agent_factory.py

@@ -192,17 +192,14 @@ async def create_agent(
             # Create the agent definition using the AIProjectClient (project-based pattern)
             # For GroupChatManager, create a definition with minimal configuration
             if client is not None:
-                try:
-                    definition = await client.agents.get_agent(agent_type_str)
-
-                except Exception as get_agent_exc:
-                    definition = await client.agents.create_agent(
-                        model=config.AZURE_OPENAI_DEPLOYMENT_NAME,
-                        name=agent_type_str,
-                        instructions=system_message,
-                        temperature=temperature,
-                        response_format=response_format,  # Add response_format if required
-                    )
+
+                definition = await client.agents.create_agent(
+                    model=config.AZURE_OPENAI_DEPLOYMENT_NAME,
+                    name=agent_type_str,
+                    instructions=system_message,
+                    temperature=temperature,
+                    response_format=response_format,  # Add response_format if required
+                )
                 logger.info(
                     f"Successfully created agent definition for {agent_type_str}"
                 )
@@ -242,14 +239,7 @@ async def create_agent(
             ):
                 init_result = await agent.async_init()
                 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")
-                and hasattr(agent._agent, "add_function")
-                and tools
-            ):
-                for fn in tools:
-                    agent._agent.add_function(fn)
+
         except Exception as e:
             logger.error(
                 f"Error creating agent of type {agent_type} with parameters: {e}"
@@ -292,37 +282,7 @@ async def _load_tools_for_agent(
             return []
         except Exception as e:
             logger.warning(f"Error loading tools for {agent_type}: {e}")
-
-            # For other agent types, try to create a simple fallback tool
-            try:
-                # Use PromptTemplateConfig to create a simple tool
-
-                # Simple minimal prompt
-                prompt = f"""You are a helpful assistant specialized in {agent_type} tasks. User query: {{$input}} Provide a helpful response."""
-
-                # Create a prompt template config
-                prompt_config = PromptTemplateConfig(
-                    template=prompt,
-                    name=f"{agent_type}_help_with_tasks",
-                    description=f"A helper function for {agent_type} tasks",
-                )
-
-                # Create the function using the prompt_config with explicit plugin_name
-                function = KernelFunction.from_prompt(
-                    function_name=f"{agent_type}_help_with_tasks",
-                    plugin_name=f"{agent_type}_fallback_plugin",
-                    description=f"A helper function for {agent_type} tasks",
-                    prompt_template_config=prompt_config,
-                )
-
-                logger.info(f"Created fallback tool for {agent_type}")
-                return [function]
-            except Exception as fallback_error:
-                logger.error(
-                    f"Failed to create fallback tool for {agent_type}: {fallback_error}"
-                )
-                # Return an empty list if everything fails - the agent can still function without tools
-                return []
+            return []
 
     @classmethod
     async def create_all_agents(