Added reasoning search plus parameterization and tests

Author: marktayl1

conftest.py

@@ -11,16 +11,6 @@
 agents_path = Path(__file__).parent.parent.parent / "backend" / "v3" / "magentic_agents"
 sys.path.insert(0, str(agents_path))
 
-
-@pytest.fixture(scope="session")
-def event_loop():
-    """Create an instance of the default event loop for the test session."""
-    import asyncio
-    loop = asyncio.get_event_loop_policy().new_event_loop()
-    yield loop
-    loop.close()
-
-
 @pytest.fixture
 def agent_env_vars():
     """Common environment variables for agent testing."""

src/backend/pyproject.toml

@@ -27,7 +27,8 @@ dependencies = [
     "pytest-cov==5.0.0",
     "python-dotenv>=1.1.0",
     "python-multipart>=0.0.20",
-    "semantic-kernel>=1.32.2",
+    "semantic-kernel[azure]>=1.32.2",
     "uvicorn>=0.34.2",
     "pylint-pydantic>=0.3.5",
+    "pexpect>=4.9.0",
 ]

src/backend/uv.lock

@@ -48,6 +48,9 @@ def __init__(self, agent_name: str,
         self._search_connection = None
         self._bing_connection = None
         self.logger = logging.getLogger(__name__)
+        # input validation
+        if self.model_deployment_name is any(["o3", "o4-mini"]):
+            raise ValueError("The current version of Foundry agents do not support reasoning models.")
 
     async def _make_bing_tool(self) -> Optional[BingGroundingTool]:
         """Create Bing search tool for web search."""
@@ -169,70 +172,3 @@ async def create_foundry_agent(agent_name:str,
     await agent.open()
     return agent
 
-# Manual Test harness
-AGENT_NAME = "TestFoundryAgent"
-AGENT_DESCRIPTION = "A comprehensive research assistant with web search, Azure AI Search RAG, and MCP capabilities."
-AGENT_INSTRUCTIONS = (
-    "You are an Enhanced Research Agent with multiple information sources:\n"
-    "1. Azure AI Search for retail store and customer interaction data. Some of these are in json format, others in .csv\n"
-    "2. Bing search for current web information and recent events\n"
-    "3. MCP tools for specialized data access\n\n"
-    "Search Strategy:\n"
-    "- Use Azure AI Search first for internal/proprietary information\n"
-    "- Use Bing search for current events, recent news, and public information\n"
-    "- Always cite your sources and specify which search method provided the information\n"
-    "- Provide comprehensive answers combining multiple sources when relevant\n"
-    "- Ask for clarification only if the task is genuinely ambiguous"
-)
-MODEL_DEPLOYMENT_NAME = "gpt-4.1"
-async def test_agent():
-    """Simple chat test harness for the agent."""
-    print("🤖 Starting agent test harness...")
-
-    try:
-        # If environment variables are missing, catch exception and abort
-        try:
-            mcp_init = MCPConfig().from_env()
-            bing_init = BingConfig().from_env()
-            search_init = SearchConfig().from_env()
-        except ValueError as ve:
-            print(f"❌ Configuration error: {ve}")
-            return
-        async with FoundryAgentTemplate(agent_name=AGENT_NAME,
-                                        agent_description=AGENT_DESCRIPTION, 
-                                        agent_instructions=AGENT_INSTRUCTIONS, 
-                                        model_deployment_name=MODEL_DEPLOYMENT_NAME,
-                                        enable_code_interpreter=True,
-                                        mcp_config=mcp_init,
-                                        bing_config=bing_init,
-                                        search_config=search_init) as agent:
-            print("💬 Type 'quit' or 'exit' to stop\n")
-
-            while True:
-                user_input = input("You: ").strip()
-
-                if user_input.lower() in ['quit', 'exit', 'q']:
-                    print("👋 Goodbye!")
-                    break
-
-                if not user_input:
-                    continue
-
-                try:
-                    print("🤖 Agent: ", end="", flush=True)
-                    async for message in agent.invoke(user_input):
-                        if hasattr(message, 'content'):
-                            print(message.content, end="", flush=True)
-                        else:
-                            print(str(message), end="", flush=True)
-                    print()
-
-                except Exception as e:
-                    print(f"❌ Error: {e}")
-
-    except Exception as e:
-        print(f"❌ Failed to create agent: {e}")
-
-
-if __name__ == "__main__":
-    asyncio.run(test_agent())

src/backend/v3/magentic_agents/foundry_agent.py

@@ -2,10 +2,12 @@
 
 from v3.magentic_agents.coder import create_foundry_agent as create_coder
 from v3.magentic_agents.proxy_agent import create_proxy_agent
-from v3.magentic_agents.reasoner import create_custom_agent as create_reasoner
 from v3.magentic_agents.researcher import \
     create_foundry_agent as create_researcher
 
+from src.backend.v3.magentic_agents.reasoner_old import \
+    create_custom_agent as create_reasoner
+
 _agent_list = []
 
 async def get_agents() -> list:

src/backend/v3/magentic_agents/magentic_agent_factory.py

@@ -53,19 +53,31 @@ def from_env(cls) -> "BingConfig":
 @dataclass(slots=True)
 class SearchConfig:
     """Configuration for connecting to Azure AI Search."""
-    connection_name: str = ""
-    index_name: str = ""
+    connection_name: str | None = None
+    endpoint: str | None = None
+    index_name: str | None = None
+    embedding_endpoint: str | None = None  # Azure OpenAI endpoint
+    embedding_model: str | None = None  # e.g., "text-embedding-ada-002"
+    api_key: str | None = None  # API key for Azure AI Search
 
     @classmethod
     def from_env(cls) -> "SearchConfig":
         connection_name = os.getenv("AZURE_AI_SEARCH_CONNECTION_NAME")
         index_name = os.getenv("AZURE_AI_SEARCH_INDEX_NAME")
+        endpoint = os.getenv("AZURE_AI_SEARCH_ENDPOINT")
+        embedding_endpoint = os.getenv("AZURE_AI_SEARCH_EMBEDDING_ENDPOINT")
+        embedding_model = os.getenv("AZURE_AI_SEARCH_EMBEDDING_MODEL_NAME")
+        api_key = os.getenv("AZURE_AI_SEARCH_API_KEY")
 
         # Raise exception if any required environment variable is missing
-        if not all([connection_name, index_name]):
-            raise ValueError(f"{cls.__name__} Missing required environment variables")
+        if not all([connection_name, index_name, endpoint]):
+            raise ValueError(f"{cls.__name__} Missing required Azure Search environment variables")
 
         return cls(
             connection_name=connection_name,
             index_name=index_name,
+            endpoint=endpoint,
+            embedding_endpoint=embedding_endpoint,
+            embedding_model=embedding_model,
+            api_key=api_key,
         )

src/backend/v3/magentic_agents/models/agent_models.py

@@ -2,15 +2,20 @@
 
 import asyncio
 import uuid
+from collections.abc import AsyncIterable
 from typing import AsyncIterator
-from semantic_kernel.contents import ChatMessageContent, AuthorRole
+
+from semantic_kernel.agents import (  # pylint: disable=no-name-in-module
+    AgentResponseItem, AgentThread)
 from semantic_kernel.agents.agent import Agent
-from semantic_kernel.agents import AgentThread, AgentResponseItem #pylint: disable=no-name-in-module
+from semantic_kernel.contents import AuthorRole, ChatMessageContent
 from semantic_kernel.contents.chat_history import ChatHistory
+from semantic_kernel.contents.history_reducer.chat_history_reducer import \
+    ChatHistoryReducer
+from semantic_kernel.exceptions.agent_exceptions import \
+    AgentThreadOperationException
 from typing_extensions import override
-from collections.abc import AsyncIterable
-from semantic_kernel.exceptions.agent_exceptions import AgentThreadOperationException
-from semantic_kernel.contents.history_reducer.chat_history_reducer import ChatHistoryReducer
+
 
 class DummyAgentThread(AgentThread):
     """Dummy thread implementation for proxy agent."""
@@ -184,9 +189,7 @@ async def test_proxy_agent():
 
     agent = ProxyAgent()
     test_messages = [
-        "What's the budget for this project?",
-        "Which department should handle this task?",
-        "What's the timeline for completion?"
+        "More information needed.  What is the name of the employee?"
     ]
 
     for message in test_messages:

src/backend/v3/magentic_agents/proxy_agent.py

@@ -0,0 +1,101 @@
+import logging
+import os
+
+from azure.identity import DefaultAzureCredential as SyncDefaultAzureCredential
+from semantic_kernel import Kernel
+from semantic_kernel.agents import ChatCompletionAgent  # pylint: disable=E0611
+from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion
+from semantic_kernel.connectors.azure_ai_search import AzureAISearchCollection
+from v3.magentic_agents.common.lifecycle import MCPEnabledBase
+from v3.magentic_agents.models.agent_models import MCPConfig, SearchConfig
+from v3.magentic_agents.reasoning_search import ReasoningSearch
+
+
+class ReasoningAgentTemplate(MCPEnabledBase):
+    """
+    SK ChatCompletionAgent with optional MCP plugin injected as a Kernel plugin.
+    No Azure AI Agents client is needed here. We only need a token provider for SK.
+    """
+
+    def __init__(self, agent_name: str, 
+                 agent_description: str, 
+                 agent_instructions: str,
+                 model_deployment_name: str,
+                 azure_openai_endpoint: str,
+                 search_config: SearchConfig | None = None,
+                 mcp_config: MCPConfig | None = None) -> None:
+        super().__init__(mcp=mcp_config)
+        self.agent_name = agent_name
+        self.agent_description = agent_description
+        self.agent_instructions = agent_instructions
+        self._model_deployment_name = model_deployment_name
+        self._openai_endpoint = azure_openai_endpoint
+        self.search_config = search_config 
+        self.reasoning_search: ReasoningSearch | None = None
+        self.logger = logging.getLogger(__name__)
+
+    async def _after_open(self) -> None:
+        self.kernel = Kernel()
+
+        # Token provider for SK chat completion
+        sync_cred = SyncDefaultAzureCredential()
+
+        def ad_token_provider() -> str:
+            token = sync_cred.get_token("https://cognitiveservices.azure.com/.default")
+            return token.token
+
+        chat = AzureChatCompletion(
+            deployment_name=self._model_deployment_name,
+            endpoint=self._openai_endpoint,
+            ad_token_provider=ad_token_provider
+        )
+        self.kernel.add_service(chat)
+
+        # Initialize search capabilities
+        if self.search_config:
+            self.reasoning_search = ReasoningSearch(self.search_config)
+            await self.reasoning_search.initialize(self.kernel)
+
+        # Inject MCP plugin into the SK kernel if available
+        if self.mcp_plugin:
+            try:
+                self.kernel.add_plugin(self.mcp_plugin, plugin_name="mcp_tools")
+                self.logger.info("Added MCP plugin")
+            except Exception as ex:
+                self.logger.exception(f"Could not add MCP plugin to kernel: {ex}")
+
+        self._agent = ChatCompletionAgent(
+            kernel=self.kernel,
+            name=self.agent_name,
+            description=self.agent_description,
+            instructions=self.agent_instructions
+        )
+    
+    async def invoke(self, message: str):
+        """Invoke the agent with a message."""
+        if not self._agent:
+            raise RuntimeError("Agent not initialized. Call open() first.")
+        
+        async for response in self._agent.invoke(message):
+            yield response
+        
+# Backward‑compatible factory
+async def create_reasoning_agent(
+            agent_name: str, 
+            agent_description: str, 
+            agent_instructions: str,
+            model_deployment_name: str,
+            azure_openai_endpoint: str,
+            search_config: SearchConfig | None = None,
+            mcp_config: MCPConfig | None = None) -> ReasoningAgentTemplate:
+    agent = ReasoningAgentTemplate(
+        agent_name=agent_name, 
+        agent_description=agent_description, 
+        agent_instructions=agent_instructions,
+        model_deployment_name=model_deployment_name,
+        azure_openai_endpoint=azure_openai_endpoint,
+        search_config= search_config,
+        mcp_config=mcp_config
+    )
+    await agent.open()
+    return agent

src/backend/v3/magentic_agents/reasoner.py renamed to src/backend/v3/magentic_agents/reasoner_old.py

@@ -0,0 +1,89 @@
+"""
+RAG search capabilities for ReasoningAgentTemplate using AzureAISearchCollection.
+Based on Semantic Kernel text search patterns.
+"""
+
+from azure.core.credentials import AzureKeyCredential
+from azure.identity import DefaultAzureCredential as SyncDefaultAzureCredential
+from azure.search.documents import SearchClient
+from azure.search.documents.indexes import SearchIndexClient
+from semantic_kernel import Kernel
+from semantic_kernel.connectors.ai.open_ai import AzureTextEmbedding
+from semantic_kernel.connectors.azure_ai_search import (
+    AzureAISearchCollection, AzureAISearchStore)
+from semantic_kernel.functions import kernel_function
+from v3.magentic_agents.models.agent_models import SearchConfig
+
+
+class ReasoningSearch:
+    """Handles Azure AI Search integration for reasoning agents."""
+    
+    def __init__(self, search_config: SearchConfig | None = None):
+        self.search_config = search_config
+        self.search_client: SearchClient | None = None
+    
+    async def initialize(self, kernel: Kernel) -> bool:
+        """Initialize the search collection with embeddings and add it to the kernel."""
+        if not self.search_config or not self.search_config.endpoint or not self.search_config.index_name:
+            print("Search configuration not available")
+            return False
+            
+        try:
+            credential = SyncDefaultAzureCredential()
+
+            self.search_client = SearchClient(endpoint=self.search_config.endpoint, 
+                                              credential=AzureKeyCredential(self.search_config.api_key), 
+                                              index_name=self.search_config.index_name)
+            
+            # Add this class as a plugin so the agent can call search_documents
+            kernel.add_plugin(self, plugin_name="knowledge_search")
+            
+            print(f"Added Azure AI Search plugin for index: {self.search_config.index_name}")
+            return True
+            
+        except Exception as ex:
+            print(f"Could not initialize Azure AI Search: {ex}")
+            return False
+    
+    @kernel_function(
+        name="search_documents",
+        description="Search the knowledge base for relevant documents and information. Use this when you need to find specific information from internal documents or data.",
+    )
+    async def search_documents(self, query: str, limit: str = "3") -> str:
+        """Search function that the agent can invoke to find relevant documents."""
+        if not self.search_client:
+            return "Search service is not available."
+            
+        try:
+            limit_int = int(limit)
+            search_results = []
+
+            results = self.search_client.search(  
+                search_text=query,  
+                query_type= "simple",
+                select=["content"],
+                top=limit_int
+            )  
+            
+            for result in results:  
+                search_results.append(f"content: {result['content']}")
+            
+            if not search_results:
+                return f"No relevant documents found for query: '{query}'"
+            
+            return search_results
+            
+        except Exception as ex:
+            return f"Search failed: {str(ex)}"
+    
+    def is_available(self) -> bool:
+        """Check if search functionality is available."""
+        return self.search_client is not None
+
+
+# Simple factory function
+async def create_reasoning_search(kernel: Kernel, search_config: SearchConfig | None) -> ReasoningSearch:
+    """Create and initialize a ReasoningSearch instance."""
+    search = ReasoningSearch(search_config)
+    await search.initialize(kernel)
+    return search