fixing input task

Author: Fr4nc3

src/backend/app_kernel.py

@@ -40,15 +40,15 @@
 from models.agent_types import AgentType
 from kernel_agents.agent_factory import AgentFactory
 
-# Check if the Application Insights Instrumentation Key is set in the environment variables
-instrumentation_key = os.getenv("APPLICATIONINSIGHTS_INSTRUMENTATION_KEY")
-if instrumentation_key:
-    # Configure Application Insights if the Instrumentation Key is found
-    configure_azure_monitor(connection_string=instrumentation_key)
-    logging.info("Application Insights configured with the provided Instrumentation Key")
-else:
-    # Log a warning if the Instrumentation Key is not found
-    logging.warning("No Application Insights Instrumentation Key found. Skipping configuration")
+# # Check if the Application Insights Instrumentation Key is set in the environment variables
+# instrumentation_key = os.getenv("APPLICATIONINSIGHTS_INSTRUMENTATION_KEY")
+# if instrumentation_key:
+#     # Configure Application Insights if the Instrumentation Key is found
+#     configure_azure_monitor(connection_string=instrumentation_key)
+#     logging.info("Application Insights configured with the provided Instrumentation Key")
+# else:
+#     # Log a warning if the Instrumentation Key is not found
+#     logging.warning("No Application Insights Instrumentation Key found. Skipping configuration")
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -59,10 +59,10 @@
 )
 logging.getLogger("azure.identity.aio._internal").setLevel(logging.WARNING)
 
-# Suppress info logs from OpenTelemetry exporter
-logging.getLogger("azure.monitor.opentelemetry.exporter.export._base").setLevel(
-    logging.WARNING
-)
+# # Suppress info logs from OpenTelemetry exporter
+# logging.getLogger("azure.monitor.opentelemetry.exporter.export._base").setLevel(
+#     logging.WARNING
+# )
 
 # Initialize the FastAPI app
 app = FastAPI()
@@ -132,9 +132,10 @@ async def input_task_endpoint(input_task: InputTask, request: Request):
         input_task_data["user_id"] = user_id
         input_task_json = json.dumps(input_task_data)
 
+        logging.info(f"Input task: {input_task}")
         # Use the planner to handle the task
         result = await planner_agent.handle_input_task(
-            KernelArguments(input_task_json=input_task_json)
+            input_task
         )
 
         print(f"Result: {result}")

src/backend/kernel_agents/agent_factory.py

@@ -25,8 +25,12 @@
 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
+from models.messages_kernel import PlannerResponsePlan
 
-
+from azure.ai.projects.models import (
+    ResponseFormatJsonSchema,
+    ResponseFormatJsonSchemaType,
+)
 logger = logging.getLogger(__name__)
 
 
@@ -348,7 +352,14 @@ async def create_all_agents(
             session_id=session_id,
             user_id=user_id,
             temperature=temperature,
-            agent_instances=agent_instances  # Pass agent instances to the planner
+            agent_instances=agent_instances,  # Pass agent instances to the planner
+            response_format=ResponseFormatJsonSchemaType(
+                    json_schema=ResponseFormatJsonSchema(
+            name=PlannerResponsePlan.__name__,
+            description=f"respond with {PlannerResponsePlan.__name__.lower()}",
+            schema=PlannerResponsePlan.model_json_schema(),
+        )
+    )
         )
         agents[planner_agent_type] = planner_agent
 

src/backend/kernel_agents/planner_agent.py

@@ -15,6 +15,7 @@
     AgentMessage,
     InputTask,
     Plan,
+    PlannerResponsePlan,
     Step,
     StepStatus,
     PlanStatus,
@@ -23,16 +24,6 @@
 from event_utils import track_event_if_configured
 from app_config import config
 
-# Define structured output models
-class StructuredOutputStep(BaseModel):
-    action: str = Field(description="Detailed description of the step action")
-    agent: str = Field(description="Name of the agent to execute this step")
-
-class StructuredOutputPlan(BaseModel):
-    initial_goal: str = Field(description="The goal of the plan")
-    steps: List[StructuredOutputStep] = Field(description="List of steps to achieve the goal")
-    summary_plan_and_steps: str = Field(description="Brief summary of the plan and steps")
-    human_clarification_request: Optional[str] = Field(None, description="Any additional information needed from the human")
 
 class PlannerAgent(BaseAgent):
     """Planner agent implementation using Semantic Kernel.
@@ -125,7 +116,7 @@ async def async_init(self) -> None:
             logging.error(f"Failed to create Azure AI Agent for PlannerAgent: {e}")
             raise
 
-    async def handle_input_task(self, kernel_arguments: KernelArguments) -> str:
+    async def handle_input_task(self, input_task: InputTask) -> str:
         """Handle the initial input task from the user.
         
         Args:
