evening changes

Author: Dhanushree-Microsoft

src/processor/src/libs/agent_framework/agent_builder.py

@@ -11,6 +11,7 @@
     AgentMiddleware,
     BaseChatClient,
     ChatMiddleware,
+    ChatOptions,
     ContextProvider,
     FunctionTool,
     ToolMode,
@@ -441,32 +442,61 @@ def build(self) -> Agent:
                 async with agent:
                     response = await agent.run("Hello!")
         """
+        # Build default_options from model parameters
+        options_dict: dict[str, Any] = {}
+        if self._frequency_penalty is not None:
+            options_dict["frequency_penalty"] = self._frequency_penalty
+        if self._logit_bias is not None:
+            options_dict["logit_bias"] = self._logit_bias
+        if self._max_tokens is not None:
+            options_dict["max_tokens"] = self._max_tokens
+        if self._metadata is not None:
+            options_dict["metadata"] = self._metadata
+        if self._model_id is not None:
+            options_dict["model"] = self._model_id
+        if self._presence_penalty is not None:
+            options_dict["presence_penalty"] = self._presence_penalty
+        if self._response_format is not None:
+            options_dict["response_format"] = self._response_format
+        if self._seed is not None:
+            options_dict["seed"] = self._seed
+        if self._stop is not None:
+            options_dict["stop"] = self._stop
+        if self._store is not None:
+            options_dict["store"] = self._store
+        if self._temperature is not None:
+            options_dict["temperature"] = self._temperature
+        if self._tool_choice is not None:
+            options_dict["tool_choice"] = self._tool_choice
+        if self._top_p is not None:
+            options_dict["top_p"] = self._top_p
+        if self._user is not None:
+            options_dict["user"] = self._user
+        if self._additional_chat_options:
+            options_dict.update(self._additional_chat_options)
+
+        default_options = ChatOptions(**options_dict) if options_dict else None
+
+        # Agent expects context_providers as a Sequence; wrap single instance in a list
+        ctx_providers = self._context_providers
+        if ctx_providers is not None and not isinstance(ctx_providers, list):
+            ctx_providers = [ctx_providers]
+
+        # Agent expects middleware as a Sequence; wrap single instance in a list
+        mw = self._middleware
+        if mw is not None and not isinstance(mw, list):
+            mw = [mw]
+
         return Agent(
-            chat_client=self._chat_client,
+            self._chat_client,
             instructions=self._instructions,
             id=self._id,
             name=self._name,
             description=self._description,
-            chat_message_store_factory=self._chat_message_store_factory,
-            conversation_id=self._conversation_id,
-            context_providers=self._context_providers,
-            middleware=self._middleware,
-            frequency_penalty=self._frequency_penalty,
-            logit_bias=self._logit_bias,
-            max_tokens=self._max_tokens,
-            metadata=self._metadata,
-            model_id=self._model_id,
-            presence_penalty=self._presence_penalty,
-            response_format=self._response_format,
-            seed=self._seed,
-            stop=self._stop,
-            store=self._store,
-            temperature=self._temperature,
-            tool_choice=self._tool_choice,
             tools=self._tools,
-            top_p=self._top_p,
-            user=self._user,
-            additional_chat_options=self._additional_chat_options,
+            default_options=default_options,
+            context_providers=ctx_providers,
+            middleware=mw,
             **self._kwargs,
         )
 
@@ -755,31 +785,60 @@ def create_agent(
             ``async with`` to ensure proper initialization and cleanup via the Agent's
             async context manager protocol.
         """
