Merge branch 'feature/azd-semantickernel' of https://github.com/microsoft/Multi-Agent-Custom-Automation-Engine-Solution-Accelerator into feature/azd-semantickernel

Author: gpickett

.devcontainer/devcontainer.json

@@ -1,11 +1,12 @@
 {
     "name": "Multi Agent Custom Automation Engine Solution Accelerator",
-    "image": "mcr.microsoft.com/devcontainers/javascript-node:20-bullseye",
+    "image": "mcr.microsoft.com/devcontainers/python:3.11-bullseye",
     "features": {
-        "ghcr.io/devcontainers/features/docker-in-docker:2": {
-        },
+        "ghcr.io/devcontainers/features/docker-in-docker:2": {},
         "ghcr.io/azure/azure-dev/azd:latest": {},
-        "ghcr.io/devcontainers/features/azure-cli:1": {}
+        "ghcr.io/devcontainers/features/node:1": {},
+        "ghcr.io/devcontainers/features/azure-cli:1": {},
+        "ghcr.io/jsburckhardt/devcontainer-features/uv:1": {}
     },
     "customizations": {
         "vscode": {
@@ -18,13 +19,30 @@
                 "ms-azuretools.vscode-bicep",
                 "ms-azuretools.vscode-docker",
                 "ms-vscode.js-debug",
-                "ms-vscode.vscode-node-azure-pack"
+                "ms-vscode.vscode-node-azure-pack",
+                "charliermarsh.ruff",
+                "exiasr.hadolint",
+                "kevinrose.vsc-python-indent",
+                "mosapride.zenkaku",
+                "ms-python.python",
+                "njpwerner.autodocstring",
+                "redhat.vscode-yaml",
+                "shardulm94.trailing-spaces",
+                "tamasfe.even-better-toml",
+                "yzhang.markdown-all-in-one",
+                "ms-vscode.azure-account"
             ]
         }
     },
-    "forwardPorts": [3000, 3100],
-    "remoteUser": "node",
+    "postCreateCommand": "bash ./.devcontainer/setupEnv.sh",
+    "containerEnv": {
+        "DISPLAY": "dummy",
+        "PYTHONUNBUFFERED": "True",
+        "UV_LINK_MODE": "copy",
+        "UV_PROJECT_ENVIRONMENT": "/home/vscode/.venv"
+    },
+    "remoteUser": "vscode",
     "hostRequirements": {
         "memory": "8gb"
     }
-}
+}

.devcontainer/setupEnv.sh

@@ -1,11 +1,25 @@
 #!/bin/bash
 
-pip install --upgrade pip
+cd ./src/backend
+uv add -r requirements.txt
 
+cd ../frontend
+uv add -r requirements.txt
 
-(cd ./src/frontend; pip install -r requirements.txt)
+cd ..
 
 
-(cd ./src/backend; pip install -r requirements.txt)
+
+
+
+
+
+# pip install --upgrade pip
+
+
+# (cd ./src/frontend; pip install -r requirements.txt)
+
+
+# (cd ./src/backend; pip install -r requirements.txt)
 
 

Multi-Agent-Custom-Automation-Engine-Solution-Accelerator.code-workspace

@@ -0,0 +1,13 @@
+{
+    "folders": [
+        {
+            "path": "."
+        },
+        // {
+        //     "path": "./src/frontend"
+        // },
+        // {
+        //     "path": "./src/backend"
+        // }
+    ]
+}

src/backend/.python-version

@@ -0,0 +1 @@
+3.11

src/backend/Dockerfile

@@ -1,11 +1,31 @@
 # Base Python image
-FROM python:3.11-slim
+FROM mcr.microsoft.com/devcontainers/python:3.11-bullseye AS base
+WORKDIR /app
 
+FROM base AS builder
+COPY --from=ghcr.io/astral-sh/uv:0.6.3 /uv /uvx /bin/
+ENV UV_COMPILE_BYTECODE=1 UV_LINK_MODE=copy
+
+WORKDIR /app
+COPY uv.lock pyproject.toml /app/
+
+# Install the project's dependencies using the lockfile and settings
+RUN --mount=type=cache,target=/root/.cache/uv \
+    --mount=type=bind,source=uv.lock,target=uv.lock \
+    --mount=type=bind,source=pyproject.toml,target=pyproject.toml \
+    uv sync --frozen --no-install-project --no-dev
 
 # Backend app setup
