returns console results

Author: marktayl1

src/backend/app_kernel.py

@@ -10,7 +10,6 @@
 
 from auth.auth_utils import get_authenticated_user_details
 from azure.monitor.opentelemetry import configure_azure_monitor
-# Semantic Kernel imports
 from common.config.app_config import config
 from common.database.database_factory import DatabaseFactory
 from common.models.messages_kernel import (AgentMessage, AgentType,
@@ -28,6 +27,8 @@
 # Local imports
 from middleware.health_check import HealthCheckMiddleware
 from v3.api.router import app_v3
+# Semantic Kernel imports
+from v3.config.settings import orchestration_config
 from v3.magentic_agents.magentic_agent_factory import (cleanup_all_agents,
                                                        get_agents)
 
@@ -60,17 +61,15 @@
 )
 
 
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    """Lifespan event handler to create and clean up agents."""
-    config.agents = await get_agents()
-    yield
-    await cleanup_all_agents()
-
-
+# @asynccontextmanager
+# async def lifespan(app: FastAPI):
+#     """Lifespan event handler to create and clean up agents."""
+#     config.agents = await get_agents()
+#     yield
+#     await cleanup_all_agents()
 
 # Initialize the FastAPI app
-app = FastAPI(lifespan=lifespan)
+app = FastAPI()
 
 frontend_url = config.FRONTEND_SITE_NAME
 
