Merge pull request #490 from microsoft/macae-v3-dev-marktayl

Exception checking for agent creation

Author: marktayl1

data/agent_teams/marketing.json

@@ -12,7 +12,7 @@
       "name": "ProductAgent",
       "deployment_name": "gpt-4.1-mini",
       "icon": "",
-      "system_message": "You are a Product agent. You have knowledge about product management, development, and compliance guidelines. When asked to call a function, you should summarize back what was done.",
+      "system_message": "You are a Product agent. You have access to MCP tools which allow you to obtain knowledge about products, product management, development, and compliance guidelines. When asked to call one of these tools, you should summarize back what was done.",
       "description": "This agent specializes in product management, development, and related tasks. It can provide information about products, manage inventory, handle product launches, analyze sales data, and coordinate with other teams like marketing and tech support.",
       "use_rag": false,
       "use_mcp": true,
@@ -29,7 +29,7 @@
       "name": "MarketingAgent",
       "deployment_name": "gpt-4.1-mini",
       "icon": "",
-      "system_message": "You are a Marketing agent. You specialize in marketing strategy, campaign development, content creation, and market analysis. You help create effective marketing campaigns, analyze market data, and develop promotional content for products and services.",
+      "system_message": "You are a Marketing agent. You have access to a number of HR related MCP tools for tasks like campaign development, content creation, and market analysis. You help create effective marketing campaigns, analyze market data, and develop promotional content for products and services.",
       "description": "This agent specializes in marketing, campaign management, and analyzing market data.",
       "use_rag": false,
       "use_mcp": true,

src/backend/app_kernel.py

@@ -2,34 +2,20 @@
 import asyncio
 import logging
 import os
-
 # Azure monitoring
 import re
 import uuid
-
 from typing import Dict, List, Optional
 
-
 from azure.monitor.opentelemetry import configure_azure_monitor
 from common.config.app_config import config
-from common.models.messages_kernel import (
-    UserLanguage,
-)
-
-
+from common.models.messages_kernel import UserLanguage
 # FastAPI imports
-from fastapi import (
-    FastAPI,
-    Query,
-    Request,
-)
+from fastapi import FastAPI, Query, Request
 from fastapi.middleware.cors import CORSMiddleware
-
-
 # Local imports
 from middleware.health_check import HealthCheckMiddleware
 from v3.api.router import app_v3
-
 # Semantic Kernel imports
 from v3.orchestration.orchestration_manager import OrchestrationManager
 
@@ -118,4 +104,4 @@ async def user_browser_language_endpoint(user_language: UserLanguage, request: R
 if __name__ == "__main__":
     import uvicorn
 
-    uvicorn.run("app_kernel:app", host="127.0.0.1", port=8000, reload=True)
+    uvicorn.run("app_kernel:app", host="127.0.0.1", port=8000, reload=True, log_level="info", access_log=False)

src/backend/common/config/app_config.py

@@ -33,9 +33,9 @@ def __init__(self):
             "APPLICATIONINSIGHTS_CONNECTION_STRING"
         )
         self.APP_ENV = self._get_required("APP_ENV", "prod")
