Merge branch 'customize-wpp' into codex/create-simple-chat-agent-implementation

Author: balureddy003

src/backend/app_kernel.py

@@ -20,6 +20,7 @@
 from fastapi import FastAPI, HTTPException, Query, Request
 from fastapi.middleware.cors import CORSMiddleware
 from kernel_agents.agent_factory import AgentFactory
+from pydantic import BaseModel
 
 # Local imports
 from middleware.health_check import HealthCheckMiddleware
@@ -168,6 +169,55 @@ async def user_browser_language_endpoint(
     return {"status": "Language received successfully"}
 
 
+class ChatRequest(BaseModel):
+    """Request model for the simple chat endpoint."""
+
+    session_id: str
+    user_message: str
+
+
+@app.post("/api/chat")
+async def chat_endpoint(chat_request: ChatRequest, request: Request):
+    """Handle a simple chat message from the user."""
+
+    authenticated_user = get_authenticated_user_details(request_headers=request.headers)
+    user_id = authenticated_user["user_principal_id"]
+
+    if not user_id:
+        track_event_if_configured(
+            "UserIdNotFound", {"status_code": 400, "detail": "no user"}
+        )
+        raise HTTPException(status_code=400, detail="no user")
+
+    kernel, memory_store = await initialize_runtime_and_context(
+        chat_request.session_id, user_id
+    )
+
+    client = None
+    try:
+        client = config.get_ai_project_client()
+    except Exception as client_exc:  # pylint: disable=broad-except
+        logging.error(f"Error creating AIProjectClient: {client_exc}")
+
+    simple_chat_agent = await AgentFactory.create_agent(
+        agent_type=AgentType.GENERIC,
+        session_id=chat_request.session_id,
+        user_id=user_id,
+        memory_store=memory_store,
+        client=client,
+    )
+
+    reply = await simple_chat_agent.handle_user_message(chat_request.user_message)
+
+    if client:
+        try:
+            client.close()
+        except Exception as e:  # pylint: disable=broad-except
+            logging.error(f"Error sending to AIProjectClient: {e}")
+
+    return {"reply": reply}
+
+
 @app.post("/api/input_task")
 async def input_task_endpoint(input_task: InputTask, request: Request):
     """

src/backend/kernel_agents/agent_base.py

@@ -28,6 +28,7 @@ def __init__(
         system_message: Optional[str] = None,
         client=None,
         definition=None,
+        summary_after_n_turns: int = 20,
     ):
         """Initialize the base agent.
 
@@ -68,6 +69,7 @@ def __init__(
         self._tools = tools
         self._system_message = system_message
         self._chat_history = [{"role": "system", "content": self._system_message}]
+        self._summary_after_n_turns: int = summary_after_n_turns
         # self._agent = None  # Will be initialized in async_init
 
         # Required properties for AgentGroupChat compatibility
@@ -86,6 +88,44 @@ def default_system_message(agent_name=None) -> str:
         name = agent_name
         return f"You are an AI assistant named {name}. Help the user by providing accurate and helpful information."
 
+    async def _add_message_to_history(self, role: str, content: str) -> None:
+        """Append a message to chat history and summarize if needed."""
+        self._chat_history.append({"role": role, "content": content})
+        await self._summarize_chat_history_if_needed()
+
+    async def _extend_chat_history(self, messages: List[Mapping[str, str]]) -> None:
+        """Extend chat history with multiple messages and summarize if needed."""
+        self._chat_history.extend(messages)
+        await self._summarize_chat_history_if_needed()
+
+    def _build_summary(self, messages: List[Mapping[str, str]]) -> str:
+        """Create a simple summary from a list of messages."""
+        return " \n".join(m["content"] for m in messages)
+
+    async def _summarize_chat_history_if_needed(self) -> None:
+        """Summarize chat history after N turns and replace older entries."""
+        if len(self._chat_history) - 1 <= self._summary_after_n_turns:
+            return
+
+        # Messages to summarize exclude the system prompt and the most recent N messages
+        messages_to_summarize = self._chat_history[1:-self._summary_after_n_turns]
+        summary_text = self._build_summary(messages_to_summarize)
+
+        await self._memory_store.add_item(
+            AgentMessage(
+                session_id=self._session_id,
+                user_id=self._user_id,
+                plan_id="summary",
+                content=summary_text,
+                source=self._agent_name,
+            )
+        )
+
+        self._chat_history = (
+            [self._chat_history[0], {"role": "system", "content": summary_text}]
+            + self._chat_history[-self._summary_after_n_turns :]
+        )
+
     async def handle_action_request(self, action_request: ActionRequest) -> str:
         """Handle an action request from another agent or the system.
 
@@ -112,7 +152,7 @@ async def handle_action_request(self, action_request: ActionRequest) -> str:
 
         # Add messages to chat history for context
         # This gives the agent visibility of the conversation history
-        self._chat_history.extend(
+        await self._extend_chat_history(
             [
                 {"role": "assistant", "content": action_request.action},
                 {

src/backend/kernel_agents/agent_factory.py

@@ -20,6 +20,7 @@
 from kernel_agents.procurement_agent import ProcurementAgent
 from kernel_agents.product_agent import ProductAgent
 from kernel_agents.tech_support_agent import TechSupportAgent
+from kernel_agents.simple_chat_agent import SimpleChatAgent
 from models.messages_kernel import AgentType, PlannerResponsePlan
 # pylint:disable=E0611
 from semantic_kernel.agents.azure_ai.azure_ai_agent import AzureAIAgent
@@ -41,6 +42,7 @@ class AgentFactory:
         AgentType.HUMAN: HumanAgent,
         AgentType.PLANNER: PlannerAgent,
         AgentType.GROUP_CHAT_MANAGER: GroupChatManager,  # Add GroupChatManager
+        AgentType.SIMPLE_CHAT: SimpleChatAgent,
     }
 
     # Mapping of agent types to their string identifiers (for automatic tool loading)
@@ -54,6 +56,7 @@ class AgentFactory:
         AgentType.HUMAN: AgentType.HUMAN.value,
         AgentType.PLANNER: AgentType.PLANNER.value,
         AgentType.GROUP_CHAT_MANAGER: AgentType.GROUP_CHAT_MANAGER.value,
+        AgentType.SIMPLE_CHAT: AgentType.SIMPLE_CHAT.value,
     }
 
     # System messages for each agent type
@@ -67,6 +70,7 @@ class AgentFactory:
         AgentType.HUMAN: HumanAgent.default_system_message(),
         AgentType.PLANNER: PlannerAgent.default_system_message(),
         AgentType.GROUP_CHAT_MANAGER: GroupChatManager.default_system_message(),
+        AgentType.SIMPLE_CHAT: SimpleChatAgent.default_system_message(),
     }
 
     # Cache of agent instances by session_id and agent_type

src/backend/kernel_agents/simple_chat_agent.py

@@ -1,3 +1,4 @@
+
 from typing import List, Optional
 
 from context.cosmos_memory_kernel import CosmosMemoryContext
@@ -75,3 +76,4 @@ async def handle_user_message(self, content: str) -> str:
 
         return response_content
 
+

src/backend/models/messages_kernel.py

@@ -48,6 +48,7 @@ class AgentType(str, Enum):
     TECH_SUPPORT = "Tech_Support_Agent"
     GROUP_CHAT_MANAGER = "Group_Chat_Manager"
     PLANNER = "Planner_Agent"
+    SIMPLE_CHAT = "Simple_Chat_Agent"
 
     # Add other agents as needed
 

src/backend/tests/test_agent_base_summary.py

@@ -0,0 +1,165 @@
+import asyncio
+import asyncio
+import os
+import sys
+from unittest.mock import MagicMock
+import types
+
+# Ensure modules under src/backend are importable
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Mock Azure dependencies required by app_config
+azure_module = types.ModuleType("azure")
+sys.modules["azure"] = azure_module
+sys.modules["azure.ai"] = types.ModuleType("azure.ai")
+sys.modules["azure.ai.projects"] = types.ModuleType("azure.ai.projects")
+projects_aio = types.ModuleType("azure.ai.projects.aio")
+projects_aio.AIProjectClient = MagicMock()
+sys.modules["azure.ai.projects.aio"] = projects_aio
+cosmos_module = types.ModuleType("azure.cosmos")
+sys.modules["azure.cosmos"] = cosmos_module
+cosmos_aio = types.ModuleType("azure.cosmos.aio")
+cosmos_aio.CosmosClient = MagicMock()
+sys.modules["azure.cosmos.aio"] = cosmos_aio
+partition_key_module = types.ModuleType("azure.cosmos.partition_key")
+partition_key_module.PartitionKey = MagicMock()
+sys.modules["azure.cosmos.partition_key"] = partition_key_module
+azure_monitor_module = types.ModuleType("azure.monitor")
+sys.modules["azure.monitor"] = azure_monitor_module
+events_module = types.ModuleType("azure.monitor.events")
+sys.modules["azure.monitor.events"] = events_module
+events_ext_module = types.ModuleType("azure.monitor.events.extension")
+events_ext_module.track_event = MagicMock()
+sys.modules["azure.monitor.events.extension"] = events_ext_module
+sys.modules["azure.monitor.opentelemetry"] = types.ModuleType("azure.monitor.opentelemetry")
+identity_module = types.ModuleType("azure.identity")
+identity_module.ManagedIdentityCredential = MagicMock()
+identity_module.DefaultAzureCredential = MagicMock()
+sys.modules["azure.identity"] = identity_module
+identity_aio_module = types.ModuleType("azure.identity.aio")
+identity_aio_module.ManagedIdentityCredential = MagicMock()
+identity_aio_module.DefaultAzureCredential = MagicMock()
+sys.modules["azure.identity.aio"] = identity_aio_module
+
+# Mock semantic kernel dependencies
+sys.modules["semantic_kernel"] = types.ModuleType("semantic_kernel")
+kernel_module = types.ModuleType("semantic_kernel.kernel")
+class Kernel:  # pragma: no cover - simple stub for testing
+    pass
+kernel_module.Kernel = Kernel
+sys.modules["semantic_kernel.kernel"] = kernel_module
+sys.modules["semantic_kernel.agents"] = types.ModuleType("semantic_kernel.agents")
+sys.modules["semantic_kernel.agents.azure_ai"] = types.ModuleType("semantic_kernel.agents.azure_ai")
+azure_ai_agent_module = types.ModuleType("semantic_kernel.agents.azure_ai.azure_ai_agent")
+class AzureAIAgent:  # pragma: no cover - simple stub for testing
+    def __init__(self, *args, **kwargs):
+        pass
+azure_ai_agent_module.AzureAIAgent = AzureAIAgent
+sys.modules["semantic_kernel.agents.azure_ai.azure_ai_agent"] = azure_ai_agent_module
+functions_module = types.ModuleType("semantic_kernel.functions")
+class KernelFunction:  # pragma: no cover - simple stub for testing
+    pass
+functions_module.KernelFunction = KernelFunction
+sys.modules["semantic_kernel.functions"] = functions_module
+numpy_module = types.ModuleType("numpy")
+class ndarray:  # pragma: no cover - stub
+    pass
+numpy_module.ndarray = ndarray
+sys.modules["numpy"] = numpy_module
+sys.modules["semantic_kernel.memory"] = types.ModuleType("semantic_kernel.memory")
+memory_record_module = types.ModuleType("semantic_kernel.memory.memory_record")
+class MemoryRecord:  # pragma: no cover - stub
+    pass
+memory_record_module.MemoryRecord = MemoryRecord
+sys.modules["semantic_kernel.memory.memory_record"] = memory_record_module
+memory_store_module = types.ModuleType("semantic_kernel.memory.memory_store_base")
+class MemoryStoreBase:  # pragma: no cover - stub
+    pass
+memory_store_module.MemoryStoreBase = MemoryStoreBase
+sys.modules["semantic_kernel.memory.memory_store_base"] = memory_store_module
+contents_module = types.ModuleType("semantic_kernel.contents")
+class ChatMessageContent:  # pragma: no cover - stub
+    def __init__(self, *args, **kwargs):
+        pass
+class ChatHistory(list):
+    pass
+class AuthorRole:  # pragma: no cover - stub
+    pass
+contents_module.ChatMessageContent = ChatMessageContent
+contents_module.ChatHistory = ChatHistory
+contents_module.AuthorRole = AuthorRole
+sys.modules["semantic_kernel.contents"] = contents_module
+kernel_pydantic_module = types.ModuleType("semantic_kernel.kernel_pydantic")
+class Field:  # pragma: no cover - stub
+    def __init__(self, *args, **kwargs):
+        pass
+class KernelBaseModel:  # pragma: no cover - stub
+    def __init__(self, **data):
+        for k, v in data.items():
+            setattr(self, k, v)
+
+    def model_dump(self):
+        return self.__dict__
+kernel_pydantic_module.Field = Field
+kernel_pydantic_module.KernelBaseModel = KernelBaseModel
+sys.modules["semantic_kernel.kernel_pydantic"] = kernel_pydantic_module
+
+# Provide required environment variables for AppConfig
+os.environ.setdefault("AZURE_OPENAI_DEPLOYMENT_NAME", "test")
+os.environ.setdefault("AZURE_OPENAI_API_VERSION", "2024-05-01")
+os.environ.setdefault("AZURE_OPENAI_ENDPOINT", "https://test")
+os.environ.setdefault("AZURE_AI_SUBSCRIPTION_ID", "sub")
+os.environ.setdefault("AZURE_AI_RESOURCE_GROUP", "rg")
+os.environ.setdefault("AZURE_AI_PROJECT_NAME", "proj")
+os.environ.setdefault("AZURE_AI_AGENT_ENDPOINT", "https://agent")
+
+from src.backend.kernel_agents.agent_base import BaseAgent
+from src.backend.models.messages_kernel import AgentMessage
+
+
+class StubMemoryStore:
+    def __init__(self):
+        self.items = []
+
+    async def add_item(self, item):
+        self.items.append(item)
+
+
+class DummyAgent(BaseAgent):
+    def __init__(self, memory_store, summary_after_n_turns=4):
+        # Bypass parent initialization for testing summarization helpers
+        self._agent_name = "dummy"
+        self._session_id = "session"
+        self._user_id = "user"
+        self._memory_store = memory_store
+        self._tools = []
+        self._system_message = "system"
+        self._chat_history = [{"role": "system", "content": self._system_message}]
+        self._summary_after_n_turns = summary_after_n_turns
+        self.name = self._agent_name
+
+    @classmethod
+    async def create(cls, **kwargs) -> "BaseAgent":
+        raise NotImplementedError
+
+
+def test_chat_history_summarization_and_truncation():
+    store = StubMemoryStore()
+    agent = DummyAgent(store, summary_after_n_turns=4)
+
+    async def run():
+        for i in range(6):
+            await agent._add_message_to_history("user", f"message {i}")
+
+    asyncio.run(run())
+
+    # system message + summary + last 4 messages
+    assert len(agent._chat_history) == 6
+    summary_entry = agent._chat_history[1]
+    assert summary_entry["role"] == "system"
+    assert "message 0" in summary_entry["content"]
+    assert "message 1" in summary_entry["content"]
+    assert agent._chat_history[-1]["content"] == "message 5"
+
+    assert len(store.items) >= 1
+    assert store.items[-1].content == summary_entry["content"]