+        # Build default_options from model parameters
+        opts: dict[str, Any] = {}
+        if frequency_penalty is not None:
+            opts["frequency_penalty"] = frequency_penalty
+        if logit_bias is not None:
+            opts["logit_bias"] = logit_bias
+        if max_tokens is not None:
+            opts["max_tokens"] = max_tokens
+        if metadata is not None:
+            opts["metadata"] = metadata
+        if model_id is not None:
+            opts["model"] = model_id
+        if presence_penalty is not None:
+            opts["presence_penalty"] = presence_penalty
+        if response_format is not None:
+            opts["response_format"] = response_format
+        if seed is not None:
+            opts["seed"] = seed
+        if stop is not None:
+            opts["stop"] = stop
+        if store is not None:
+            opts["store"] = store
+        if temperature is not None:
+            opts["temperature"] = temperature
+        if tool_choice is not None:
+            opts["tool_choice"] = tool_choice
+        if top_p is not None:
+            opts["top_p"] = top_p
+        if user is not None:
+            opts["user"] = user
+        if additional_chat_options:
+            opts.update(additional_chat_options)
+
+        default_options = ChatOptions(**opts) if opts else None
+
+        # Agent expects context_providers as a Sequence; wrap single instance in a list
+        ctx_providers = context_providers
+        if ctx_providers is not None and not isinstance(ctx_providers, list):
+            ctx_providers = [ctx_providers]
+
+        # Agent expects middleware as a Sequence; wrap single instance in a list
+        mw = middleware
+        if mw is not None and not isinstance(mw, list):
+            mw = [mw]
+
         return Agent(
-            chat_client=chat_client,
+            chat_client,
             instructions=instructions,
             id=id,
             name=name,
             description=description,
-            chat_message_store_factory=chat_message_store_factory,
-            conversation_id=conversation_id,
-            context_providers=context_providers,
-            middleware=middleware,
-            frequency_penalty=frequency_penalty,
-            logit_bias=logit_bias,
-            max_tokens=max_tokens,
-            metadata=metadata,
-            model_id=model_id,
-            presence_penalty=presence_penalty,
-            response_format=response_format,
-            seed=seed,
-            stop=stop,
-            store=store,
-            temperature=temperature,
-            tool_choice=tool_choice,
             tools=tools,
-            top_p=top_p,
-            user=user,
-            additional_chat_options=additional_chat_options,
+            default_options=default_options,
+            context_providers=ctx_providers,
+            middleware=mw,
             **kwargs,
         )

src/processor/src/libs/agent_framework/agent_info.py

@@ -5,13 +5,15 @@
 
 from typing import Any, Callable, MutableMapping, Sequence
 
-from agent_framework import FunctionTool
+from agent_framework import FunctionTool, MCPStdioTool, MCPStreamableHTTPTool
 from jinja2 import Template
 from openai import BaseModel
 from pydantic import Field
 
 from .agent_framework_helper import AgentFrameworkHelper, ClientType
 
+ToolType = FunctionTool | MCPStreamableHTTPTool | MCPStdioTool | Callable[..., Any] | MutableMapping[str, Any]
+
 
 class AgentInfo(BaseModel):
     agent_name: str
@@ -21,10 +23,8 @@ class AgentInfo(BaseModel):
     agent_instruction: str | None = Field(default=None)
     agent_framework_helper: AgentFrameworkHelper | None = Field(default=None)
     tools: (
-        FunctionTool
-        | Callable[..., Any]
-        | MutableMapping[str, Any]
-        | Sequence[FunctionTool | Callable[..., Any] | MutableMapping[str, Any]]
+        ToolType
+        | Sequence[ToolType]
         | None
     ) = Field(default=None)
 

src/processor/src/libs/agent_framework/azure_openai_response_retry.py

@@ -539,12 +539,27 @@ def __init__(
         # Map legacy params to OpenAIChatClient params
         if deployment_name and "model" not in kwargs:
             kwargs["model"] = deployment_name
-        if endpoint and "azure_endpoint" not in kwargs:
+        if endpoint and not kwargs.get("azure_endpoint"):
             kwargs["azure_endpoint"] = endpoint
         if ad_token_provider and kwargs.get("credential") is None:
             kwargs["credential"] = ad_token_provider
 
+        # Remove None-valued keys that would conflict with env-based settings
+        for k in list(kwargs):
+            if kwargs[k] is None:
+                del kwargs[k]
+
         super().__init__(*args, **kwargs)
+
+        # OpenAIChatClient appends /v1/ to azure_endpoint but Azure AI Foundry
+        # endpoints expect /openai/responses (without /v1/). Fix the base URL.
+        if hasattr(self, "client") and self.client is not None:
+            base = str(self.client.base_url)
+            if "/openai/v1/" in base:
+                import httpx
+                corrected = base.replace("/openai/v1/", "/openai/")
+                self.client._base_url = httpx.URL(corrected)
+
         self._retry_config = retry_config or RateLimitRetryConfig.from_env()
         self._context_trim_config = ContextTrimConfig.from_env()
 

src/processor/src/libs/agent_framework/groupchat_orchestrator.py

@@ -28,9 +28,9 @@
     Role,
     SupportsAgentRun,
     Workflow,
-    WorkflowBuilder as GroupChatBuilder,
     WorkflowEvent,
 )
+from agent_framework_orchestrations import GroupChatBuilder
 from mem0 import AsyncMemory
 from pydantic import BaseModel, ValidationError
 