@@ -135,15 +126,19 @@ async def handle_input_task(self, kernel_arguments: KernelArguments) -> str:
             Status message
         """
         # Parse the input task
-        input_task_json = kernel_arguments["input_task_json"]
-        input_task = InputTask.parse_raw(input_task_json)
+        logging.info("Handling input task")
+
+        logging.info(f"Parsed input task: {input_task}")
 
         # Generate a structured plan with steps
+        
+        logging.info(f"Received input task: {input_task.description}")
+        logging.info(f"Session ID: {input_task.session_id}, User ID: {self._user_id}")
         plan, steps = await self._create_structured_plan(input_task)
 
-        print(f"Plan created: {plan}")
+        logging.info(f"Plan created: {plan}")
+        logging.info(f"Steps created: {steps}")
 
-        print(f"Steps created: {steps}")
 
 
         if steps:
@@ -273,8 +268,13 @@ async def _create_structured_plan(self, input_task: InputTask) -> Tuple[Plan, Li
         """
         try:
             # Generate the instruction for the LLM
+            logging.info("Generating instruction for the LLM")
+            logging.debug(f"Input: {input_task}")
+            logging.debug(f"Available agents: {self._available_agents}")
+
             instruction = self._generate_instruction(input_task.description)
 
+            logging.info(f"Generated instruction: {instruction}")   
             # Log the input task for debugging
             logging.info(f"Creating plan for task: '{input_task.description}'")
             logging.info(f"Using available agents: {self._available_agents}")
@@ -294,17 +294,17 @@ async def _create_structured_plan(self, input_task: InputTask) -> Tuple[Plan, Li
             kernel_args = KernelArguments()
             kernel_args["input"] = f"TASK: {input_task.description}\n\n{instruction}"
 
-            print(f"Kernel arguments: {kernel_args}")
+            logging.debug(f"Kernel arguments: {kernel_args}")
 
             # Call invoke with proper keyword arguments
             response_content = ""
 
-            # Use keyword arguments instead of positional arguments
-            # Set a lower temperature to ensure consistent results
+            # Ensure we're using the right pattern for Azure AI agents with semantic kernel
+            # Properly handle async generation
             async_generator = self._azure_ai_agent.invoke(
                 arguments=kernel_args,
                 settings={
-                    "temperature": 0.0
+                    "temperature": 0.0,  # Keep temperature low for consistent planning
                 }
             )
 
@@ -313,13 +313,8 @@ async def _create_structured_plan(self, input_task: InputTask) -> Tuple[Plan, Li
                 if chunk is not None:
                     response_content += str(chunk)
 
-            print(f"Response content: {response_content}")
-            
-            # Debug the response
-            logging.info(f"Response content length: {len(response_content)}")
-            logging.debug(f"Response content first 500 chars: {response_content[:500]}")
-            # Log more of the response for debugging
-            logging.info(f"Full response: {response_content}")
+
+            logging.info(f"Response content: {response_content}")
 
             # Check if response is empty or whitespace
             if not response_content or response_content.isspace():
@@ -329,7 +324,7 @@ async def _create_structured_plan(self, input_task: InputTask) -> Tuple[Plan, Li
             try:
                 # First try to parse using Pydantic model
                 try:
-                    parsed_result = StructuredOutputPlan.parse_raw(response_content)
+                    parsed_result = PlannerResponsePlan.parse_raw(response_content)
                 except Exception as e1:
                     logging.warning(f"Failed to parse direct JSON with Pydantic: {str(e1)}")
 
@@ -339,12 +334,12 @@ async def _create_structured_plan(self, input_task: InputTask) -> Tuple[Plan, Li
                         json_content = json_match.group(1)
                         logging.info(f"Found JSON content in markdown code block, length: {len(json_content)}")
                         try:
-                            parsed_result = StructuredOutputPlan.parse_raw(json_content)
+                            parsed_result = PlannerResponsePlan.parse_raw(json_content)
                         except Exception as e2:
                             logging.warning(f"Failed to parse extracted JSON with Pydantic: {str(e2)}")
                             # Try conventional JSON parsing as fallback
                             json_data = json.loads(json_content)
-                            parsed_result = StructuredOutputPlan.parse_obj(json_data)
+                            parsed_result = PlannerResponsePlan.parse_obj(json_data)
                     else:
                         # Try to extract JSON without code blocks - maybe it's embedded in text
                         # Look for patterns like { ... } that contain "initial_goal" and "steps"
@@ -356,12 +351,12 @@ async def _create_structured_plan(self, input_task: InputTask) -> Tuple[Plan, Li
                             logging.info(f"Found potential JSON in text, length: {len(potential_json)}")
                             try:
                                 json_data = json.loads(potential_json)
-                                parsed_result = StructuredOutputPlan.parse_obj(json_data)
+                                parsed_result = PlannerResponsePlan.parse_obj(json_data)
                             except Exception as e3:
                                 logging.warning(f"Failed to parse potential JSON: {str(e3)}")
                                 # If all extraction attempts fail, try parsing the whole response as JSON
                                 json_data = json.loads(response_content)
-                                parsed_result = StructuredOutputPlan.parse_obj(json_data)
+                                parsed_result = PlannerResponsePlan.parse_obj(json_data)
                         else:
                             # If we can't find JSON patterns, create a fallback plan from the text
                             logging.info("Using fallback plan creation from text response")