Merge pull request #156 from Fr4nc3/main

feat: pass variables values

Author: Fr4nc3

src/backend/app_config.py

@@ -194,6 +194,7 @@ async def create_azure_ai_agent(
         agent_name: str,
         instructions: str,
         tools: Optional[List[KernelFunction]] = None,
+        client=None,
         response_format=None,
         temperature: float = 0.0,
     ):
@@ -216,15 +217,16 @@ async def create_azure_ai_agent(
         """
         try:
             # Get the AIProjectClient
-            project_client = self.get_ai_project_client()
+            if client is None:
+                client = self.get_ai_project_client()
 
             # First try to get an existing agent with this name as assistant_id
             try:
 
-                existing_definition = await project_client.agents.get_agent(agent_name)
+                existing_definition = await client.agents.get_agent(agent_name)
                 # Create the agent instance directly with project_client and existing definition
                 agent = AzureAIAgent(
-                    client=project_client,
+                    client=client,
                     definition=existing_definition,
                     plugins=tools,
                 )
@@ -244,7 +246,7 @@ async def create_azure_ai_agent(
                     )
 
             # Create the agent using the project client with the agent_name as both name and assistantId
-            agent_definition = await project_client.agents.create_agent(
+            agent_definition = await client.agents.create_agent(
                 model=self.AZURE_OPENAI_DEPLOYMENT_NAME,
                 name=agent_name,
                 instructions=instructions,
@@ -254,7 +256,7 @@ async def create_azure_ai_agent(
 
             # Create the agent instance directly with project_client and definition
             agent = AzureAIAgent(
-                client=project_client,
+                client=client,
                 definition=agent_definition,
                 plugins=tools,
             )

src/backend/kernel_agents/agent_factory.py

@@ -93,6 +93,7 @@ async def create_agent(
         memory_store: Optional[CosmosMemoryContext] = None,
         system_message: Optional[str] = None,
         response_format: Optional[Any] = None,
+        client: Optional[Any] = None,
         **kwargs,
     ) -> BaseAgent:
         """Create an agent of the specified type.
@@ -160,7 +161,10 @@ async def create_agent(
         client = None
 
         try:
-            client = config.get_ai_project_client()
+            if client is None:
+                # Create the AIProjectClient instance using the config
+                # This is a placeholder; replace with actual client creation logic
+                client = config.get_ai_project_client()
         except Exception as client_exc:
             logger.error(f"Error creating AIProjectClient: {client_exc}")
             raise

src/backend/kernel_agents/group_chat_manager.py

@@ -54,11 +54,9 @@ def __init__(
         """Initialize the GroupChatManager Agent.
 
         Args:
-            kernel: The semantic kernel instance
             session_id: The current session identifier
             user_id: The user identifier
             memory_store: The Cosmos memory context
-            tools: Optional list of tools for this agent
             system_message: Optional system message for the agent
             agent_name: Optional name for the agent (defaults to "GroupChatManagerAgent")
             config_path: Optional path to the configuration file

src/backend/kernel_agents/human_agent.py

@@ -5,7 +5,6 @@
 from context.cosmos_memory_kernel import CosmosMemoryContext
 from event_utils import track_event_if_configured
 from kernel_agents.agent_base import BaseAgent
-from kernel_tools.human_tools import HumanTools
 from models.messages_kernel import (
     ActionRequest,
     AgentMessage,
@@ -40,7 +39,6 @@ def __init__(
         """Initialize the Human Agent.
 
         Args:
-            kernel: The semantic kernel instance
             session_id: The current session identifier
             user_id: The user identifier
             memory_store: The Cosmos memory context
@@ -51,15 +49,10 @@ def __init__(
             client: Optional client instance
             definition: Optional definition instance
         """
-        # Load configuration if tools not provided
-        if not tools:
-            # Get tools directly from HumanTools class
-            tools_dict = HumanTools.get_all_kernel_functions()
-            tools = [KernelFunction.from_method(func) for func in tools_dict.values()]
 
-            # Use system message from config if not explicitly provided
-            if not system_message:
-                system_message = self.default_system_message(agent_name)
+        # Use system message from config if not explicitly provided
+        if not system_message:
+            system_message = self.default_system_message(agent_name)
 
             # Use agent name from config if available
             agent_name = AgentType.HUMAN.value
@@ -75,11 +68,6 @@ def __init__(
             definition=definition,
         )
 
-    @property
-    def plugins(self):
-        """Get the plugins for the human agent."""
-        return HumanTools.get_all_kernel_functions()
-
     @staticmethod
     def default_system_message(agent_name=None) -> str:
         """Get the default system message for the agent.

src/backend/kernel_agents/planner_agent.py

@@ -32,6 +32,12 @@
 )
 from event_utils import track_event_if_configured
 from app_config import config
+from kernel_tools.hr_tools import HrTools
+from kernel_tools.generic_tools import GenericTools
+from kernel_tools.marketing_tools import MarketingTools
+from kernel_tools.procurement_tools import ProcurementTools
+from kernel_tools.product_tools import ProductTools
+from kernel_tools.tech_support_tools import TechSupportTools
 
 
 class PlannerAgent(BaseAgent):
@@ -50,7 +56,6 @@ def __init__(
         system_message: Optional[str] = None,
         agent_name: str = AgentType.PLANNER.value,
         available_agents: List[str] = None,
-        agent_tools_list: List[str] = None,
         agent_instances: Optional[Dict[str, BaseAgent]] = None,
         client=None,
         definition=None,
@@ -97,7 +102,15 @@ def __init__(
             AgentType.TECH_SUPPORT.value,
             AgentType.GENERIC.value,
         ]
-        self._agent_tools_list = agent_tools_list or []
+        self._agent_tools_list = {
+            AgentType.HR: HrTools.generate_tools_json_doc(),
+            AgentType.MARKETING: MarketingTools.generate_tools_json_doc(),
+            AgentType.PRODUCT: ProductTools.generate_tools_json_doc(),
+            AgentType.PROCUREMENT: ProcurementTools.generate_tools_json_doc(),
+            AgentType.TECH_SUPPORT: TechSupportTools.generate_tools_json_doc(),
+            AgentType.GENERIC: GenericTools.generate_tools_json_doc(),
+        }
+
         self._agent_instances = agent_instances or {}
 
     @staticmethod
@@ -311,8 +324,6 @@ async def _create_structured_plan(
             kernel_args = KernelArguments(**args)
             # kernel_args["input"] = f"TASK: {input_task.description}\n\n{instruction}"
 
-            logging.info(f"Kernel arguments: {kernel_args}")
-
             # Get the schema for our expected response format
 
             # Ensure we're using the right pattern for Azure AI agents with semantic kernel
@@ -522,177 +533,9 @@ def _generate_args(self, objective: str) -> any:
         # 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:
-            # Process each agent to get their tools
-            for agent_name, agent in self._agent_instances.items():
-                # First try to get tools directly from the agent's corresponding tool class
-                tools_dict = None
-
-                # Try to access plugins property which returns the get_all_kernel_functions result
-                if hasattr(agent, "plugins"):
-                    try:
-                        # Access plugins as a property, not a method
-                        tools_dict = agent.plugins
-                        logging.info(
-                            f"Got tools dictionary from {agent_name}'s plugins property"
-                        )
-
-                        # Check if tools_dict is a list or a dictionary
-                        if isinstance(tools_dict, list):
-                            # Convert list to dictionary if needed
-                            tools_dict_converted = {}
-                            for i, func in enumerate(tools_dict):
-                                func_name = getattr(func, "__name__", f"function_{i}")
-                                tools_dict_converted[func_name] = func
-                            tools_dict = tools_dict_converted
-                            logging.info(
-                                f"Converted tools list to dictionary for {agent_name}"
-                            )
-
-                    except Exception as e:
-                        logging.warning(
-                            f"Error accessing plugins property for {agent_name}: {e}"
-                        )
-
-                # Process tools from tools_dict if available
-                if tools_dict:
-                    for func_name, func in tools_dict.items():
-                        # Check if the function has necessary attributes
-                        if hasattr(func, "__name__") and hasattr(func, "__doc__"):
-                            description = func.__doc__ or f"Function {func_name}"
-
-                            # Create tool entry
-                            tool_entry = {
-                                "agent": agent_name,
-                                "function": func_name,
-                                "description": description,
-                                "arguments": "{}",  # Default empty dict
-                            }
-
-                            tools_list.append(tool_entry)
-
-                # Fall back to the previous approach if no tools_dict found
-                elif hasattr(agent, "_tools") and agent._tools:
-                    # Add each tool from this agent
-                    for tool in agent._tools:
-                        if hasattr(tool, "name") and hasattr(tool, "description"):
-                            # Extract function parameters/arguments
-                            args_dict = {}
-                            if hasattr(tool, "parameters"):
-                                # Check if we have kernel_arguments that need to be processed
-                                has_kernel_args = any(
-                                    param.name == "kernel_arguments"
-                                    for param in tool.parameters
-                                )
-                                has_kwargs = any(
-                                    param.name == "kwargs" for param in tool.parameters
-                                )
-
-                                # Process regular parameters first
-                                for param in tool.parameters:
-                                    # Skip kernel_arguments and kwargs as we'll handle them specially
-                                    if param.name in ["kernel_arguments", "kwargs"]:
-                                        continue
-
-                                    param_type = "string"  # Default type
-                                    if hasattr(param, "type"):
-                                        param_type = param.type
-
-                                    args_dict[param.name] = {
-                                        "description": (
-                                            param.description
-                                            if param.description
-                                            else param.name
-                                        ),
-                                        "title": param.name.replace("_", " ").title(),
-                                        "type": param_type,
-                                    }
-
-                                # If we have a kernel_arguments parameter, introspect it to extract its values
-                                # This is a special case handling for kernel_arguments to include its fields in the arguments
-                                if has_kernel_args:
-                                    # Check if we have kernel_parameter_descriptions
-                                    if hasattr(tool, "kernel_parameter_descriptions"):
-                                        # Extract parameter descriptions from the kernel
-                                        for (
-                                            key,
-                                            description,
-                                        ) in tool.kernel_parameter_descriptions.items():
-                                            if (
-                                                key not in args_dict
-                                            ):  # Only add if not already added
-                                                args_dict[key] = {
-                                                    "description": (
-                                                        description
-                                                        if description
-                                                        else key
-                                                    ),
-                                                    "title": key.replace(
-                                                        "_", " "
-                                                    ).title(),
-                                                    "type": "string",  # Default to string type
-                                                }
-                                    # Fall back to function's description if no specific descriptions
-                                    elif hasattr(tool, "description") and not args_dict:
-                                        # Add a generic parameter with the function's description
-                                        args_dict["input"] = {
-                                            "description": f"Input for {tool.name}: {tool.description}",
-                                            "title": "Input",
-                                            "type": "string",
-                                        }
-
-                            # If after all processing, arguments are still empty, add a dummy input parameter
-                            if not args_dict:
-                                args_dict["input"] = {
-                                    "description": f"Input for {tool.name}",
-                                    "title": "Input",
-                                    "type": "string",
-                                }
-
-                            # Create tool entry
-                            tool_entry = {
-                                "agent": agent_name,
-                                "function": tool.name,
-                                "description": tool.description,
-                                "arguments": str(args_dict),
-                            }
-
-                            tools_list.append(tool_entry)
-
-            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:
-            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 = AgentType.GENERIC.value
-
-                            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
-        logging.info(f"Tools list: {len(tools_list)}")
-        logging
+        for agent_name, tools in self._agent_tools_list.items():
+            if agent_name in self._available_agents:
+                tools_list.append(tools)
 
         tools_str = str(tools_list)