able to create the agnets

Author: Dhruvkumar-Microsoft

src/backend/common/config/app_config.py

@@ -5,9 +5,10 @@
 
 from azure.ai.projects.aio import AIProjectClient
 from azure.cosmos import CosmosClient
-from azure.identity import DefaultAzureCredential, ManagedIdentityCredential
+from azure.identity import DefaultAzureCredential, ManagedIdentityCredential, AzureCliCredential
 from azure.identity.aio import DefaultAzureCredential as AioDefaultAzureCredential
 from azure.identity.aio import ManagedIdentityCredential as AioManagedIdentityCredential
+from azure.identity.aio import AzureCliCredential as AioAzureCliCredential
 from dotenv import load_dotenv
 
 
@@ -115,17 +116,17 @@ def get_azure_credential(self, client_id=None):
         """
         Returns an Azure credential based on the application environment.
 
-        If the environment is 'dev', it uses DefaultAzureCredential.
+        If the environment is 'dev', it uses AzureCliCredential for proper token scoping.
         Otherwise, it uses ManagedIdentityCredential.
 
         Args:
             client_id (str, optional): The client ID for the Managed Identity Credential.
 
         Returns:
-            Credential object: Either DefaultAzureCredential or ManagedIdentityCredential.
+            Credential object: Either AzureCliCredential or ManagedIdentityCredential.
         """
         if self.APP_ENV == "dev":
-            return DefaultAzureCredential()  # CodeQL [SM05139]: DefaultAzureCredential is safe here
+            return AzureCliCredential()  # Use AzureCliCredential for dev to properly scope tokens for https://ai.azure.com
         else:
             return ManagedIdentityCredential(client_id=client_id)
 
@@ -136,10 +137,10 @@ async def get_azure_credential_async(self, client_id=None):
             client_id (str, optional): The client ID for the Managed Identity Credential.
         
         Returns:
