init changes

Author: marktayl1

src/backend/app_kernel.py

@@ -2,41 +2,32 @@
 import asyncio
 import logging
 import os
+# Azure monitoring
+import re
 import uuid
 from typing import Dict, List, Optional
 
 # Semantic Kernel imports
 from app_config import config
 from auth.auth_utils import get_authenticated_user_details
-
-# Azure monitoring
-import re
-from dateutil import parser
 from azure.monitor.opentelemetry import configure_azure_monitor
 from config_kernel import Config
+from dateutil import parser
 from event_utils import track_event_if_configured
-
 # FastAPI imports
 from fastapi import FastAPI, HTTPException, Query, Request
 from fastapi.middleware.cors import CORSMiddleware
 from kernel_agents.agent_factory import AgentFactory
-
 # Local imports
 from middleware.health_check import HealthCheckMiddleware
-from models.messages_kernel import (
-    AgentMessage,
-    AgentType,
-    HumanClarification,
-    HumanFeedback,
-    InputTask,
-    PlanWithSteps,
-    Step,
-    UserLanguage
-)
-
+from models.messages_kernel import (AgentMessage, AgentType,
+                                    HumanClarification, HumanFeedback,
+                                    InputTask, PlanWithSteps, Step,
+                                    UserLanguage)
 # Updated import for KernelArguments
 from utils_kernel import initialize_runtime_and_context, rai_success
-
+from v3.orchestration.manager import OnboardingOrchestrationManager
+from v3.scenarios.onboarding_cases import MagenticScenarios
 
 # Check if the Application Insights Instrumentation Key is set in the environment variables
 connection_string = os.getenv("APPLICATIONINSIGHTS_CONNECTION_STRING")
@@ -281,6 +272,119 @@ async def input_task_endpoint(input_task: InputTask, request: Request):
         )
         raise HTTPException(status_code=400, detail=f"Error creating plan: {error_msg}") from e
 
+@app.post("/api/input_task_2")
+async def input_task_endpoint_2(input_task: InputTask, request: Request):
+    """
+    Receive the initial input task from the user.
+    """
+    # Fix 1: Properly await the async rai_success function
+    if not await rai_success(input_task.description, True):
+        print("RAI failed")
+
+        track_event_if_configured(
+            "RAI failed",
+            {
+                "status": "Plan not created",
+                "description": input_task.description,
+                "session_id": input_task.session_id,
+            },
+        )
+
+        return {
+            "status": "Plan not created",
+        }
+    authenticated_user = get_authenticated_user_details(request_headers=request.headers)
+    user_id = authenticated_user["user_principal_id"]
+
+    if not user_id:
+        track_event_if_configured(
+            "UserIdNotFound", {"status_code": 400, "detail": "no user"}
+        )
+        raise HTTPException(status_code=400, detail="no user")
+
+    # Generate session ID if not provided
+    if not input_task.session_id:
+        input_task.session_id = str(uuid.uuid4())
+
+    try:
+        # Create all agents instead of just the planner agent
+        # This ensures other agents are created first and the planner has access to them
+        # <? Do we need to do this every time? >
+        kernel, memory_store = await initialize_runtime_and_context(
+            input_task.session_id, user_id
+        )
+        client = None
+        try:
+            client = config.get_ai_project_client()
+        except Exception as client_exc:
+            logging.error(f"Error creating AIProjectClient: {client_exc}")
+
+        agents = await AgentFactory.create_all_agents(
+            session_id=input_task.session_id,
+            user_id=user_id,
+            memory_store=memory_store,
+            client=client,
+        )
+
+        group_chat_manager = agents[AgentType.GROUP_CHAT_MANAGER.value]
+
+        # Convert input task to JSON for the kernel function, add user_id here
+
+        # Use the planner to handle the task
+        await group_chat_manager.handle_input_task(input_task)
+
+        # Get plan from memory store
+        plan = await memory_store.get_plan_by_session(input_task.session_id)
+
+        if not plan:  # If the plan is not found, raise an error
+            track_event_if_configured(
+                "PlanNotFound",
+                {
+                    "status": "Plan not found",
+                    "session_id": input_task.session_id,
+                    "description": input_task.description,
+                },
+            )
+            raise HTTPException(status_code=404, detail="Plan not found")
+        # Log custom event for successful input task processing
+        track_event_if_configured(
+            "InputTaskProcessed",
+            {
+                "status": f"Plan created with ID: {plan.id}",
+                "session_id": input_task.session_id,
+                "plan_id": plan.id,
+                "description": input_task.description,
+            },
+        )
+        if client:
+            try:
+                client.close()
+            except Exception as e:
+                logging.error(f"Error sending to AIProjectClient: {e}")
+        return {
+            "status": f"Plan created with ID: {plan.id}",
+            "session_id": input_task.session_id,
+            "plan_id": plan.id,
+            "description": input_task.description,
+        }
+
+    except Exception as e:
+        # Extract clean error message for rate limit errors
+        error_msg = str(e)
+        if "Rate limit is exceeded" in error_msg:
+            match = re.search(r"Rate limit is exceeded\. Try again in (\d+) seconds?\.", error_msg)
+            if match:
+                error_msg = f"Rate limit is exceeded. Try again in {match.group(1)} seconds."
+
+        track_event_if_configured(
+            "InputTaskError",
+            {
+                "session_id": input_task.session_id,
+                "description": input_task.description,
+                "error": str(e),
+            },
+        )
+        raise HTTPException(status_code=400, detail=f"Error creating plan: {error_msg}") from e
 
 @app.post("/api/human_feedback")
 async def human_feedback_endpoint(human_feedback: HumanFeedback, request: Request):

