Refactor agent creation and configuration to avoid mutating original team objects and streamline AzureAIClient initialization

Author: Abdul-Microsoft

src/backend/common/utils/utils_af.py

@@ -88,9 +88,15 @@ async def create_RAI_agent(
     )
 
     model_deployment_name = config.AZURE_OPENAI_RAI_DEPLOYMENT_NAME
-    team.team_id = "rai_team"  # Use a fixed team ID for RAI agent
-    team.name = "RAI Team"
-    team.description = "Team responsible for Responsible AI checks"
+
+    # Create a copy to avoid mutating the caller's team config.
+    # The original team object is reused later (e.g., for orchestration init),
+    # so mutating it would corrupt the real team name/id.
+    rai_team = team.model_copy()
+    rai_team.team_id = "rai_team"
+    rai_team.name = "RAI Team"
+    rai_team.description = "Team responsible for Responsible AI checks"
+
     agent = FoundryAgentTemplate(
         agent_name=agent_name,
         agent_description=agent_description,
@@ -101,7 +107,7 @@ async def create_RAI_agent(
         project_endpoint=config.AZURE_AI_PROJECT_ENDPOINT,
         mcp_config=None,
         search_config=None,
-        team_config=team,
+        team_config=rai_team,
         memory_store=memory_store,
     )
 

src/backend/common/utils/utils_agents.py

@@ -1,11 +1,6 @@
 
-import logging
 import secrets
 import string
-from typing import Optional
-
-from common.database.database_base import DatabaseBase
-from common.models.messages_af import TeamConfiguration
 
 
 def generate_assistant_id(prefix: str = "asst_", length: int = 24) -> str:
@@ -21,22 +16,3 @@ def generate_assistant_id(prefix: str = "asst_", length: int = 24) -> str:
     # cryptographically strong randomness
     random_part = "".join(secrets.choice(alphabet) for _ in range(length))
     return f"{prefix}{random_part}"
-
-
-async def get_database_team_agent_id(
-    memory_store: DatabaseBase, team_config: TeamConfiguration, agent_name: str
-) -> Optional[str]:
-    """Retrieve existing team agent from database, if any."""
-    agent_id = None
-    try:
-        currentAgent = await memory_store.get_team_agent(
-            team_id=team_config.team_id, agent_name=agent_name
-        )
-        if currentAgent and currentAgent.agent_foundry_id:
-            agent_id = currentAgent.agent_foundry_id
-
-    except (
-        Exception
-    ) as ex:  # Consider narrowing this to specific exceptions if possible
-        logging.error("Failed to initialize Get database team agent: %s", ex)
-    return agent_id

src/backend/v4/callbacks/response_handlers.py

@@ -8,7 +8,7 @@
 import re
 from typing import Any
 
-from agent_framework import ChatMessage, AgentRunUpdateEvent
+from agent_framework import ChatMessage
 
 from v4.config.settings import connection_config
 from v4.models.messages import (
@@ -108,7 +108,7 @@ def agent_response_callback(
 
 async def streaming_agent_response_callback(
     agent_id: str,
-    update,  # AgentRunUpdateEvent.data or similar streaming update object
+    update,  # Streaming update object (e.g. AgentResponseUpdate, ChatMessage)
     is_final: bool,
     user_id: str | None = None,
 ) -> None:
@@ -119,7 +119,7 @@ async def streaming_agent_response_callback(
         return
 
     try:
-        # Handle both AgentRunUpdateEvent.data and raw text updates
+        # Handle various streaming update object shapes
         chunk_text = getattr(update, "text", None)
 
         # If text is None, don't fall back to str(update) as that would show object repr

src/backend/v4/magentic_agents/common/lifecycle.py

@@ -15,10 +15,9 @@
 from azure.ai.agents.aio import AgentsClient
 from azure.identity.aio import DefaultAzureCredential
 from common.database.database_base import DatabaseBase
-from common.models.messages_af import CurrentTeamAgent, TeamConfiguration
+from common.models.messages_af import TeamConfiguration
 from common.utils.utils_agents import (
     generate_assistant_id,
-    get_database_team_agent_id,
 )
 from v4.common.services.team_service import TeamService
 from v4.config.agent_registry import agent_registry
@@ -148,13 +147,12 @@ async def _after_open(self) -> None:
         """Subclasses must build self._agent here."""
         raise NotImplementedError
 
-    def get_chat_client(self, chat_client) -> AzureAIClient:
+    def get_chat_client(self) -> AzureAIClient:
         """Return the underlying ChatClientProtocol (AzureAIClient).
         
-        Uses agent_name with use_latest_version=True to get the latest agent version
+        Uses agent_name with use_latest_version=True to get the latest agent version.
+        Agent reuse is handled automatically by the SDK via agent_name.
         """
-        if chat_client:
-            return chat_client
         if (
             self._agent
             and self._agent.chat_client
@@ -173,176 +171,16 @@ def get_chat_client(self, chat_client) -> AzureAIClient:
         )
         return chat_client
 
-    async def resolve_agent_id(self, agent_id: str) -> Optional[str]:
-        """Resolve agent ID via Projects SDK first (for RAI agents), fallback to AgentsClient.
-
-        Args:
-            agent_id: The agent ID to resolve
-
-        Returns:
-            The resolved agent ID if found, None otherwise
-        """
-        # Try Projects SDK first (RAI agents were created via project_client)
-        try:
-            if self.project_client:
-                agent = await self.project_client.agents.get_agent(agent_id)
-                if agent and agent.id:
-                    self.logger.info(
-                        "RAI.AgentReuseSuccess: Resolved agent via Projects SDK (id=%s)",
-                        agent.id,
-                    )
-                    return agent.id
-        except Exception as ex:
-            self.logger.warning(
-                "RAI.AgentReuseMiss: Projects SDK get_agent failed (reason=ProjectsGetFailed, id=%s): %s",
-                agent_id,
-                ex,
-            )
-
-        # Fallback via AgentsClient (endpoint)
-        try:
-            if self.client:
-                agent = await self.client.get_agent(agent_id=agent_id)
-                if agent and agent.id:
-                    self.logger.info(
-                        "RAI.AgentReuseSuccess: Resolved agent via AgentsClient (id=%s)",
-                        agent.id,
-                    )
-                    return agent.id
-        except Exception as ex:
-            self.logger.warning(
-                "RAI.AgentReuseMiss: AgentsClient get_agent failed (reason=EndpointGetFailed, id=%s): %s",
-                agent_id,
-                ex,
-            )
-
-        self.logger.error(
-            "RAI.AgentReuseMiss: Agent ID not resolvable via any client (reason=ClientMismatch, id=%s)",
-            agent_id,
-        )
-        return None
-
-    def get_agent_id(self, chat_client) -> str:
-        """Return the underlying agent ID or generate a new one.
+    def get_agent_id(self) -> str:
+        """Generate a local agent ID for the ChatAgent wrapper.
         
-        Note: The new AzureAIClient doesn't expose agent_id directly.
-        We generate a new ID if not available.
+        The new AzureAIClient identifies agents by name (not ID) on the server side.
+        This ID is only used locally for the ChatAgent wrapper instance.
         """
-        # Generate a new agent ID since AzureAIClient doesn't expose agent_id
         id = generate_assistant_id()
         self.logger.info("Generated new agent ID: %s", id)
         return id
 
-    async def get_database_team_agent(self) -> Optional[AzureAIClient]:
-        """Retrieve existing team agent from database, if any.
-        
-        NOTE: Agent reuse is currently DISABLED to ensure fresh agents are created
-        with the correct Azure AI Search configuration.
-        This prevents issues with stale agents that may not have the search tool configured.
-        
-        To re-enable agent reuse, set ENABLE_AGENT_REUSE=true in environment.
-        """
-        import os
-        
-        # DISABLED: Always create fresh agents to ensure Azure AI Search tool is configured
-        enable_reuse = os.environ.get("ENABLE_AGENT_REUSE", "false").lower() == "true"
-        if not enable_reuse:
-            self.logger.info(
-                "Agent reuse DISABLED: Creating fresh agent with search tools (agent_name=%s)",
-                self.agent_name,
-            )
-            return None
-        
-        chat_client = None
-        try:
-            agent_id = await get_database_team_agent_id(
-                self.memory_store, self.team_config, self.agent_name
-            )
-
-            if not agent_id:
-                self.logger.info(
-                    "RAI reuse: no stored agent id (agent_name=%s)", self.agent_name
-                )
-                return None
-
-            # Use resolve_agent_id to try Projects SDK first, then AgentsClient
-            resolved = await self.resolve_agent_id(agent_id)
-            if not resolved:
-                self.logger.error(
-                    "RAI.AgentReuseMiss: stored id %s not resolvable (agent_name=%s)",
-                    agent_id,
-                    self.agent_name,
-                )
-                return None
-
-            # Create client with resolved ID
-            if self.agent_name == "RAIAgent" and self.project_client:
-                chat_client = AzureAIClient(
-                    project_endpoint=self.project_endpoint,
-                    agent_id=resolved,
-                    credential=self.creds,
-                )
-                self.logger.info(
-                    "RAI.AgentReuseSuccess: Created AzureAIClient (id=%s)",
-                    resolved,
-                )
-            else:
-                chat_client = AzureAIClient(
-                    project_endpoint=self.project_endpoint,
-                    agent_id=resolved,
-                    model_deployment_name=self.model_deployment_name,
-                    credential=self.creds,
-                )
-                self.logger.info(
-                    "Created AzureAIClient via endpoint (id=%s)", resolved
-                )
-
-        except Exception as ex:
-            self.logger.error(
-                "Failed to initialize Get database team agent (agent_name=%s): %s",
-                self.agent_name,
-                ex,
-            )
-        return chat_client
-
-    async def save_database_team_agent(self) -> None:
-        """Save current team agent to database (only if truly new or changed)."""
-        try:
-            if self._agent is None or self._agent.id is None:
-                self.logger.error("Cannot save database team agent: agent or agent_id is None")
-                return
-
-            # Use the agent ID from ChatAgent (set during creation)
-            agent_id = self._agent.id
-
-            # Check if stored ID matches current ID
-            stored_id = await get_database_team_agent_id(
-                self.memory_store, self.team_config, self.agent_name
-            )
-            if stored_id == agent_id:
-                self.logger.info(
-                    "RAI reuse: id unchanged (id=%s); skip save.", agent_id
-                )
-                return
-
-            currentAgent = CurrentTeamAgent(
-                team_id=self.team_config.team_id,
-                team_name=self.team_config.name,
-                agent_name=self.agent_name,
-                agent_foundry_id=agent_id,
-                agent_description=self.agent_description,
-                agent_instructions=self.agent_instructions,
-            )
-            await self.memory_store.add_team_agent(currentAgent)
-            self.logger.info(
-                "Saved team agent to database (agent_name=%s, id=%s)",
-                self.agent_name,
-                agent_id,
-            )
-
-        except Exception as ex:
-            self.logger.error("Failed to save database: %s", ex)
-
     async def _prepare_mcp_tool(self) -> None:
         """Translate MCPConfig to a HostedMCPTool (agent_framework construct)."""
         if not self.mcp_cfg:

src/backend/v4/magentic_agents/foundry_agent.py

@@ -115,7 +115,7 @@ async def _collect_tools(self) -> List:
     # -------------------------
     # Azure Search helper
     # -------------------------
-    async def _create_azure_search_enabled_client(self, chatClient=None) -> Optional[AzureAIClient]:
+    async def _create_azure_search_enabled_client(self) -> Optional[AzureAIClient]:
         """
         Create a server-side Azure AI agent with Azure AI Search tool using create_version.
 
@@ -132,10 +132,6 @@ async def _create_azure_search_enabled_client(self, chatClient=None) -> Optional
         Returns:
             AzureAIClient | None
         """
-        if chatClient:
-            self.logger.info("Reusing existing chatClient for agent '%s' (already has Azure Search configured)", self.agent_name)
-            return chatClient
-
         if not self.search:
             self.logger.error("Search configuration missing.")
             return None
@@ -244,25 +240,23 @@ async def _after_open(self) -> None:
             temp = 0.1
 
         try:
-            chatClient = await self.get_database_team_agent()
-
             if self._use_azure_search:
                 # Azure Search mode (skip MCP + Code Interpreter due to incompatibility)
                 self.logger.info(
                     "Initializing agent '%s' in Azure AI Search mode (exclusive) with index=%s.",
                     self.agent_name,
                     getattr(self.search, "index_name", "N/A") if self.search else "N/A"
                 )
-                chat_client = await self._create_azure_search_enabled_client(chatClient)
+                chat_client = await self._create_azure_search_enabled_client()
                 if not chat_client:
                     raise RuntimeError(
                         "Azure AI Search mode requested but setup failed."
                     )
 
                 # In Azure Search raw tool path, tools/tool_choice are handled server-side.
                 self._agent = ChatAgent(
-                    id=self.get_agent_id(chat_client),
-                    chat_client=self.get_chat_client(chat_client),
+                    id=self.get_agent_id(),
+                    chat_client=chat_client,
                     instructions=self.agent_instructions,
                     name=self.agent_name,
                     description=self.agent_description,
@@ -272,12 +266,12 @@ async def _after_open(self) -> None:
                     default_options={"store": False},  # Client-managed conversation to avoid stale tool call IDs across rounds
                 )
             else:
-                # use MCP path
+                # MCP path (also used by RAI agent which has no tools)
                 self.logger.info("Initializing agent in MCP mode.")
                 tools = await self._collect_tools()
                 self._agent = ChatAgent(
-                    id=self.get_agent_id(chatClient),
-                    chat_client=self.get_chat_client(chatClient),
+                    id=self.get_agent_id(),
+                    chat_client=self.get_chat_client(),
                     instructions=self.agent_instructions,
                     name=self.agent_name,
                     description=self.agent_description,
@@ -314,12 +308,7 @@ async def invoke(self, prompt: str):
 
         messages = [ChatMessage(role=Role.USER, text=prompt)]
 
-        agent_saved = False
         async for update in self._agent.run_stream(messages):
-            # Save agent ID only once on first update
-            if not agent_saved:
-                await self.save_database_team_agent()
-                agent_saved = True
             yield update
 
     # -------------------------