@@ -598,7 +597,7 @@ async def approve_step_endpoint(
 
         return {"status": "All steps approved"}
 
-
+# Get plans is called in the initial side rendering of the frontend
 @app.get("/api/plans")
 async def get_plans(
     request: Request,
@@ -662,13 +661,17 @@ async def get_plans(
       404:
         description: Plan not found
     """
+
     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")
+    
+    # Initialize agent team for this user session
+    await orchestration_config.get_current_orchestration(user_id=user_id)
 
     # Initialize memory context
     memory_store = await DatabaseFactory.get_database(user_id=user_id)

src/backend/common/config/app_config.py

@@ -77,7 +77,7 @@ def __init__(self):
         self._cosmos_database = None
         self._ai_project_client = None
 
-        self._agents = []
+        self._agents = {}
 
     def get_azure_credential(self, client_id=None):
         """
@@ -206,6 +206,15 @@ def set_user_local_browser_language(self, language: str):
         """
         os.environ["USER_LOCAL_BROWSER_LANGUAGE"] = language
 
+    # Get agent team list by user_id dictionary index
+    def get_agents(self) -> dict[str, list]:
+        """Get the list of agents configured in the application.
+
+        Returns:
+            A list of agent names or configurations
+        """
+        return self._agents
+
 
 # Create a global instance of AppConfig
 config = AppConfig()

src/backend/v3/api/router.py

@@ -1,34 +1,31 @@
-import uuid
-import logging
 import json
-from fastapi import APIRouter, Depends, HTTPException, UploadFile, File, Request
+import logging
+import uuid
 
 from auth.auth_utils import get_authenticated_user_details
-from common.models.messages_kernel import (
-    GeneratePlanRequest,
-    InputTask,
-    Plan,
-    PlanStatus,
-)
+from common.config.app_config import config
+from common.database.database_factory import DatabaseFactory
+from common.models.messages_kernel import (GeneratePlanRequest, InputTask,
+                                           Plan, PlanStatus)
 from common.utils.event_utils import track_event_if_configured
-from common.utils.utils_kernel import (
-    rai_success,
-    rai_validate_team_config,
-)
-from v3.common.services.team_service import TeamService
+from common.utils.utils_kernel import rai_success, rai_validate_team_config
+from fastapi import (APIRouter, Depends, File, HTTPException, Request,
+                     UploadFile)
 from kernel_agents.agent_factory import AgentFactory
-from common.database.database_factory import DatabaseFactory
+from semantic_kernel.agents.runtime import InProcessRuntime
+from v3.common.services.team_service import TeamService
+from v3.config.settings import orchestration_config
+from v3.models.models import MPlan, MStep
 from v3.models.orchestration_models import AgentType
-from common.config.app_config import config
 
 app_v3 = APIRouter(
     prefix="/api/v3",
     responses={404: {"description": "Not found"}},
 )
 
-
+# To do: change endpoint to process request
 @app_v3.post("/create_plan")
-async def create_plan_endpoint(input_task: InputTask, request: Request):
+async def process_request(input_task: InputTask, request: Request):
     """
     Create a new plan without full processing.
 
@@ -128,14 +125,24 @@ async def create_plan_endpoint(input_task: InputTask, request: Request):
         memory_store = await DatabaseFactory.get_database(user_id=user_id)
 
         # Create a new Plan object
-        plan = Plan(
-            session_id=input_task.session_id,
-            team_id=input_task.team_id,
-            user_id=user_id,
-            initial_goal=input_task.description,
-            overall_status=PlanStatus.in_progress,
-            source=AgentType.PLANNER.value,
-        )
+        plan = MPlan()
+        #     session_id=input_task.session_id,
+        #     team_id=input_task.team_id,
+        #     user_id=user_id,
+        #     initial_goal=input_task.description,
+        #     overall_status=PlanStatus.in_progress,
+        #     source=AgentType.PLANNER.value,
+        # )
+
+        # setup and call the magentic orchestration
+        magentic_orchestration = await orchestration_config.get_current_orchestration(user_id)
+
+        runtime = InProcessRuntime()
+        runtime.start()
+
+        # invoke returns immediately, wait on result.get
+        orchestration_result = await magentic_orchestration.invoke(task=input_task.description,runtime=runtime)
+        team_result = await orchestration_result.get()
 
         # Save the plan to the database
         await memory_store.add_plan(plan)

src/backend/v3/callbacks/response_handlers.py

@@ -4,137 +4,46 @@
 """
 
 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', {})
+from semantic_kernel.contents import (ChatMessageContent,
+                                      StreamingChatMessageContent)
+
+coderagent = False
+
+def agent_response_callback(message: ChatMessageContent) -> None:
+    """Observer function to print detailed information about streaming messages."""
+    global coderagent
+    # import sys
+
+    # Get agent name to determine handling
     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)
+    # Debug information about the message
+    message_type = type(message).__name__
+    metadata = getattr(message, 'metadata', {})
+    # when streaming code - list the coder info first once - 
+    if 'code' in metadata and metadata['code'] is True:
+        if coderagent == False:
+            print(f"\n🧠 **{agent_name}** [{message_type}]")
+            print("-" * (len(agent_name) + len(message_type) + 10))
+            coderagent = True
+        print(message.content, end='', flush=False)
+        return
+    elif coderagent == True:
+        coderagent = False
+    role = getattr(message, 'role', 'unknown')
 
-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))
-    
+    print("-" * (len(agent_name) + len(message_type) + 10))
+    if message.items[-1].content_type == 'function_call':
+        print(f"🔧 Function call: {message.items[-1].function_name}, Arguments: {message.items[-1].arguments}")
     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()
-
+# Add this function after your agent_response_callback function
 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()
+    if streaming_message.name != "CoderAgent":
+        # Print streaming content as it arrives
+        if hasattr(streaming_message, 'content') and streaming_message.content:
+            print(streaming_message.content, end='', flush=False)

src/backend/v3/config/settings.py

@@ -4,11 +4,14 @@
 """
 
 import os
-from semantic_kernel.connectors.ai.open_ai import (
-    AzureChatCompletion,
-    OpenAIChatPromptExecutionSettings,
-)
+
 from common.config.app_config import config
+from semantic_kernel.agents.orchestration.magentic import MagenticOrchestration
+from semantic_kernel.connectors.ai.open_ai import (
+    AzureChatCompletion, OpenAIChatPromptExecutionSettings)
+from v3.magentic_agents.magentic_agent_factory import (cleanup_all_agents,
+                                                       get_agents)
+from v3.orchestration.manager import init_orchestration
 
 
 class AzureConfig:
@@ -55,8 +58,22 @@ def get_headers(self, token):
             if token
             else {}
         )
+    
+class OrchestrationConfig:
+    """Configuration for orchestration settings."""
+
+    def __init__(self):
+        self._orchestrations = {}
+
+    async def get_current_orchestration(self, user_id: str) -> MagenticOrchestration:
+        """Initialize or get existing orchestration instance."""
+        if user_id not in self._orchestrations:
+            agents = await get_agents()
+            self._orchestrations[user_id] = await init_orchestration(agents)
+        return self._orchestrations[user_id]
 
 
 # Global config instances
 azure_config = AzureConfig()
 mcp_config = MCPConfig()
+orchestration_config = OrchestrationConfig()