clean unuse code

Author: Fr4nc3

src/backend/app_config.py

@@ -9,7 +9,6 @@
 from semantic_kernel.kernel import Kernel
 from semantic_kernel.contents import ChatHistory
 from semantic_kernel.agents.azure_ai.azure_ai_agent import AzureAIAgent
-
 # Load environment variables from .env file
 load_dotenv()
 
@@ -139,6 +138,8 @@ def create_kernel(self):
         Returns:
             A new Semantic Kernel instance
         """
+        # Create a new kernel instance without manually configuring OpenAI services
+        # The agents will be created using Azure AI Agent Project pattern instead
         kernel = Kernel()
         return kernel
 

src/backend/app_kernel.py

@@ -4,6 +4,7 @@
 import os
 import uuid
 import re
+import json
 from typing import List, Dict, Optional, Any
 
 # FastAPI imports
@@ -87,7 +88,8 @@ async def input_task_endpoint(input_task: InputTask, request: Request):
     """
     Receive the initial input task from the user.
     """
-    if not rai_success(input_task.description):
+    # Fix 1: Properly await the async rai_success function
+    if not await rai_success(input_task.description):
         print("RAI failed")
 
         track_event_if_configured(
@@ -113,8 +115,8 @@ async def input_task_endpoint(input_task: InputTask, request: Request):
     if not input_task.session_id:
         input_task.session_id = str(uuid.uuid4())
 
-    # Set user ID from authenticated user
-    input_task.user_id = user_id
+    # Fix 2: Don't try to set user_id on InputTask directly since it doesn't have that field
+    # Instead, include it in the JSON we'll pass to the planner
 
     try:
         # Create just the planner agent instead of all agents
@@ -125,8 +127,12 @@ async def input_task_endpoint(input_task: InputTask, request: Request):
             user_id=user_id
         )
 
-        # Use the planner to handle the task - pass input_task_json for compatibility
-        input_task_json = input_task.json()
+        # Convert input task to JSON for the kernel function, add user_id here
+        input_task_data = input_task.model_dump()
+        input_task_data["user_id"] = user_id
+        input_task_json = json.dumps(input_task_data)
+        
+        # Use the planner to handle the task
         result = await planner_agent.handle_input_task(
             KernelArguments(input_task_json=input_task_json)
         )
@@ -151,12 +157,7 @@ async def input_task_endpoint(input_task: InputTask, request: Request):
                         "description": input_task.description,
                     }
                 )
-                return {
-                    "status": "Error: Failed to create plan",
-                    "session_id": input_task.session_id,
-                    "plan_id": "",
-                    "description": input_task.description,
-                }
+                raise HTTPException(status_code=400, detail="Error: Failed to create plan")
 
         # Log custom event for successful input task processing
         track_event_if_configured(
@@ -186,16 +187,13 @@ async def input_task_endpoint(input_task: InputTask, request: Request):
                 "error": str(e),
             }
         )
-        return {
-            "status": f"Error creating plan: {str(e)}",
-            "session_id": input_task.session_id,
-            "plan_id": "",
-            "description": input_task.description,
-        }
+        raise HTTPException(status_code=400, detail="Error creating plan")
+
 
 
 @app.post("/human_feedback")
 async def human_feedback_endpoint(human_feedback: HumanFeedback, request: Request):
+    
     """
     Receive human feedback on a step.
 
@@ -616,7 +614,7 @@ async def get_steps_by_plan(plan_id: str, request: Request) -> List[Step]:
               updated_action:
                 type: string
                 description: Optional modified action based on feedback
-      400:
+       400:
         description: Missing or invalid user information
       404:
         description: Plan or steps not found

src/backend/kernel_agents/agent_factory.py

@@ -21,10 +21,11 @@
 from kernel_agents.tech_support_agent import TechSupportAgent
 from kernel_agents.procurement_agent import ProcurementAgent
 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 context.cosmos_memory_kernel import CosmosMemoryContext
-from azure.ai.projects.models import Agent
+
 
 logger = logging.getLogger(__name__)
 

src/backend/kernel_agents/planner_agent.py

@@ -95,12 +95,21 @@ def __init__(
                                                      "TechSupportAgent", "GenericAgent"]
         self._agent_tools_list = agent_tools_list or []
 
-        # Create the planning function
+        # Create the planning function using prompt_template_config instead of direct string
+        from semantic_kernel.prompt_template.prompt_template_config import PromptTemplateConfig
+        
+        # Create a proper prompt template configuration
+        prompt_config = PromptTemplateConfig(
+            template=self._system_message,
+            name="PlannerFunction",
+            description="Creates and manages execution plans"
+        )
+        
         self._planner_function = KernelFunction.from_prompt(
             function_name="PlannerFunction",
             plugin_name="planner_plugin",
-            prompt_template=self._system_message,
-            description="Creates and manages execution plans"
+            description="Creates and manages execution plans",
+            prompt_template_config=prompt_config
         )
         self._kernel.add_function("planner_plugin", self._planner_function)
 