-        self.AZURE_AI_MODEL_DEPLOYMENT_NAME = self._get_required(
-            "AZURE_AI_MODEL_DEPLOYMENT_NAME", "gpt-4o"
-        )
+        # self.AZURE_AI_MODEL_DEPLOYMENT_NAME = self._get_required(
+        #     "AZURE_AI_MODEL_DEPLOYMENT_NAME", "gpt-4o"
+        # )
 
         self.AZURE_COGNITIVE_SERVICES = self._get_optional(
             "AZURE_COGNITIVE_SERVICES", "https://cognitiveservices.azure.com/.default"

src/backend/v3/config/settings.py

@@ -197,32 +197,25 @@ async def send_status_update_async(
             )
             return
 
-        print(f" websocket original message: {message}")
-        print(f" websocket message type: {type(message)}")
 
         # Convert message to proper format for frontend
         try:
             if hasattr(message, "to_dict"):
                 # Use the custom to_dict method if available
                 message_data = message.to_dict()
-                print(f" websocket used to_dict(): {message_data}")
             elif hasattr(message, "data") and hasattr(message, "type"):
                 # Handle structured messages with data property
                 message_data = message.data
-                print(f" websocket used message.data: {message_data}")
             elif isinstance(message, dict):
                 # Already a dictionary
                 message_data = message
-                print(f" websocket already dict: {message_data}")
             else:
                 # Convert to string if it's a simple type
                 message_data = str(message)
-                print(f" websocket converted to string: {message_data}")
         except Exception as e:
-            print(f"Error processing message data: {e}")
+            logger.error("Error processing message data: %s", e)
             message_data = str(message)
 
-        print(f" websocket final message_data: {message_data}")
 
         standard_message = {
             "type": message_type,

src/backend/v3/magentic_agents/foundry_agent.py

@@ -1,5 +1,6 @@
 """ Agent template for building foundry agents with Azure AI Search, Bing, and MCP plugins. """
 
+import asyncio
 import logging
 from typing import List, Optional
 
@@ -39,7 +40,7 @@ def __init__(self, agent_name: str,
         self._bing_connection = None
         self.logger = logging.getLogger(__name__)
         # input validation
-        if self.model_deployment_name is any(["o3", "o4-mini"]):
+        if self.model_deployment_name in ["o3", "o4-mini"]:
             raise ValueError("The current version of Foundry agents do not support reasoning models.")
 
     # async def _make_bing_tool(self) -> Optional[BingGroundingTool]:
@@ -76,9 +77,11 @@ async def _make_azure_search_tool(self) -> Optional[AzureAISearchTool]:
             return search_tool
 
         except Exception as ex:
-            self.logger.error(f"Azure AI Search tool creation failed: {ex}   Connection name: " /
-                              f"{self.search.connection_name}   Index name: {self.search.index_name}" /
-                              " Make sure the connection exists in Azure AI Foundry portal")
+            self.logger.error(
+                "Azure AI Search tool creation failed: %s | Connection name: %s | Index name: %s | "
+                "Make sure the connection exists in Azure AI Foundry portal",
+                ex, self.search.connection_name, self.search.index_name
+            )
             return None
 
     async def _collect_tools_and_resources(self) -> tuple[List, dict]:
@@ -133,14 +136,49 @@ async def _after_open(self) -> None:
         # Add MCP plugins if available
         plugins = [self.mcp_plugin] if self.mcp_plugin else []
 
-        self._agent = AzureAIAgent(
-            client=self.client,
-            definition=definition,
-            plugins=plugins,
-        )
+        try:
+            self._agent = AzureAIAgent(
+                client=self.client,
+                definition=definition,
+                plugins=plugins,
+            )
+        except Exception as ex:
+            self.logger.error("Failed to create AzureAIAgent: %s", ex)
+            raise
+
+        # After self._agent creation in _after_open:
+        # Diagnostics
+        try:
+            tool_names = [t.get("function", {}).get("name") for t in (definition.tools or []) if isinstance(t, dict)]
+            self.logger.info(
+                "Foundry agent '%s' initialized. Azure tools: %s | MCP plugin: %s",
+                self.agent_name,
+                tool_names,
+                getattr(self.mcp_plugin, 'name', None)
+            )
+            if not tool_names and not plugins:
+                self.logger.warning(
+                    "Foundry agent '%s' has no Azure tool definitions and no MCP plugin. "
+                    "Subsequent tool calls may fail.", self.agent_name
+                )
+        except Exception as diag_ex:
+            self.logger.warning("Diagnostics collection failed: %s", diag_ex)
 
         self.logger.info("%s initialized with %d tools and %d plugins", self.agent_name, len(tools), len(plugins))
 
+    async def fetch_run_details(self, thread_id: str, run_id: str):
+        """Fetch and log run details after a failure."""
+        try:
+            run = await self.client.agents.runs.get(thread=thread_id, run=run_id)
+            self.logger.error(
+                "Run failure details | status=%s | id=%s | last_error=%s | usage=%s",
+                getattr(run, 'status', None),
+                run_id,
+                getattr(run, 'last_error', None),
+                getattr(run, 'usage', None),
+            )
+        except Exception as ex:
+            self.logger.error("Could not fetch run details: %s", ex)
 
 async def create_foundry_agent(agent_name:str,
                                agent_description:str, 

src/backend/v3/orchestration/human_approval_manager.py

@@ -6,13 +6,12 @@
 import asyncio
 import re
 from typing import Any, List, Optional
-            # Create a progress ledger that indicates the request is satisfied (task complete)
-from semantic_kernel.agents.orchestration.magentic import (
-                ProgressLedger, ProgressLedgerItem)
+
 import v3.models.messages as messages
 from semantic_kernel.agents import Agent
 from semantic_kernel.agents.orchestration.magentic import (
-    MagenticContext, ProgressLedger, StandardMagenticManager)
+    MagenticContext, ProgressLedger, ProgressLedgerItem,
+    StandardMagenticManager)
 from semantic_kernel.agents.orchestration.prompts._magentic_prompts import (
     ORCHESTRATOR_TASK_LEDGER_FACTS_PROMPT,
     ORCHESTRATOR_TASK_LEDGER_PLAN_PROMPT,
@@ -22,6 +21,8 @@
                                 orchestration_config)
 from v3.models.models import MPlan, MStep
 
+# Create a progress ledger that indicates the request is satisfied (task complete)
+
 
 class HumanApprovalMagenticManager(StandardMagenticManager):
     """
@@ -45,6 +46,11 @@ def __init__(self, *args, **kwargs):
         """
 
         plan_append = """
+IMPORTANT: Never ask the user for information or clarification until all agents on the team have been asked first.
+
+EXAMPLE: If the user request involves product information, first ask all agents on the team to provide the information. 
+Do not ask the user unless all agents have been consulted and the information is still missing.
+
 Plan steps should always include a bullet point, followed by an agent name, followed by a description of the action
 to be taken. If a step involves multiple actions, separate them into distinct steps with an agent included in each step. If the step is taken by an agent that 
 is not part of the team, such as the MagenticManager, please always list the MagenticManager as the agent for that step. At any time, if more information is 

src/frontend/frontend_server.py

@@ -60,4 +60,4 @@ async def serve_app(full_path: str):
     return FileResponse(INDEX_HTML)
 
 if __name__ == "__main__":
-    uvicorn.run(app, host="127.0.0.1", port=3000)
+    uvicorn.run(app, host="127.0.0.1", port=3000, access_log=False, log_level="info")

src/mcp_server/mcp_server.py

@@ -32,7 +32,9 @@
 factory.register_service(TechSupportService())
 factory.register_service(MarketingService())
 factory.register_service(ProductService())
-factory.register_service(GeneralService())
+
+# General service has tests for llm to mcp connectivity
+#factory.register_service(GeneralService())
 
 # Register DataToolService with the dataset path
 #factory.register_service(DataToolService(dataset_path="datasets"))

src/mcp_server/services/hr_service.py

@@ -2,10 +2,11 @@
 Human Resources MCP tools service.
 """
 
-from typing import Dict, Any
-from core.factory import MCPToolBase, Domain
+from typing import Any, Dict
+
+from core.factory import Domain, MCPToolBase
 from utils.date_utils import format_date_for_user
-from utils.formatters import format_success_response, format_error_response
+from utils.formatters import format_error_response, format_success_response
 
 
 class HRService(MCPToolBase):
@@ -17,6 +18,123 @@ def __init__(self):
     def register_tools(self, mcp) -> None:
         """Register HR tools with the MCP server."""
 
+        @mcp.tool(tags={self.domain.value})
+        async def employee_onboarding_blueprint_flat(
+            employee_name: str | None = None,
+            start_date: str | None = None,
+            role: str | None = None
+        ) -> dict:
+            """
+            Ultra-minimal onboarding blueprint (flat list).
+            Agent usage:
+            1. Call this first when onboarding intent detected.
+            2. Filter steps to its own domain.
+            3. Execute in listed order while honoring depends_on.
+            """
+            return {
+                "version": "1.0",
+                "intent": "employee_onboarding",
+                "employee": {
+                    "name": employee_name,
+                    "start_date": start_date,
+                    "role": role
+                },
+                "steps": [
+                    # Pre-boarding
+                    {
+                        "id": "bg_check",
+                        "domain": "HR",
+                        "action": "Initiate background check",
+                        "tool": "initiate_background_check",
+                        "required": True,
+                        "params": ["employee_name", "check_type?"]
+                    },
+                    {
+                        "id": "configure_laptop",
+                        "domain": "TECH_SUPPORT",
+                        "action": "Provision and configure laptop",
+                        "tool": "configure_laptop",
+                        "required": True
+                    },
+                    {
+                        "id": "create_accounts",
+                        "domain": "TECH_SUPPORT",
+                        "action": "Create system accounts",
+                        "tool": "create_system_accounts",
+                        "required": True
+                    },
+
+                    # Day 1
+                    {
+                        "id": "orientation",
+                        "domain": "HR",
+                        "action": "Schedule orientation session",
+                        "tool": "schedule_orientation_session",
+                        "required": True,
+                        "depends_on": ["bg_check"],
+                        "params": ["employee_name", "date"]
+                    },
+                    {
+                        "id": "handbook",
+                        "domain": "HR",
+                        "action": "Provide employee handbook",
+                        "tool": "provide_employee_handbook",
+                        "required": True,
+                        "params": ["employee_name"]
+                    },
+                    {
+                        "id": "welcome_email",
+                        "domain": "TECH_SUPPORT",
+                        "action": "Send welcome email",
+                        "tool": "send_welcome_email",
+                        "required": False,
+                        "depends_on": ["create_accounts"]
+                    },
+
+                    # Week 1
+                    {
+                        "id": "mentor",
+                        "domain": "HR",
+                        "action": "Assign mentor",
+                        "tool": "assign_mentor",
+                        "required": False,
+                        "params": ["employee_name", "mentor_name?"]
+                    },
+                    {
+                        "id": "vpn",
+                        "domain": "TECH_SUPPORT",
+                        "action": "Set up VPN access",
+                        "tool": "setup_vpn_access",
+                        "required": False,
+                        "depends_on": ["create_accounts"]
+                    },
+                    {
+                        "id": "benefits",
+                        "domain": "HR",
+                        "action": "Register employee for benefits",
+                        "tool": "register_for_benefits",
+                        "required": True,
+                        "params": ["employee_name", "benefits_package?"]
+                    },
+                    {
+                        "id": "payroll",
+                        "domain": "HR",
+                        "action": "Set up payroll",
+                        "tool": "set_up_payroll",
+                        "required": True,
+                        "params": ["employee_name", "salary?"]
+                    },
+                    {
+                        "id": "id_card",
+                        "domain": "HR",
+                        "action": "Request ID card",
+                        "tool": "request_id_card",
+                        "required": False,
+                        "depends_on": ["bg_check"],
+                        "params": ["employee_name", "department?"]
+                    }
+                ]
+            }
         @mcp.tool(tags={self.domain.value})
         async def schedule_orientation_session(employee_name: str, date: str) -> str:
             """Schedule an orientation session for a new employee."""

src/mcp_server/services/marketing_service.py

@@ -13,7 +13,7 @@ class MarketingService(MCPToolBase):
     """Marketing tools for employee onboarding and management."""
 
     def __init__(self):
-        super().__init__(Domain.HR)
+        super().__init__(Domain.MARKETING)
 
     def register_tools(self, mcp) -> None:
         """Register Marketing tools with the MCP server."""