src/backend/v3/callbacks/__init__.py

@@ -0,0 +1 @@
+# Callbacks package for handling agent responses and streaming

src/backend/v3/callbacks/global_debug.py

@@ -0,0 +1,15 @@
+
+class DebugGlobalAccess:
+    """Class to manage global access to the Magentic orchestration manager."""
+    
+    _managers = []
+
+    @classmethod
+    def add_manager(cls, manager):
+        """Add a new manager to the global list."""
+        cls._managers.append(manager)
+
+    @classmethod
+    def get_managers(cls):
+        """Get the list of all managers."""
+        return cls._managers

src/backend/v3/callbacks/response_handlers.py

@@ -0,0 +1,140 @@
+"""
+Enhanced response callbacks for employee onboarding agent system.
+Provides detailed monitoring and response handling for different agent types.
+"""
+
+import sys
+from semantic_kernel.contents import ChatMessageContent, StreamingChatMessageContent
+
+def enhanced_agent_response_callback(message: ChatMessageContent) -> None:
+    """Enhanced callback to monitor agent responses with detailed information."""
+    
+    # Get basic message information
+    message_type = type(message).__name__
+    role = getattr(message, 'role', 'unknown')
+    metadata = getattr(message, 'metadata', {})
+    agent_name = message.name or "Unknown Agent"
+    
+    # Handle different agent types with specific formatting
+    if "Coder" in agent_name:
+        _handle_coder_response(message, agent_name, message_type)
+    elif "Reasoning" in agent_name:
+        _handle_reasoning_response(message, agent_name, message_type, role)
+    elif "Research" in agent_name or "Enhanced" in agent_name:
+        _handle_research_response(message, agent_name, message_type, role, metadata)
+    else:
+        _handle_default_response(message, agent_name, message_type, role)
+
+def _handle_coder_response(message, agent_name, message_type):
+    """Handle coder agent responses with code execution details."""
+    if hasattr(message, 'items') and message.items and len(message.items) > 0:
+        for item in message.items:
+            if hasattr(item, 'text') and item.text:
+                print(item.text, end='', flush=True)
+    
+    content = message.content or ""
+    if content.strip():
+        print(content, end='', flush=True)
+
+def _handle_reasoning_response(message, agent_name, message_type, role):
+    """Handle reasoning agent responses with logical process details."""
+    print(f"\n🧠 **{agent_name}** [{message_type}] (role: {role})")
+    print("-" * (len(agent_name) + len(message_type) + 15))
+    
+    if hasattr(message, 'items') and message.items:
+        for item in message.items:
+            if hasattr(item, 'function_name') and item.function_name:
+                print(f"🔧 Function Call: {item.function_name}")
+            if hasattr(item, 'text') and item.text:
+                print(item.text, end='', flush=True)
+    
+    content = message.content or ""
+    if content.strip():
+        print(f"💭 Reasoning: {content}")
+    
+    sys.stdout.flush()
+    print()
+
+def _handle_research_response(message, agent_name, message_type, role, metadata):
+    """Handle research agent responses with search result details."""
+    print(f"\n🔍 **{agent_name}** [{message_type}] (role: {role})")
+    print("-" * (len(agent_name) + len(message_type) + 15))
+    
+    if metadata:
+        print(f"📋 Metadata: {metadata}")
+    
+    # Show detailed search results if available
+    if hasattr(message, 'items') and message.items and len(message.items) > 0:
+        print(f"🔧 Found {len(message.items)} items in message")
+        
+        for i, item in enumerate(message.items):
+            print(f"   Item {i+1}:")
+            
+            if hasattr(item, 'function_name'):
+                print(f"      Function Name: {item.function_name}")
+            
+            if hasattr(item, 'arguments'):
+                print(f"      Arguments: {item.arguments}")
+            
+            if hasattr(item, 'text') and item.text:
+                print(f"      Text: {item.text[:200]}...")
+            
+            # Extract Bing search results
+            if hasattr(item, 'response_metadata'):
+                _parse_search_results(item.response_metadata)
+    
+    content = message.content or ""
+    if content.strip():
+        print(f"💬 Content: {content}")
+    else:
+        print("💬 Content: [Empty]")
+    
+    sys.stdout.flush()
+    print()
+
+def _parse_search_results(response_meta):
+    """Parse and display Bing search results from metadata."""
+    print(f"      Response Metadata: {str(response_meta)[:300]}...")
+    
+    if isinstance(response_meta, str):
+        try:
+            import json
+            parsed_meta = json.loads(response_meta)
+            if 'webPages' in parsed_meta:
+                web_pages = parsed_meta.get('webPages', {})
+                total_docs = web_pages.get('totalEstimatedMatches', 0)
+                available_docs = len(web_pages.get('value', []))
+                print(f"      📊 BING SEARCH RESULTS: {available_docs} docs returned, ~{total_docs} total matches")
+                
+                # Show first few results
+                for j, page in enumerate(web_pages.get('value', [])[:3]):
+                    title = page.get('name', 'No title')[:50]
+                    url = page.get('url', 'No URL')[:80]
+                    print(f"         Result {j+1}: {title} - {url}")
+        except Exception as parse_error:
+            print(f"      ⚠️ Could not parse search results: {parse_error}")
+
+def _handle_default_response(message, agent_name, message_type, role):
+    """Handle default agent responses."""
+    print(f"\n🤖 **{agent_name}** [{message_type}] (role: {role})")
+    print("-" * (len(agent_name) + len(message_type) + 15))
+    
+    content = message.content or ""
+    if content.strip():
+        print(f"💬 Content: {content}")
+    else:
+        print("💬 Content: [Empty]")
+    
+    sys.stdout.flush()
+    print()
+
+async def streaming_agent_response_callback(streaming_message: StreamingChatMessageContent, is_final: bool) -> None:
+    """Simple streaming callback to show real-time agent responses."""
+    
+    # Print streaming content as it arrives
+    if hasattr(streaming_message, 'content') and streaming_message.content:
+        print(streaming_message.content, end='', flush=True)
+    
+    # Add a newline when the streaming is complete for this message
+    if is_final:
+        print()

src/backend/v3/config/__init__.py

@@ -0,0 +1 @@
+# Configuration package for Magentic Example