Refactor FoundryAgent to use new tool interfaces

Replaces Azure AI Search and code interpreter tool logic with HostedFileSearchTool and HostedCodeInterpreterTool. Updates lifecycle to use async MCP tool preparation and simplifies tool/resource collection. Removes legacy compatibility and diagnostics code, streamlining agent initialization and invocation for improved maintainability.

Author: Fr4nc3

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

@@ -21,7 +21,7 @@
     ToolMode,
     ToolProtocol,
 )
-from agent_framework import HostedMCPTool
+from agent_framework import MCPStreamableHTTPTool
 
 from af.magentic_agents.models.agent_models import MCPConfig
 from af.config.agent_registry import agent_registry
@@ -86,17 +86,18 @@ async def _after_open(self) -> None:
         """Subclasses must build self._agent here."""
         raise NotImplementedError
 
-    def _prepare_mcp_tool(self) -> None:
+    async def _prepare_mcp_tool(self) -> None:
         """Translate MCPConfig to a HostedMCPTool (agent_framework construct)."""
         if not self.mcp_cfg:
             return
         try:
-            self.mcp_tool = HostedMCPTool(
+            mcp_tool = MCPStreamableHTTPTool(
                 name=self.mcp_cfg.name,
                 description=self.mcp_cfg.description,
-                server_label=self.mcp_cfg.name.replace(" ", "_"),
-                url="",  # URL will be resolved via MCPConfig in HostedMCPTool
+                url=self.mcp_cfg.url
             )
+            await self._stack.enter_async_context(mcp_tool)
+            self.mcp_tool = mcp_tool  # Store for later use
         except Exception:  # noqa: BLE001
             self.mcp_tool = None
 
@@ -145,7 +146,7 @@ async def open(self) -> "AzureAgentBase":
         await self._stack.enter_async_context(self.client)
 
         # Prepare MCP
-        self._prepare_mcp_tool()
+        await self._prepare_mcp_tool()
 
         # Let subclass build agent client
         await self._after_open()

src/backend/af/magentic_agents/foundry_agent.py

@@ -3,33 +3,18 @@
 import logging
 from typing import List, Optional
 
-from azure.ai.agents.models import (
-    Agent,
-    AzureAISearchTool,
-    CodeInterpreterToolDefinition,
-)
-
 from agent_framework import (
+    ChatAgent,
     ChatMessage,
     Role,
-    ChatOptions,
-    HostedMCPTool,
-    AggregateContextProvider,
-    ChatAgent,
-    ChatClientProtocol,
-    ChatMessageStoreProtocol,
-    ContextProvider,
-    Middleware,
-    ToolMode,
-    ToolProtocol,
+    HostedFileSearchTool,
+    HostedVectorStoreContent,
+    HostedCodeInterpreterTool,
 )
 from af.magentic_agents.common.lifecycle import AzureAgentBase
 from af.magentic_agents.models.agent_models import MCPConfig, SearchConfig
 from af.config.agent_registry import agent_registry
 
-# Broad exception flag
-# pylint: disable=w0718
-
 
 class FoundryAgentTemplate(AzureAgentBase):
     """Agent that uses Azure AI Search (RAG) and optional MCP tool via agent_framework."""
@@ -44,253 +29,106 @@ def __init__(
         mcp_config: MCPConfig | None = None,
         search_config: SearchConfig | None = None,
     ) -> None:
-        super().__init__(mcp=mcp_config)
+        super().__init__(mcp=mcp_config, model_deployment_name=model_deployment_name)
         self.agent_name = agent_name
         self.agent_description = agent_description
         self.agent_instructions = agent_instructions
-        self.model_deployment_name = model_deployment_name
         self.enable_code_interpreter = enable_code_interpreter
-        self.mcp = mcp_config
         self.search = search_config
-
-        self._search_connection = None
         self.logger = logging.getLogger(__name__)
 
-        if self.model_deployment_name in {"o3", "o4-mini"}:
-            raise ValueError(
-                "Foundry agents do not support reasoning models in this implementation."
-            )
-
     # -------------------------
     # Tool construction helpers
     # -------------------------
-    async def _make_azure_search_tool(self) -> Optional[AzureAISearchTool]:
-        """Create Azure AI Search tool (RAG capability)."""
-        if not (
-            self.client
-            and self.search
-            and self.search.connection_name
-            and self.search.index_name
-        ):
-            self.logger.info(
-                "Azure AI Search tool not enabled (missing config or client)."
-            )
+    async def _make_file_search_tool(self) -> Optional[HostedFileSearchTool]:
+        """Create File Search tool (RAG capability) using vector stores."""
+        if not self.search or not self.search.vector_store_id:
+            self.logger.info("File search tool not enabled (missing vector_store_id).")
             return None
 
         try:
-            self._search_connection = await self.client.connections.get(
-                name=self.search.connection_name
-            )
-            self.logger.info(
-                "Found Azure AI Search connection: %s", self._search_connection.id
-            )
-
-            return AzureAISearchTool(
-                index_connection_id=self._search_connection.id,
-                index_name=self.search.index_name,
+            # HostedFileSearchTool uses vector stores, not direct Azure AI Search indexes
+            file_search_tool = HostedFileSearchTool(
+                inputs=[HostedVectorStoreContent(vector_store_id=self.search.vector_store_id)],
+                max_results=self.search.max_results if hasattr(self.search, 'max_results') else None,
+                description="Search through indexed documents"
             )
+            self.logger.info("Created HostedFileSearchTool with vector store: %s", self.search.vector_store_id)
+            return file_search_tool
         except Exception as ex:
-            self.logger.error(
-                "Azure AI Search tool creation failed: %s | connection=%s | index=%s",
-                ex,
-                getattr(self.search, "connection_name", None),
-                getattr(self.search, "index_name", None),
-            )
+            self.logger.error("File search tool creation failed: %s", ex)
             return None
 
-    async def _collect_tools_and_resources(self) -> tuple[List, dict]:
-        """Collect tool definitions + tool_resources for agent definition creation."""
+    async def _collect_tools(self) -> List:
+        """Collect tool definitions for ChatAgent."""
         tools: List = []
-        tool_resources: dict = {}
 
-        # Search tool
-        if self.search and self.search.connection_name and self.search.index_name:
-            search_tool = await self._make_azure_search_tool()
+        # File Search tool (RAG)
+        if self.search:
+            search_tool = await self._make_file_search_tool()
             if search_tool:
-                tools.extend(search_tool.definitions)
-                tool_resources = search_tool.resources
-                self.logger.info(
-                    "Added %d Azure AI Search tool definitions.",
-                    len(search_tool.definitions),
-                )
-            else:
-                self.logger.warning("Azure AI Search tool not configured properly.")
+                tools.append(search_tool)
+                self.logger.info("Added File Search tool.")
 
         # Code Interpreter
         if self.enable_code_interpreter:
             try:
-                tools.append(CodeInterpreterToolDefinition())
-                self.logger.info("Added Code Interpreter tool definition.")
-            except ImportError as ie:
-                self.logger.error("Code Interpreter dependency missing: %s", ie)
+                code_tool = HostedCodeInterpreterTool()
+                tools.append(code_tool)
+                self.logger.info("Added Code Interpreter tool.")
+            except Exception as ie:
+                self.logger.error("Code Interpreter tool creation failed: %s", ie)
+
+        # MCP Tool (from base class)
+        if self.mcp_tool:
+            tools.append(self.mcp_tool)
+            self.logger.info("Added MCP tool: %s", self.mcp_tool.name)
 
-        self.logger.info("Total tool definitions collected: %d", len(tools))
-        return tools, tool_resources
+        self.logger.info("Total tools collected: %d", len(tools))
+        return tools
 
     # -------------------------
     # Agent lifecycle override
     # -------------------------
     async def _after_open(self) -> None:
-        # Instantiate persistent AzureAIAgentClient bound to existing agent_id
+        """Initialize ChatAgent after connections are established."""
         try:
-            # AzureAIAgentClient(
-            #     project_client=self.client,
-            #     agent_id=str(definition.id),
-            #     agent_name=self.agent_name,
-            # )
-            tools, tool_resources = await self._collect_tools_and_resources()
+            tools = await self._collect_tools()
+            
             self._agent = ChatAgent(
                 chat_client=self.client,
-                instructions=self.agent_description + " " + self.agent_instructions,
+                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",
-                allow_multiple_tool_calls=True,
                 temperature=0.7,
+                model_id=self.model_deployment_name,
             )
-
+            
+            self.logger.info("Initialized ChatAgent '%s'", self.agent_name)
         except Exception as ex:
-            self.logger.error("Failed to initialize AzureAIAgentClient: %s", ex)
+            self.logger.error("Failed to initialize ChatAgent: %s", ex)
             raise
 
         # Register agent globally
         try:
             agent_registry.register_agent(self)
-            self.logger.info(
-                "Registered agent '%s' in global registry.", self.agent_name
-            )
+            self.logger.info("Registered agent '%s' in global registry.", self.agent_name)
         except Exception as reg_ex:
-            self.logger.warning(
-                "Could not register agent '%s': %s", self.agent_name, reg_ex
-            )
-
-    # -------------------------
-    # Definition compatibility
-    # -------------------------
-    async def _check_connection_compatibility(self, existing_definition: Agent) -> bool:
-        """Verify existing Azure AI Search connection matches current config."""
-        try:
-            if not (self.search and self.search.connection_name):
-                self.logger.info("No search config provided; assuming compatibility.")
-                return True
-
-            tool_resources = getattr(existing_definition, "tool_resources", None)
-            if not tool_resources:
-                self.logger.info(
-                    "Existing agent has no tool resources; incompatible with search requirement."
-                )
-                return False
-
-            azure_search = tool_resources.get("azure_ai_search", {})
-            indexes = azure_search.get("indexes", [])
-            if not indexes:
-                self.logger.info(
-                    "Existing agent has no Azure AI Search indexes; incompatible."
-                )
-                return False
-
-            existing_conn_id = indexes[0].get("index_connection_id")
-            if not existing_conn_id:
-                self.logger.info(
-                    "Existing agent missing index_connection_id; incompatible."
-                )
-                return False
-
-            current_connection = await self.client.connections.get(
-                name=self.search.connection_name
-            )
-            same = existing_conn_id == current_connection.id
-            if same:
-                self.logger.info("Search connection compatible: %s", existing_conn_id)
-            else:
-                self.logger.info(
-                    "Search connection mismatch: existing=%s current=%s",
-                    existing_conn_id,
-                    current_connection.id,
-                )
-            return same
-        except Exception as ex:
-            self.logger.error("Error during connection compatibility check: %s", ex)
-            return False
-
-    async def _get_azure_ai_agent_definition(self, agent_name: str) -> Agent | None:
-        """Return existing agent definition by name or None."""
-        try:
-            async for agent in self.client.agents.list_agents():
-                if agent.name == agent_name:
-                    self.logger.info(
-                        "Found existing agent '%s' (id=%s).", agent_name, agent.id
-                    )
-                    return await self.client.agents.get_agent(agent.id)
-            return None
-        except Exception as e:
-            if "ResourceNotFound" in str(e) or "404" in str(e):
-                self.logger.info("Agent '%s' not found; will create new.", agent_name)
-            else:
-                self.logger.warning(
-                    "Unexpected error listing agent '%s': %s; will attempt creation.",
-                    agent_name,
-                    e,
-                )
-            return None
-
-    # -------------------------
-    # Diagnostics helper
-    # -------------------------
-    async def fetch_run_details(self, thread_id: str, run_id: str) -> None:
-        """Log run diagnostics for a failed run."""
-        try:
-            run = await self.client.agents.runs.get(thread=thread_id, run=run_id)
-            self.logger.error(
-                "Run failure | 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(
-                "Failed fetching run details (thread=%s run=%s): %s",
-                thread_id,
-                run_id,
-                ex,
-            )
+            self.logger.warning("Could not register agent '%s': %s", self.agent_name, reg_ex)
 
     # -------------------------
     # Invocation (streaming)
     # -------------------------
     async def invoke(self, prompt: str):
-        """
-        Stream model output for a prompt.
-
-        Yields ChatResponseUpdate objects:
-          - update.text for incremental text
-          - update.contents for tool calls / usage events
-        """
+        """Stream model output for a prompt."""
         if not self._agent:
-            raise RuntimeError("Agent client not initialized; call open() first.")
+            raise RuntimeError("Agent not initialized; call open() first.")
 
         messages = [ChatMessage(role=Role.USER, text=prompt)]
-
-        tools = []
-        # Use mcp_tool prepared in AzureAgentBase
-        if self.mcp_tool and isinstance(self.mcp_tool, HostedMCPTool):
-            tools.append(self.mcp_tool)
-
-        chat_options = ChatOptions(
-            model_id=self.model_deployment_name,
-            tools=tools if tools else None,
-            tool_choice="auto" if tools else "none",
-            allow_multiple_tool_calls=True,
-            temperature=0.7,
-        )
-
-        async for update in self._agent.run_stream(
-            messages=messages,
-           # chat_options=chat_options,
-           # instructions=self.agent_instructions,
-        ):
+        
+        async for update in self._agent.run_stream(messages=messages):
             yield update
 
 
@@ -305,7 +143,7 @@ async def create_foundry_agent(
     mcp_config: MCPConfig | None,
     search_config: SearchConfig | None,
 ) -> FoundryAgentTemplate:
-    """Factory to create and open a FoundryAgentTemplate (agent_framework version)."""
+    """Factory to create and open a FoundryAgentTemplate."""
     agent = FoundryAgentTemplate(
         agent_name=agent_name,
         agent_description=agent_description,
@@ -316,4 +154,4 @@ async def create_foundry_agent(
         search_config=search_config,
     )
     await agent.open()
-    return agent
+    return agent