-WORKDIR /src/backend
-COPY . .  
+COPY . /app  
+RUN --mount=type=cache,target=/root/.cache/uv uv sync --frozen --no-dev
+
+FROM base
+
+COPY --from=builder /app /app
+COPY --from=builder /bin/uv /bin/uv
+
+ENV PATH="/app/.venv/bin:$PATH"
 # Install dependencies
-RUN pip install --no-cache-dir -r requirements.txt
+
 EXPOSE 8000
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]
+CMD ["uv", "run", "uvicorn", "app_kernel:app", "--host", "0.0.0.0", "--port", "8000"]

src/backend/README.md

@@ -0,0 +1,4 @@
+## Execute backend API Service
+```shell
+uv run uvicorn app_kernel:app --port 8000
+```

src/backend/app_kernel.py

@@ -115,18 +115,18 @@ async def input_task_endpoint(input_task: InputTask, request: Request):
     if not input_task.session_id:
         input_task.session_id = str(uuid.uuid4())
 
-    # Fix 2: Don't try to set user_id on InputTask directly since it doesn't have that field
-    # Instead, include it in the JSON we'll pass to the planner
-    
     try:
-        # Create just the planner agent instead of all agents
+        # Create all agents instead of just the planner agent
+        # This ensures other agents are created first and the planner has access to them
         kernel, memory_store = await initialize_runtime_and_context(input_task.session_id, user_id)
-        planner_agent = await AgentFactory.create_agent(
-            agent_type=AgentType.PLANNER, 
-            session_id=input_task.session_id, 
+        agents = await AgentFactory.create_all_agents(
+            session_id=input_task.session_id,
             user_id=user_id
         )
 
+        # Get the planner agent from the created agents
+        planner_agent = agents[AgentType.PLANNER]
+        
         # Convert input task to JSON for the kernel function, add user_id here
         input_task_data = input_task.model_dump()
         input_task_data["user_id"] = user_id
@@ -137,8 +137,11 @@ async def input_task_endpoint(input_task: InputTask, request: Request):
             KernelArguments(input_task_json=input_task_json)
         )
 
+        print(f"Result: {result}")
         # Get plan from memory store
         plan = await memory_store.get_plan_by_session(input_task.session_id)
+
+        print(f"Plan: {plan}")
 
         if not plan or not plan.id:
             # If plan not found by session, try to extract plan ID from result
@@ -190,7 +193,6 @@ async def input_task_endpoint(input_task: InputTask, request: Request):
         raise HTTPException(status_code=400, detail="Error creating plan")
 
 
-
 @app.post("/human_feedback")
 async def human_feedback_endpoint(human_feedback: HumanFeedback, request: Request):
 

src/backend/kernel_agents/agent_factory.py