@@ -251,8 +260,30 @@ async def _create_structured_plan(self, input_task: InputTask) -> Tuple[Plan, Li
 
             # Ask the LLM to generate a structured plan
             args = KernelArguments(input=instruction)
-            result = await self._planner_function.invoke_async(kernel_arguments=args)
-            response_content = result.value.strip()
+            
+            # Try different invocation methods based on available API
+            try:
+                # Method 1: Try direct invoke method (newer SK versions)
+                result = await self._kernel.invoke(
+                    self._planner_function,
+                    args
+                )
+            except (AttributeError, TypeError) as e:
+                # Method 2: Try using the kernel to invoke the function by name
+                logging.debug(f"First invoke method failed: {e}, trying alternative")
+                result = await self._kernel.invoke_function_async(
+                    "planner_plugin",
+                    "PlannerFunction", 
+                    input=instruction
+                )
+                
+            # Extract the response content
+            if hasattr(result, 'value'):
+                response_content = result.value.strip()
+            elif isinstance(result, str):
+                response_content = result.strip()
+            else:
+                response_content = str(result).strip()
 
             # Parse the JSON response using the structured output model
             try:
@@ -276,11 +307,11 @@ async def _create_structured_plan(self, input_task: InputTask) -> Tuple[Plan, Li
                 summary = parsed_result.summary_plan_and_steps
                 human_clarification_request = parsed_result.human_clarification_request
 
-                # Create the Plan instance
+                # Create the Plan instance - use self._user_id instead of input_task.user_id
                 plan = Plan(
                     id=str(uuid.uuid4()),
                     session_id=input_task.session_id,
-                    user_id=input_task.user_id,
+                    user_id=self._user_id,  # Use the agent's user_id instead
                     initial_goal=initial_goal,
                     overall_status=PlanStatus.in_progress,
                     summary=summary,
@@ -294,7 +325,7 @@ async def _create_structured_plan(self, input_task: InputTask) -> Tuple[Plan, Li
                     "Planner - Initial plan and added into the cosmos",
                     {
                         "session_id": input_task.session_id,
-                        "user_id": input_task.user_id,
+                        "user_id": self._user_id,  # Use the agent's user_id
                         "initial_goal": initial_goal,
                         "overall_status": PlanStatus.in_progress,
                         "source": "PlannerAgent",
@@ -314,11 +345,12 @@ async def _create_structured_plan(self, input_task: InputTask) -> Tuple[Plan, Li
                         logging.warning(f"Invalid agent name: {agent_name}, defaulting to GenericAgent")
                         agent_name = "GenericAgent"
 
-                    # Create the step
+                    # Create the step - use self._user_id instead of input_task.user_id
                     step = Step(
                         id=str(uuid.uuid4()),
                         plan_id=plan.id,
                         session_id=input_task.session_id,
+                        user_id=self._user_id,  # Use the agent's user_id
                         action=action,
                         agent=agent_name,
                         status=StepStatus.planned,
@@ -337,7 +369,7 @@ async def _create_structured_plan(self, input_task: InputTask) -> Tuple[Plan, Li
                             "agent": agent_name,
                             "status": StepStatus.planned,
                             "session_id": input_task.session_id,
-                            "user_id": input_task.user_id,
+                            "user_id": self._user_id,  # Use the agent's user_id
                             "human_approval_status": HumanFeedbackStatus.requested,
                         },
                     )
@@ -356,19 +388,19 @@ async def _create_structured_plan(self, input_task: InputTask) -> Tuple[Plan, Li
                 f"Planner - Error in create_structured_plan: {e} into the cosmos",
                 {
                     "session_id": input_task.session_id,
-                    "user_id": input_task.user_id,
+                    "user_id": self._user_id,  # Use the agent's user_id
                     "initial_goal": "Error generating plan",
                     "overall_status": PlanStatus.failed,
                     "source": "PlannerAgent",
                     "summary": f"Error generating plan: {e}",
                 },
             )
 
-            # Create an error plan
+            # Create an error plan - use self._user_id instead of input_task.user_id
             error_plan = Plan(
                 id=str(uuid.uuid4()),
                 session_id=input_task.session_id,
-                user_id=input_task.user_id,
+                user_id=self._user_id,  # Use the agent's user_id
                 initial_goal="Error generating plan",
                 overall_status=PlanStatus.failed,
                 summary=f"Error generating plan: {str(e)}"
@@ -395,7 +427,7 @@ async def _create_plan_from_text(self, input_task: InputTask, text_content: str)
         plan = Plan(
             id=str(uuid.uuid4()),
             session_id=input_task.session_id,
-            user_id=input_task.user_id,
+            user_id=self._user_id,
             initial_goal=goal,
             overall_status=PlanStatus.in_progress
         )
@@ -428,6 +460,7 @@ async def _create_plan_from_text(self, input_task: InputTask, text_content: str)
                 id=str(uuid.uuid4()),
                 plan_id=plan.id,
                 session_id=input_task.session_id,
+                user_id=self._user_id,
                 action=action,
                 agent=agent,
                 status=StepStatus.planned,
@@ -454,6 +487,7 @@ def _generate_instruction(self, objective: str) -> str:
         # Create list of available tools
         tools_str = "\n".join(self._agent_tools_list) if self._agent_tools_list else "Various specialized tools"
 
+        # Use double curly braces to escape them in f-strings
         return f"""
         You are the Planner, an AI orchestrator that manages a group of AI agents to accomplish tasks.
 
@@ -496,15 +530,15 @@ def _generate_instruction(self, objective: str) -> str:
         Choose from {agents_str} ONLY for planning your steps.
         
         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" 
-        }
+        }}
         """