-            Async credential object: Either AioDefaultAzureCredential or AioManagedIdentityCredential.
+            Async credential object: Either AioAzureCliCredential or AioManagedIdentityCredential.
         """
         if self.APP_ENV == "dev":
-            return AioDefaultAzureCredential()  # CodeQL [SM05139]: DefaultAzureCredential is safe here
+            return AioAzureCliCredential()  # Use AzureCliCredential for dev to properly scope tokens for https://ai.azure.com
         else:
             return AioManagedIdentityCredential(client_id=client_id)
 
@@ -252,7 +253,7 @@ def get_ai_project_client(self):
 
             endpoint = self.AZURE_AI_AGENT_ENDPOINT
             self._ai_project_client = AIProjectClient(
-                endpoint=endpoint, credential=AioDefaultAzureCredential()
+                endpoint=endpoint, credential=self.get_azure_credential(self.AZURE_CLIENT_ID)
             )
 
             return self._ai_project_client

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

@@ -13,7 +13,7 @@
 
 from agent_framework.azure import AzureAIClient
 from azure.ai.agents.aio import AgentsClient
-from azure.identity.aio import DefaultAzureCredential
+from azure.identity.aio import AzureCliCredential
 from common.database.database_base import DatabaseBase
 from common.models.messages_af import CurrentTeamAgent, TeamConfiguration
 from common.utils.utils_agents import (
@@ -68,14 +68,26 @@ async def open(self) -> "MCPEnabledBase":
             return self
         self._stack = AsyncExitStack()
 
-        # Acquire credential
-        self.creds = DefaultAzureCredential()
+        # Acquire async credential - using AzureCliCredential for dev environment
+        # following Microsoft reference pattern from agent-framework samples
+        self.creds = AzureCliCredential()
         if self._stack:
             await self._stack.enter_async_context(self.creds)
-        # Create AgentsClient
+        
+        # Create project_client with async credentials if not already set
+        if not self.project_client:
+            from azure.ai.projects.aio import AIProjectClient
+            self.project_client = AIProjectClient(
+                endpoint=config.AZURE_AI_AGENT_ENDPOINT,
+                credential=self.creds
+            )
+            if self._stack:
+                await self._stack.enter_async_context(self.project_client)
+        
+        # Create AgentsClient with same async credential
         self.client = AzureAIClient(
                 project_client=self.project_client,
-                #async_credential=self.creds if hasattr(self, 'creds') and self.creds else None,
+                async_credential=self.creds,
                 agent_name=self.agent_name,
                 use_latest_version=True,
             )
@@ -145,7 +157,7 @@ def get_chat_client(self, chat_client) -> AzureAIClient:
         if self.project_client and self.agent_name and self.creds:
             chat_client = AzureAIClient(
                 project_client=self.project_client,
-                #async_credential=self.creds,
+                async_credential=self.creds,
                 agent_name=self.agent_name,
                 use_latest_version=True,
             )
@@ -253,7 +265,7 @@ async def get_database_team_agent(self) -> Optional[AzureAIClient]:
             if self.agent_name == "RAIAgent" and self.project_client and self.creds:
                 chat_client = AzureAIClient(
                     project_client=self.project_client,
-                    #async_credential=self.creds,
+                    async_credential=self.creds,
                     agent_name=self.agent_name,
                     use_latest_version=True,
                 )
@@ -264,7 +276,7 @@ async def get_database_team_agent(self) -> Optional[AzureAIClient]:
             elif self.project_client and self.creds:
                 chat_client = AzureAIClient(
                     project_client=self.project_client,
-                    #async_credential=self.creds,
+                    async_credential=self.creds,
                     agent_name=self.agent_name,
                     use_latest_version=True,
                 )

src/backend/v4/magentic_agents/foundry_agent.py

@@ -46,8 +46,8 @@ def __init__(
         team_config: TeamConfiguration | None = None,
         memory_store: DatabaseBase | None = None,
     ) -> None:
-        # Get project_client before calling super().__init__
-        project_client = config.get_ai_project_client()
+        # Defer project_client creation until async open() to use async credentials
+        project_client = None  # Will be created in parent's open() method
 
         super().__init__(
             mcp=mcp_config,
@@ -223,7 +223,7 @@ async def _create_azure_search_enabled_client(self, chatClient=None) -> Optional
             # The async_credential is needed for inference/streaming operations
             chat_client = AzureAIClient(
                 project_client=self.project_client,
-                #async_credential=self.creds if hasattr(self, 'creds') and self.creds else None,
+                async_credential=self.creds if hasattr(self, 'creds') and self.creds else None,
                 agent_name=self.agent_name,
                 use_latest_version=True,
             )
@@ -281,35 +281,53 @@ async def _after_open(self) -> None:
                 self.logger.info("Initializing agent in MCP mode.")
 
                 tools = await self._collect_tools()
-                # NOTE: Following Microsoft reference pattern - ChatAgent used directly
                 self._tools_for_invoke = tools if tools else None
                 self._tool_choice = "auto" if tools else "none"
 
-                self._agent =  AzureAIClient(
-                    project_client=self.project_client,
-                    use_latest_version=True).create_agent(
-                        name=self.agent_name,
+                # Convert agent_framework tools to Foundry FunctionTool format
+                foundry_tools = []
+                for tool in (tools or []):
+                    if hasattr(tool, 'to_function_tool'):
+                        foundry_tools.append(tool.to_function_tool())
+                    elif hasattr(tool, 'function'):
+                        # For MCP tools or other function-based tools
+                        foundry_tools.append(FunctionTool(function=tool.function))
+                
+                # Create Azure agent version with tools
+                azure_agent = await self.project_client.agents.create_version(
+                    agent_name=self.agent_name,
+                    definition=PromptAgentDefinition(
+                        model=self.model_deployment_name,
                         instructions=self.agent_instructions,
-                        tools=tools if tools else None
+                        tools=foundry_tools if foundry_tools else None
                     )
-                print("mcp based agent: ",self.agent_name)
-                # Create ChatAgent following reference pattern  
-                # self._agent = ChatAgent(
-                #     chat_client=self.get_chat_client(chatClient),
-                #     instructions=self.agent_instructions,
-                #     name=self.agent_name,
-                #     description=self.agent_description,
-                #     tools=tools if tools else None,
-                #     tool_choice="auto" if tools else "none",
-                #     temperature=temp,
-                #     model_id=self.model_deployment_name,
-                # )
+                )
+                
+                self.logger.info(
+                    "Created Azure agent version (agent_name=%s) with %d tools.",
+                    self.agent_name,
+                    len(foundry_tools)
+                )
+                
+                # Use AzureAIClient with the created agent
+                chat_client = AzureAIClient(
+                    project_client=self.project_client,
+                    async_credential=self.creds if hasattr(self, 'creds') and self.creds else None,
+                    agent_name=self.agent_name,
+                    use_latest_version=True,
+                )
+                
+                # Create ChatAgent with the Azure-backed client
+                self._agent = ChatAgent(
+                    chat_client=self.get_chat_client(chat_client),
+                    tools=self._tools_for_invoke,
+                    tool_choice=self._tool_choice,
+                    store=True,
+                )
+
                 async for agent in self.project_client.agents.list():
                     print(f"  Agent: {agent.name}")
 
-                async for version in self.project_client.agents.list_versions(agent_name=self.agent_name):
-                    print(f"  Version: {version}")
-
             self.logger.info("Initialized ChatAgent '%s'", self.agent_name)
 
         except Exception as ex:
@@ -338,7 +356,7 @@ async def invoke(self, prompt: str):
         messages = [ChatMessage(role=Role.USER, text=prompt)]
 
         agent_saved = False
-        print("invoke stream...", self._agent.name)
+        print(f"invoke stream... agent_name={self.agent_name}")
         async for update in self._agent.run_stream(messages):
             # Save agent only once on first update (using agent name)
             if not agent_saved and self._agent.id:

src/backend/v4/orchestration/orchestration_manager.py

@@ -80,6 +80,7 @@ async def init_orchestration(
 
             chat_client = AzureAIClient(
                 project_client=project_client,
+                async_credential=credential,
                 agent_name=agent_name,
                 use_latest_version=True
             )