@@ -152,29 +152,37 @@ async def create_agent(
         agent_type_str = cls._agent_type_strings.get(agent_type, agent_type.value.lower())
         tools = await cls._load_tools_for_agent(kernel, agent_type_str)
 
-        # Build the agent definition (functions schema) if tools exist
+        # Build the agent definition (functions schema)
         definition = None
         client = None
+        
         try:
             client = config.get_ai_project_client()
         except Exception as client_exc:
             logger.error(f"Error creating AIProjectClient: {client_exc}")
-            raise
+            if agent_type == AgentType.GROUP_CHAT_MANAGER:
+                logger.info(f"Continuing with GroupChatManager creation despite AIProjectClient error")
+            else:
+                raise
+                
         try:
-            if tools:
-                # Create the agent definition using the AIProjectClient (project-based pattern)
+            # Create the agent definition using the AIProjectClient (project-based pattern)
+            # For GroupChatManager, create a definition with minimal configuration
+            if client is not None:
                 definition = await client.agents.create_agent(
                     model=config.AZURE_OPENAI_DEPLOYMENT_NAME,
                     name=agent_type_str,
                     instructions=system_message,
                     temperature=temperature,
                     response_format=None  # Add response_format if required
                 )
+                logger.info(f"Successfully created agent definition for {agent_type_str}")
         except Exception as agent_exc:
-            logger.error(f"Error creating agent definition with AIProjectClient: {agent_exc}")
-            raise
-        if definition is None:
-            raise RuntimeError("Failed to create agent definition from Azure AI Project. Check your Azure configuration, permissions, and network connectivity.")
+            logger.error(f"Error creating agent definition with AIProjectClient for {agent_type_str}: {agent_exc}")
+            if agent_type == AgentType.GROUP_CHAT_MANAGER:
+                logger.info(f"Continuing with GroupChatManager creation despite definition error")
+            else:
+                raise
 
         # Create the agent instance using the project-based pattern
         try:
@@ -215,7 +223,7 @@ async def create_agent(
         cls._agent_cache[session_id][agent_type] = agent
 
         return agent
-        
+
     @classmethod
     async def create_azure_ai_agent(
         cls,
@@ -272,7 +280,7 @@ async def _load_tools_for_agent(cls, kernel: Kernel, agent_type: str) -> List[Ke
         """Load tools for an agent from the tools directory.
         
         This tries to load tool configurations from JSON files. If that fails,
-        it creates a simple helper function as a fallback.
+        it returns an empty list for agents that don't need tools.
         
         Args:
             kernel: The semantic kernel instance
@@ -286,9 +294,20 @@ async def _load_tools_for_agent(cls, kernel: Kernel, agent_type: str) -> List[Ke
             tools = BaseAgent.get_tools_from_config(kernel, agent_type)
             logger.info(f"Successfully loaded {len(tools)} tools for {agent_type}")
             return tools
+        except FileNotFoundError:
+            # No tool configuration file found - this is expected for some agents
+            logger.info(f"No tools defined for agent type '{agent_type}'. Returning empty list.")
+            return []
         except Exception as e:
-            logger.warning(f"Failed to load tools for {agent_type}, using fallback: {e}")
+            logger.warning(f"Error loading tools for {agent_type}: {e}")
 
+            # Return an empty list for agents without tools rather than attempting a fallback
+            # Special handling for group_chat_manager which typically doesn't need tools
+            if "group_chat_manager" in agent_type:
+                logger.info(f"No tools needed for {agent_type}. Returning empty list.")
+                return []
+                
+            # For other agent types, try to create a simple fallback tool
             try:
                 # Use PromptTemplateConfig to create a simple tool
                 from semantic_kernel.prompt_template.prompt_template_config import PromptTemplateConfig
@@ -319,7 +338,7 @@ async def _load_tools_for_agent(cls, kernel: Kernel, agent_type: str) -> List[Ke
                 return [function]
             except Exception as fallback_error:
                 logger.error(f"Failed to create fallback tool for {agent_type}: {fallback_error}")
-                # Return an empty list if everything fails
+                # Return an empty list if everything fails - the agent can still function without tools
                 return []
 
     @classmethod
@@ -343,16 +362,56 @@ async def create_all_agents(
         if session_id in cls._agent_cache and len(cls._agent_cache[session_id]) == len(cls._agent_classes):
             return cls._agent_cache[session_id]
 
-        # Create each agent type
+        # Create each agent type in two phases
+        # First, create all agents except PlannerAgent and GroupChatManager
         agents = {}
-        for agent_type in cls._agent_classes.keys():
+        planner_agent_type = AgentType.PLANNER
+        group_chat_manager_type = AgentType.GROUP_CHAT_MANAGER
+        
+        # Initialize cache for this session if it doesn't exist
+        if session_id not in cls._agent_cache:
+            cls._agent_cache[session_id] = {}
+        
+        # Phase 1: Create all agents except planner and group chat manager
+        for agent_type in [at for at in cls._agent_classes.keys() 
+                           if at != planner_agent_type and at != group_chat_manager_type]:
             agents[agent_type] = await cls.create_agent(
                 agent_type=agent_type,
                 session_id=session_id,
                 user_id=user_id,
                 temperature=temperature
             )
-            
+        
+        # Create agent name to instance mapping for the planner
+        agent_instances = {}
+        for agent_type, agent in agents.items():
+            agent_name = cls._agent_type_strings.get(agent_type).replace("_", "") + "Agent"
+            agent_name = agent_name[0].upper() + agent_name[1:]  # Capitalize first letter
+            agent_instances[agent_name] = agent
+        
+        # Log the agent instances for debugging
+        logger.debug(f"Created {len(agent_instances)} agent instances for planner: {', '.join(agent_instances.keys())}")
+        
+        # Phase 2: Create the planner agent with agent_instances
+        planner_agent = await cls.create_agent(
+            agent_type=planner_agent_type,
+            session_id=session_id,
+            user_id=user_id,
+            temperature=temperature,
+            agent_instances=agent_instances  # Pass agent instances to the planner
+        )
+        agents[planner_agent_type] = planner_agent
+        
+        # Phase 3: Create group chat manager with all agents including the planner
+        group_chat_manager = await cls.create_agent(
+            agent_type=group_chat_manager_type,
+            session_id=session_id,
+            user_id=user_id,
+            temperature=temperature,
+            available_agents=agent_instances  # Pass all agents to group chat manager
+        )
+        agents[group_chat_manager_type] = group_chat_manager
+        
         return agents
 
     @classmethod