Merge branch 'dev' of https://github.com/microsoft/Multi-Agent-Custom-Automation-Engine-Solution-Accelerator into psl-ts-macetimerfinal

Author: Tejasri-Microsoft

conftest.py

@@ -2,6 +2,9 @@
 Test configuration for agent tests.
 """
 
+import sys
+from pathlib import Path
+
 import pytest
 
 # Add the agents path

src/backend/callbacks/response_handlers.py

@@ -17,6 +17,45 @@
 logger = logging.getLogger(__name__)
 
 
+def format_agent_display_name(raw_name: str) -> str:
+    """Convert raw agent IDs (e.g. 'HRHelperAgent', 'hr_helper_agent') to
+    human-readable display names (e.g. 'HR Helper Agent').
+
+    Applies similar splitting/casing logic as the frontend's
+    ``cleanTextToSpaces`` + ``getAgentDisplayName`` pipeline, but does NOT
+    strip the "Agent" suffix (the frontend handles that separately).
+    """
+    if not raw_name:
+        return "Assistant"
+
+    name = raw_name
+
+    # Replace underscores with spaces
+    name = name.replace("_", " ")
+
+    # Insert space before each uppercase letter preceded by a lowercase letter
+    # e.g. "HelperAgent" → "Helper Agent"
+    name = re.sub(r'([a-z])([A-Z])', r'\1 \2', name)
+
+    # Insert space between consecutive uppercase and an uppercase+lowercase pair
+    # e.g. "HRHelper" → "HR Helper"
+    name = re.sub(r'([A-Z]+)([A-Z][a-z])', r'\1 \2', name)
+
+    # Collapse multiple spaces
+    name = re.sub(r'\s+', ' ', name).strip()
+
+    # Title-case each word
+    name = name.title()
+
+    # Fix common acronyms back to uppercase (word-boundary safe)
+    _ACRONYMS = {'Hr': 'HR', 'It': 'IT', 'Ai': 'AI', 'Api': 'API',
+                 'Ui': 'UI', 'Db': 'DB', 'Kb': 'KB'}
+    for title_form, upper_form in _ACRONYMS.items():
+        name = re.sub(rf'\b{title_form}\b', upper_form, name)
+
+    return name
+
+
 def clean_citations(text: str) -> str:
     """Remove citation markers from agent responses while preserving formatting."""
     if not text:
@@ -66,6 +105,7 @@ def agent_response_callback(
     Final (non-streaming) agent response callback using agent_framework Message.
     """
     agent_name = getattr(message, "author_name", None) or agent_id or "Unknown Agent"
+    agent_name = format_agent_display_name(agent_name)
     role = getattr(message, "role", "assistant")
 
     # Message has a .text property that concatenates all TextContent items