@@ -491,7 +491,7 @@ async def run_stream(
             # Execute with streaming
             conversation: list[Message] = []
 
-            async for event in group_chat_workflow.run_stream(task_prompt):
+            async for event in group_chat_workflow.run(task_prompt, stream=True):
                 # Enforce wall-clock timeout if configured.
                 if self.max_seconds is not None:
                     elapsed = (datetime.now() - start_time).total_seconds()
@@ -1114,9 +1114,10 @@ async def _build_groupchat(self) -> Workflow:
         ]
 
         return (
-            GroupChatBuilder()
-            .set_manager(coordinator)
-            .participants(participants)
+            GroupChatBuilder(
+                participants=participants,
+                orchestrator_agent=coordinator,
+            )
             .build()
         )
 

src/processor/src/libs/agent_framework/shared_memory_context_provider.py

@@ -77,6 +77,7 @@ def __init__(
             top_k: Number of relevant memories to retrieve per turn.
             score_threshold: Minimum similarity score for memory retrieval.
         """
+        super().__init__(source_id=f"shared_memory_{agent_name}_{step}")
         self._memory_store = memory_store
         self._agent_name = agent_name
         self._step = step
@@ -96,24 +97,28 @@ def __init__(
                 break
         self._prior_steps = _STEP_ORDER[:step_idx] if step_idx else []
 
-    async def invoking(
+    async def before_run(
         self,
-        messages: Message | MutableSequence[Message],
-        **kwargs,
-    ) -> Context:
+        *,
+        agent,
+        session,
+        context,
+        state,
+    ) -> None:
         """Called before the agent's LLM call. Injects relevant shared memories.
 
         Only searches memories from PREVIOUS steps. Within the current step,
         agents already see all messages via GroupChat broadcast.
         """
         # Skip if this is the first step (no prior memories exist)
         if not self._prior_steps:
-            return Context()
+            return
 
-        # Extract query from the most recent messages
+        # Extract query from the most recent messages in context
+        messages = context.get_messages()
         query = self._extract_query(messages)
         if not query:
-            return Context()
+            return
 
         try:
             memories = await self._memory_store.search(
@@ -127,15 +132,15 @@ async def invoking(
                 self._agent_name,
                 e,
             )
-            return Context()
+            return
 
         if not memories:
-            return Context()
+            return
 
         # Format memories into context instructions
         formatted = self._format_memories(memories)
         if not formatted:
-            return Context()
+            return
 
         instructions = f"{self.DEFAULT_CONTEXT_PROMPT}\n\n{formatted}"
 
@@ -147,14 +152,15 @@ async def invoking(
             len(instructions),
         )
 
-        return Context(instructions=instructions)
+        context.extend_instructions(self.source_id, instructions)
 
-    async def invoked(
+    async def after_run(
         self,
-        request_messages: Message | Sequence[Message],
-        response_messages: Message | Sequence[Message] | None = None,
-        invoke_exception: Exception | None = None,
-        **kwargs,
+        *,
+        agent,
+        session,
+        context,
+        state,
     ) -> None:
         """Called after the agent's LLM response. Buffers the response for storage.
 
@@ -163,33 +169,26 @@ async def invoked(
         This means only the agent's last response per step gets stored,
         which is the most complete and useful summary.
         """
-        if invoke_exception is not None:
-            logger.debug(
-                "[MEMORY] invoked() skipped for %s — exception: %s",
-                self._agent_name,
-                invoke_exception,
-            )
-            return
-
-        if response_messages is None:
+        response = context.response
+        if response is None:
             logger.debug(
-                "[MEMORY] invoked() skipped for %s — no response_messages",
+                "[MEMORY] after_run() skipped for %s — no response",
                 self._agent_name,
             )
             return
 
         # Extract text from response
-        content = self._extract_text(response_messages)
+        content = response.text if hasattr(response, "text") else None
         if not content or len(content) < MIN_CONTENT_LENGTH_TO_STORE:
             logger.debug(
-                "[MEMORY] invoked() skipped for %s — content too short (%d chars)",
+                "[MEMORY] after_run() skipped for %s — content too short (%d chars)",
                 self._agent_name,
                 len(content) if content else 0,
             )
             return
 
         logger.info(
-            "[MEMORY] invoked() buffering for %s (step=%s, %d chars)",
+            "[MEMORY] after_run() buffering for %s (step=%s, %d chars)",
             self._agent_name,
             self._step,
             len(content),