@@ -107,6 +147,8 @@ async def streaming_agent_response_callback(
     if not user_id:
         return
 
+    display_name = format_agent_display_name(agent_id)
+
     try:
         chunk_text = getattr(update, "text", None)
         if not chunk_text:
@@ -123,7 +165,7 @@ async def streaming_agent_response_callback(
         contents = getattr(update, "contents", []) or []
         tool_calls = _extract_tool_calls_from_contents(contents)
         if tool_calls:
-            tool_message = AgentToolMessage(agent_name=agent_id)
+            tool_message = AgentToolMessage(agent_name=display_name)
             tool_message.tool_calls.extend(tool_calls)
             await connection_config.send_status_update_async(
                 tool_message,
@@ -134,7 +176,7 @@ async def streaming_agent_response_callback(
 
         if cleaned:
             streaming_payload = AgentMessageStreaming(
-                agent_name=agent_id,
+                agent_name=display_name,
                 content=cleaned,
                 is_final=is_final,
             )

src/backend/orchestration/orchestration_manager.py

@@ -16,6 +16,7 @@
                                             MagenticPlanReviewRequest)
 from agents.agent_factory import AgentFactory
 from callbacks.response_handlers import (agent_response_callback,
+                                         format_agent_display_name,
                                          streaming_agent_response_callback)
 from common.config.app_config import config
 from common.database.database_base import DatabaseBase
@@ -142,8 +143,20 @@ async def init_orchestration(
 
         manager_agent = Agent(manager_chat_client, name="MagenticManager")
 
+        # Collect participant agent names so the orchestrator plan prompt can
+        # enforce mandatory inclusion of every team agent (e.g. TriageAgent,
+        # ComplianceAgent) — otherwise the manager silently drops them.
+        participant_agent_names = []
+        for ag in agents:
+            nm = getattr(ag, "agent_name", None) or getattr(ag, "name", None)
+            if nm:
+                participant_agent_names.append(nm)
+
         # Get prompt customization kwargs
-        prompt_kwargs = get_magentic_prompt_kwargs(has_user_responses=has_user_responses)
+        prompt_kwargs = get_magentic_prompt_kwargs(
+            has_user_responses=has_user_responses,
+            participant_names=participant_agent_names,
+        )
 
         cls.logger.info(
             "Building MagenticBuilder for user '%s' with max_rounds=%d, "
@@ -782,12 +795,12 @@ async def _process_event_stream(
                             and executor != current_streaming_agent_ref[0]
                         ):
                             current_streaming_agent_ref[0] = executor
-                            display_name = executor.replace("_", " ")
+                            display_name = format_agent_display_name(executor)
                             header_text = f"\n\n---\n### {display_name}\n\n"
                             try:
                                 await connection_config.send_status_update_async(
                                     AgentMessageStreaming(
-                                        agent_name=executor,
+                                        agent_name=display_name,
                                         content=header_text,
                                         is_final=False,
                                     ),

src/backend/orchestration/plan_review_helpers.py

@@ -31,14 +31,23 @@
 # Prompt kwargs builder
 # ---------------------------------------------------------------------------
 
-def get_magentic_prompt_kwargs(*, has_user_responses: bool = False) -> dict:
+def get_magentic_prompt_kwargs(
+    *,
+    has_user_responses: bool = False,
+    participant_names: Optional[list[str]] = None,
+) -> dict:
     """Build the prompt-override kwargs dict for ``MagenticBuilder``.
 
     Args:
         has_user_responses: Whether any agent has ``user_responses: true``,
             giving it access to the ``ask_user`` tool for user clarification.
             When True, prompts allow agents to gather info via their tools;
             when False, agents must use defaults only.
+        participant_names: Names of the team's participant agents. When provided,
+            the orchestrator plan prompt is augmented with a MANDATORY AGENTS
+            clause requiring every one of these agents to appear as a plan step,
+            so coordinator-like agents (e.g. TriageAgent) and final-validation
+            agents (e.g. ComplianceAgent) are not silently dropped.
 
     Returns:
         A dict suitable for unpacking into ``MagenticBuilder(**kwargs)``.
@@ -70,12 +79,26 @@ def get_magentic_prompt_kwargs(*, has_user_responses: bool = False) -> dict:
 - Ask EXACTLY 0 questions. Always proceed with sensible defaults.
 """
 
+    mandatory_block = ""
+    if participant_names:
+        agent_lines = "\n".join(f"- {name}" for name in participant_names)
+        mandatory_block = (
+            "\n\nMANDATORY AGENTS (CRITICAL — NON-NEGOTIABLE):\n"
+            "Every plan you generate MUST include EVERY ONE of the following agents,\n"
+            "each as its own distinct step, each invoked at least once:\n"
+            + agent_lines
+            + "\nDo NOT omit any of these agents, even if a step seems optional,\n"
+            "redundant, already covered by another agent, or something you "
+            "(MagenticManager)\ncould do yourself. A plan missing any listed agent "
+            "is INVALID — regenerate it\nuntil every listed agent appears as a step.\n"
+        )
+
     plan_append = """
 
 PLAN RULES:
 - Steps are HIGH-LEVEL task assignments — one step per agent. Do NOT prescribe
   sub-tasks, parameters, or data retrieval. Agents discover their own processes.
-""" + clarification_policy + """
+""" + mandatory_block + clarification_policy + """
 OUTPUT FORMAT (CRITICAL — use EXACTLY this JSON structure, nothing else):
 ```json
 [
@@ -86,11 +109,14 @@ def get_magentic_prompt_kwargs(*, has_user_responses: bool = False) -> dict:
 Use exact agent names from the team list above. Output ONLY the JSON array — no
 markdown fences, no commentary before or after.
 
-IMPORTANT: There is NO UserInteractionAgent. Do NOT include any user-interaction
+""" + ("""IMPORTANT: There is NO UserInteractionAgent. Do NOT include any user-interaction
 agent in the plan. Domain agents gather user info themselves via their
 request_user_clarification tool — the framework pauses automatically when they
 call it and resumes when the user answers.
-
+""" if has_user_responses else """IMPORTANT: There is NO UserInteractionAgent. Do NOT include any user-interaction
+agent in the plan. Agents apply sensible defaults for missing details and proceed
+without asking the user any questions.
+""") + """
 Example plan:
 [
   {{"agent": "HRHelperAgent", "action": "execute the onboarding process for the new employee"}},
@@ -143,12 +169,42 @@ def get_magentic_prompt_kwargs(*, has_user_responses: bool = False) -> dict:
             ORCHESTRATOR_TASK_LEDGER_FACTS_PROMPT + facts_append
         )
 
-        progress_append = """
+    # Completion-enforcement progress-ledger rules. Applied ALWAYS (not only when
+    # has_user_responses) so that EVERY plan-step agent — e.g. TriageAgent and
+    # ComplianceAgent in the content_gen team, whose agents all have
+    # user_responses=false — must actually run before the request can be marked
+    # satisfied, and the orchestrator re-selects any uninvoked plan-step agent
+    # instead of silently finishing early.
+    progress_append = """
 
 EXECUTION RULES:
 - When selecting next_speaker, prefer a work agent that has NOT yet been invoked.
-- MagenticManager MUST NOT generate answers, ask questions, or list missing info.
-  It only routes tasks to the appropriate agent.
+- MagenticManager MUST NOT generate answers or fabricate content on behalf of
+  work agents. It only routes tasks and compiles the final output.
+
+COMPLETION CHECK (CRITICAL):
+Before setting is_request_satisfied to true, you MUST verify:
+1. Review the conversation history and list every agent that has actually produced
+   a substantive response (meaningful output — calling tools and returning results
+   where the agent has tools, or producing a substantive text response otherwise).
+2. Compare that list against the plan steps. If ANY plan-step agent has NOT been
+   invoked and produced a substantive response, set is_request_satisfied to false
+   and select the next uninvoked agent as next_speaker.
+3. is_request_satisfied = true ONLY when ALL plan-step agents have completed
+   their work (produced a substantive response — tool results, or meaningful text
+   output for agents that have no tools).
+- Each agent handles a DISTINCT domain. One agent's output does NOT satisfy
+  another agent's step.
+- Do NOT re-invoke an agent that already completed its step successfully.
+- IGNORE agent-level completion language (e.g. "all steps are complete",
+  "onboarding is done"). An individual agent only knows about its own domain.
+  The workflow is NOT complete until every plan-step agent has been invoked."""
+
+    if has_user_responses:
+        progress_append += """
+
+USER-CLARIFICATION EXECUTION RULES:
+- MagenticManager MUST NOT ask questions or list missing info — it only routes.
 - There is NO UserInteractionAgent. Do NOT select it as next_speaker.
 - Domain agents that need user info will call their request_user_clarification
   tool. The framework handles the pause/resume automatically via
@@ -168,26 +224,11 @@ def get_magentic_prompt_kwargs(*, has_user_responses: bool = False) -> dict:
 STALL DETECTION OVERRIDE:
 - An agent calling request_user_clarification is NOT stalling. The framework
   pauses automatically. Set is_progress_being_made=true and is_in_loop=false.
-- Do NOT treat a framework pause as a stall or loop.
+- Do NOT treat a framework pause as a stall or loop."""
 
-COMPLETION CHECK (CRITICAL):
-Before setting is_request_satisfied to true, you MUST verify:
-1. Review the conversation history and list every agent that has actually produced
-   a substantive response (called tools and returned results).
-2. Compare that list against the plan steps. If ANY plan-step agent has NOT been
-   invoked and produced a substantive response, set is_request_satisfied to false
-   and select the next uninvoked agent as next_speaker.
-3. is_request_satisfied = true ONLY when ALL plan-step agents have completed
-   their work successfully (called their tools, returned results).
-- Each agent handles a DISTINCT domain. One agent's output does NOT satisfy
-  another agent's step.
-- Do NOT re-invoke an agent that already completed its step successfully.
-- IGNORE agent-level completion language (e.g. "all steps are complete",
-  "onboarding is done"). An individual agent only knows about its own domain.
-  The workflow is NOT complete until every plan-step agent has been invoked."""
-        kwargs["progress_ledger_prompt"] = (
-            ORCHESTRATOR_PROGRESS_LEDGER_PROMPT + progress_append
-        )
+    kwargs["progress_ledger_prompt"] = (
+        ORCHESTRATOR_PROGRESS_LEDGER_PROMPT + progress_append
+    )
 
     return kwargs