sharepoint sample fix (#3108)

* Initial plan

* Fix message ordering inconsistency when using AIContextProvider

Co-authored-by: westey-m <164392973+westey-m@users.noreply.github.com>

* Revert to original message ordering: Input, AIContextProvider, Response

Co-authored-by: westey-m <164392973+westey-m@users.noreply.github.com>

* Reorder messages to ChatClient to match MessageStore order: Existing, Input, AIContextProvider

Co-authored-by: westey-m <164392973+westey-m@users.noreply.github.com>

* Remove redundant test methods as existing tests already verify the behavior

Co-authored-by: westey-m <164392973+westey-m@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: westey-m <164392973+westey-m@users.noreply.github.com>
Co-authored-by: Mark Wallace <127216156+markwallace-microsoft@users.noreply.github.com>
Co-authored-by: Chris <66376200+crickman@users.noreply.github.com>

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,8 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Documentation
+    url: https://aka.ms/agent-framework
+    about: Check out the official documentation for guides and API reference.
+  - name: Discussions
+    url: https://github.com/microsoft/agent-framework/discussions
+    about: Ask questions and share ideas in GitHub Discussions.

.github/ISSUE_TEMPLATE/issue.yml

@@ -0,0 +1,203 @@
+name: Issue Report
+description: Report a bug, request a feature, or ask a question about Microsoft Agent Framework
+title: "[Issue]: "
+labels: ["triage"]
+body:
+  - type: dropdown
+    id: language
+    attributes:
+      label: Language
+      description: Which language/SDK are you using?
+      options:
+        - .NET
+        - Python
+        - None / Not Applicable
+    validations:
+      required: true
+
+  - type: dropdown
+    id: issue-type
+    attributes:
+      label: Type of Issue
+      description: What type of issue is this?
+      options:
+        - Bug
+        - Feature Request
+        - Question
+    validations:
+      required: true
+
+  - type: markdown
+    attributes:
+      value: |
+        ## Version Information
+        Please provide the version of the package(s) you are using. Select the relevant packages below.
+
+  - type: markdown
+    attributes:
+      value: "### .NET Packages"
+
+  - type: input
+    id: dotnet-agents-ai
+    attributes:
+      label: Microsoft.Agents.AI
+      description: Version of Microsoft.Agents.AI (e.g., 1.0.0)
+      placeholder: "e.g., 1.0.0"
+    validations:
+      required: false
+
+  - type: input
+    id: dotnet-agents-ai-abstractions
+    attributes:
+      label: Microsoft.Agents.AI.Abstractions
+      description: Version of Microsoft.Agents.AI.Abstractions
+      placeholder: "e.g., 1.0.0"
+    validations:
+      required: false
+
+  - type: input
+    id: dotnet-agents-ai-openai
+    attributes:
+      label: Microsoft.Agents.AI.OpenAI
+      description: Version of Microsoft.Agents.AI.OpenAI
+      placeholder: "e.g., 1.0.0"
+    validations:
+      required: false
+
+  - type: input
+    id: dotnet-agents-ai-azureai
+    attributes:
+      label: Microsoft.Agents.AI.AzureAI
+      description: Version of Microsoft.Agents.AI.AzureAI
+      placeholder: "e.g., 1.0.0"
+    validations:
+      required: false
+
+  - type: input
+    id: dotnet-agents-ai-anthropic
+    attributes:
+      label: Microsoft.Agents.AI.Anthropic
+      description: Version of Microsoft.Agents.AI.Anthropic
+      placeholder: "e.g., 1.0.0"
+    validations:
+      required: false
+
+  - type: input
+    id: dotnet-agents-ai-hosting
+    attributes:
+      label: Microsoft.Agents.AI.Hosting
+      description: Version of Microsoft.Agents.AI.Hosting
+      placeholder: "e.g., 1.0.0"
+    validations:
+      required: false
+
+  - type: input
+    id: dotnet-agents-ai-workflows
+    attributes:
+      label: Microsoft.Agents.AI.Workflows
+      description: Version of Microsoft.Agents.AI.Workflows
+      placeholder: "e.g., 1.0.0"
+    validations:
+      required: false
+
+  - type: input
+    id: dotnet-other-packages
+    attributes:
+      label: Other .NET Packages
+      description: List any other Microsoft.Agents.* packages and versions you are using
+      placeholder: "e.g., Microsoft.Agents.AI.CopilotStudio: 1.0.0, Microsoft.Agents.AI.Purview: 1.0.0"
+    validations:
+      required: false
+
+  - type: markdown
+    attributes:
+      value: "### Python Packages"
+
+  - type: input
+    id: python-core
+    attributes:
+      label: agent-framework-core
+      description: Version of agent-framework-core
+      placeholder: "e.g., 1.0.0b1"
+    validations:
+      required: false
+
+  - type: input
+    id: python-azure-ai
+    attributes:
+      label: agent-framework-azure-ai
+      description: Version of agent-framework-azure-ai
+      placeholder: "e.g., 1.0.0b1"
+    validations:
+      required: false
+
+  - type: input
+    id: python-anthropic
+    attributes:
+      label: agent-framework-anthropic
+      description: Version of agent-framework-anthropic
+      placeholder: "e.g., 1.0.0b1"
+    validations:
+      required: false
+
+  - type: input
+    id: python-azurefunctions
+    attributes:
+      label: agent-framework-azurefunctions
+      description: Version of agent-framework-azurefunctions
+      placeholder: "e.g., 1.0.0b1"
+    validations:
+      required: false
+
+  - type: input
+    id: python-other-packages
+    attributes:
+      label: Other Python Packages
+      description: List any other agent-framework-* packages and versions you are using
+      placeholder: "e.g., agent-framework-mem0: 1.0.0b1, agent-framework-redis: 1.0.0b1"
+    validations:
+      required: false
+
+  - type: markdown
+    attributes:
+      value: "---"
+
+  - type: textarea
+    id: description
+    attributes:
+      label: Description
+      description: Please provide a clear and detailed description of the issue, feature request, or question.
+      placeholder: |
+        For bugs: Describe what happened, what you expected to happen, and steps to reproduce.
+        For features: Describe the feature you'd like and why it would be useful.
+        For questions: Describe what you're trying to accomplish.
+    validations:
+      required: true
+
+  - type: textarea
+    id: code-sample
+    attributes:
+      label: Code Sample
+      description: If applicable, provide a minimal code sample that demonstrates the issue or your use case.
+      placeholder: |
+        ```python
+        # Your code here
+        ```
+
+        or
+
+        ```csharp
+        // Your code here
+        ```
+      render: markdown
+    validations:
+      required: false
+
+  - type: textarea
+    id: additional-context
+    attributes:
+      label: Additional Context
+      description: Add any other context, screenshots, error messages, or stack traces that might be helpful.
+      placeholder: "Any additional information..."
+    validations:
+      required: false

.github/actions/azure-functions-integration-setup/action.yml

@@ -28,6 +28,18 @@ runs:
           echo "Waiting for Azurite (Azure Storage emulator) to be ready"
           timeout 30 bash -c 'until curl --silent http://localhost:10000/devstoreaccount1; do sleep 1; done'
           echo "Azurite (Azure Storage emulator) is ready"
+      - name: Start Redis
+        shell: bash
+        run: |
+          if [ "$(docker ps -aq -f name=redis)" ]; then
+            echo "Stopping and removing existing Redis"
+            docker rm -f redis
+          fi
+          echo "Starting Redis"
+          docker run -d --name redis -p 6379:6379 redis:latest
+          echo "Waiting for Redis to be ready"
+          timeout 30 bash -c 'until docker exec redis redis-cli ping | grep -q PONG; do sleep 1; done'
+          echo "Redis is ready"
       - name: Install Azure Functions Core Tools
         shell: bash
         run: |

.github/workflows/label-issues.yml

@@ -45,19 +45,58 @@ jobs:
               labels.push("triage")
             }
 
-            // Check if the body or the title contains the word 'python' (case-insensitive)
-            if ((body != null && body.match(/python/i)) || (title != null && title.match(/python/i))) {
-              // Add the 'python' label to the array
-              labels.push("python")
+            // Helper function to extract field value from issue form body
+            // Issue forms format fields as: ### Field Name\n\nValue
+            function getFormFieldValue(body, fieldName) {
+              if (!body) return null
+              const regex = new RegExp(`###\\s*${fieldName}\\s*\\n\\n([^\\n#]+)`, 'i')
+              const match = body.match(regex)
+              return match ? match[1].trim() : null
             }
 
-            // Check if the body or the title contains the words 'dotnet', '.net', 'c#' or 'csharp' (case-insensitive)
-            if ((body != null && body.match(/.net/i)) || (title != null && title.match(/.net/i)) ||
-                (body != null && body.match(/dotnet/i)) || (title != null && title.match(/dotnet/i)) ||
-                (body != null && body.match(/C#/i)) || (title != null && title.match(/C#/i)) ||
-                (body != null && body.match(/csharp/i)) || (title != null && title.match(/csharp/i))) {
-              // Add the '.NET' label to the array
-              labels.push(".NET")
+            // Check for language from issue form dropdown first
+            const languageField = getFormFieldValue(body, 'Language')
+            let languageLabelAdded = false
+
+            if (languageField) {
+              if (languageField === 'Python') {
+                labels.push("python")
+                languageLabelAdded = true
+              } else if (languageField === '.NET') {
+                labels.push(".NET")
+                languageLabelAdded = true
+              }
+              // 'None / Not Applicable' - don't add any language label
+            }
+
+            // Fallback: Check if the body or the title contains the word 'python' (case-insensitive)
+            // Only if language wasn't already determined from the form field
+            if (!languageLabelAdded) {
+              if ((body != null && body.match(/python/i)) || (title != null && title.match(/python/i))) {
+                // Add the 'python' label to the array
+                labels.push("python")
+              }
+
+              // Check if the body or the title contains the words 'dotnet', '.net', 'c#' or 'csharp' (case-insensitive)
+              if ((body != null && body.match(/\.net/i)) || (title != null && title.match(/\.net/i)) ||
+                  (body != null && body.match(/dotnet/i)) || (title != null && title.match(/dotnet/i)) ||
+                  (body != null && body.match(/C#/i)) || (title != null && title.match(/C#/i)) ||
+                  (body != null && body.match(/csharp/i)) || (title != null && title.match(/csharp/i))) {
+                // Add the '.NET' label to the array
+                labels.push(".NET")
+              }
+            }
+
+            // Check for issue type from issue form dropdown
+            const issueTypeField = getFormFieldValue(body, 'Type of Issue')
+            if (issueTypeField) {
+              if (issueTypeField === 'Bug') {
+                labels.push("bug")
+              } else if (issueTypeField === 'Feature Request') {
+                labels.push("enhancement")
+              } else if (issueTypeField === 'Question') {
+                labels.push("question")
+              }
             }
 
             // Add the labels to the issue (only if there are labels to add)

.github/workflows/python-merge-tests.yml

@@ -154,7 +154,7 @@ jobs:
           subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
       - name: Test with pytest
         timeout-minutes: 10
-        run: uv run poe azure-ai-tests -n logical --dist loadfile --dist worksteal --timeout 300 --retries 3 --retry-delay 10
+        run: uv run --directory packages/azure-ai poe integration-tests -n logical --dist loadfile --dist worksteal --timeout 300 --retries 3 --retry-delay 10
         working-directory: ./python
       - name: Test Azure AI samples
         timeout-minutes: 10

agent-samples/README.md

@@ -1,3 +1,3 @@
 # Declarative Agents
 
-This folder contains sample agent definitions than be ran using the declarative agent support, for python see the [declarative agent python sample folder](../python/samples/getting_started/declarative/).
+This folder contains sample agent definitions that can be run using the declarative agent support, for python see the [declarative agent python sample folder](../python/samples/getting_started/declarative/).

docs/decisions/0001-agent-run-response.md

@@ -64,7 +64,7 @@ Approaches observed from the compared SDKs:
 | AutoGen | **Approach 1** Separates messages into Agent-Agent (maps to Primary) and Internal (maps to Secondary) and these are returned as separate properties on the agent response object.  See [types of messages](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/messages.html#types-of-messages) and [Response](https://microsoft.github.io/autogen/stable/reference/python/autogen_agentchat.base.html#autogen_agentchat.base.Response) | **Approach 2** Returns a stream of internal events and the last item is a Response object. See [ChatAgent.on_messages_stream](https://microsoft.github.io/autogen/stable/reference/python/autogen_agentchat.base.html#autogen_agentchat.base.ChatAgent.on_messages_stream) |
 | OpenAI Agent SDK | **Approach 1** Separates new_items (Primary+Secondary) from final output (Primary) as separate properties on the [RunResult](https://github.com/openai/openai-agents-python/blob/main/src/agents/result.py#L39) | **Approach 1** Similar to non-streaming, has a way of streaming updates via a method on the response object which includes all data, and then a separate final output property on the response object which is populated only when the run is complete. See [RunResultStreaming](https://github.com/openai/openai-agents-python/blob/main/src/agents/result.py#L136) |
 | Google ADK | **Approach 2** [Emits events](https://google.github.io/adk-docs/runtime/#step-by-step-breakdown) with [FinalResponse](https://github.com/google/adk-java/blob/main/core/src/main/java/com/google/adk/events/Event.java#L232) true (Primary) / false (Secondary) and callers have to filter out those with false to get just the final response message | **Approach 2** Similar to non-streaming except [events](https://google.github.io/adk-docs/runtime/#streaming-vs-non-streaming-output-partialtrue) are emitted with [Partial](https://github.com/google/adk-java/blob/main/core/src/main/java/com/google/adk/events/Event.java#L133) true to indicate that they are streaming messages. A final non partial event is also emitted. |
-| AWS (Strands) | **Approach 3** Returns an [AgentResult](https://strandsagents.com/latest/api-reference/agent/#strands.agent.agent_result.AgentResult) (Primary) with messages and a reason for the run's completion. | **Approach 2** [Streams events](https://strandsagents.com/latest/api-reference/agent/#strands.agent.agent.Agent.stream_async) (Primary+Secondary) including, response text, current_tool_use, even data from "callbacks" (strands plugins) |
+| AWS (Strands) | **Approach 3** Returns an [AgentResult](https://strandsagents.com/latest/documentation/docs/api-reference/python/agent/agent_result/) (Primary) with messages and a reason for the run's completion. | **Approach 2** [Streams events](https://strandsagents.com/latest/documentation/docs/api-reference/python/agent/agent/#strands.agent.agent.Agent.stream_async) (Primary+Secondary) including, response text, current_tool_use, even data from "callbacks" (strands plugins) |
 | LangGraph | **Approach 2** A mixed list of all [messages](https://langchain-ai.github.io/langgraph/agents/run_agents/#output-format) | **Approach 2** A mixed list of all [messages](https://langchain-ai.github.io/langgraph/agents/run_agents/#output-format) |
 | Agno | **Combination of various approaches** Returns a [RunResponse](https://docs.agno.com/reference/agents/run-response) object with text content, messages (essentially chat history including inputs and instructions), reasoning and thinking text properties. Secondary events could potentially be extracted from messages. | **Approach 2** Returns [RunResponseEvent](https://docs.agno.com/reference/agents/run-response#runresponseevent-types-and-attributes) objects including tool call, memory update, etc, information, where the [RunResponseCompletedEvent](https://docs.agno.com/reference/agents/run-response#runresponsecompletedevent) has similar properties to RunResponse|
 | A2A | **Approach 3** Returns a [Task or Message](https://a2aproject.github.io/A2A/latest/specification/#71-messagesend) where the message is the final result (Primary) and task is a reference to a long running process. | **Approach 2** Returns a [stream](https://a2aproject.github.io/A2A/latest/specification/#72-messagestream) that contains task updates (Secondary) and a final message (Primary) |
@@ -495,8 +495,8 @@ We need to decide what AIContent types, each agent response type will be mapped
 | SDK | Structured Outputs support |
 |-|-|
 | AutoGen | **Approach 1** Supports [configuring an agent](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/agents.html#structured-output) at agent creation. |
-| Google ADK | **Approach 1** Both [input and output shemas can be specified for LLM Agents](https://google.github.io/adk-docs/agents/llm-agents/#structuring-data-input_schema-output_schema-output_key) at construction time. This option is specific to this agent type and other agent types do not necessarily support |
-| AWS (Strands) | **Approach 2** Supports a special invocation method called [structured_output](https://strandsagents.com/latest/api-reference/agent/#strands.agent.agent.Agent.structured_output) |
+| Google ADK | **Approach 1** Both [input and output schemas can be specified for LLM Agents](https://google.github.io/adk-docs/agents/llm-agents/#structuring-data-input_schema-output_schema-output_key) at construction time. This option is specific to this agent type and other agent types do not necessarily support |
+| AWS (Strands) | **Approach 2** Supports a special invocation method called [structured_output](https://strandsagents.com/latest/documentation/docs/api-reference/python/agent/agent/#strands.agent.agent.Agent.structured_output) |
 | LangGraph | **Approach 1** Supports [configuring an agent](https://langchain-ai.github.io/langgraph/agents/agents/?h=structured#6-configure-structured-output) at agent construction time, and a [structured response](https://langchain-ai.github.io/langgraph/agents/run_agents/#output-format) can be retrieved as a special property on the agent response |
 | Agno | **Approach 1** Supports [configuring an agent](https://docs.agno.com/examples/getting-started/structured-output) at agent construction time |
 | A2A | **Informal Approach 2** Doesn't formally support schema negotiation, but [hints can be provided via metadata](https://a2a-protocol.org/latest/specification/#97-structured-data-exchange-requesting-and-providing-json) at invocation time |
@@ -508,7 +508,7 @@ We need to decide what AIContent types, each agent response type will be mapped
 |-|-|
 | AutoGen | Supports a [stop reason](https://microsoft.github.io/autogen/stable/reference/python/autogen_agentchat.base.html#autogen_agentchat.base.TaskResult.stop_reason) which is a freeform text string |
 | Google ADK | [No equivalent present](https://github.com/google/adk-python/blob/main/src/google/adk/events/event.py) |
-| AWS (Strands) | Exposes a [stop_reason](https://strandsagents.com/latest/api-reference/types/#strands.types.event_loop.StopReason) property on the [AgentResult](https://strandsagents.com/latest/api-reference/agent/#strands.agent.agent_result.AgentResult) class with options that are tied closely to LLM operations. |
+| AWS (Strands) | Exposes a [stop_reason](https://strandsagents.com/latest/documentation/docs/api-reference/python/types/event_loop/#strands.types.event_loop.StopReason) property on the [AgentResult](https://strandsagents.com/latest/documentation/docs/api-reference/python/agent/agent_result/) class with options that are tied closely to LLM operations. |
 | LangGraph | No equivalent present, output contains only [messages](https://langchain-ai.github.io/langgraph/agents/run_agents/#output-format) |
 | Agno | [No equivalent present](https://docs.agno.com/reference/agents/run-response) |
 | A2A | No equivalent present, response only contains a [message](https://a2a-protocol.org/latest/specification/#64-message-object) or [task](https://a2a-protocol.org/latest/specification/#61-task-object). |

dotnet/Directory.Packages.props

@@ -112,19 +112,21 @@
     <PackageVersion Include="Microsoft.Bot.ObjectModel.PowerFx" Version="1.2025.1106.1" />
     <PackageVersion Include="Microsoft.PowerFx.Interpreter" Version="1.5.0-build.20251008-1002" />
     <!-- Durable Task -->
-    <PackageVersion Include="Microsoft.DurableTask.Client" Version="1.16.2" />
-    <PackageVersion Include="Microsoft.DurableTask.Client.AzureManaged" Version="1.16.2-preview.1" />
-    <PackageVersion Include="Microsoft.DurableTask.Worker" Version="1.16.2" />
-    <PackageVersion Include="Microsoft.DurableTask.Worker.AzureManaged" Version="1.16.2-preview.1" />
+    <PackageVersion Include="Microsoft.DurableTask.Client" Version="1.18.0" />
+    <PackageVersion Include="Microsoft.DurableTask.Client.AzureManaged" Version="1.18.0" />
+    <PackageVersion Include="Microsoft.DurableTask.Worker" Version="1.18.0" />
+    <PackageVersion Include="Microsoft.DurableTask.Worker.AzureManaged" Version="1.18.0" />
     <!-- Azure Functions -->
     <PackageVersion Include="Microsoft.Azure.Functions.Worker" Version="2.50.0" />
     <PackageVersion Include="Microsoft.Azure.Functions.Worker.ApplicationInsights" Version="2.50.0" />
-    <PackageVersion Include="Microsoft.Azure.Functions.Worker.Extensions.DurableTask" Version="1.9.0" />
-    <PackageVersion Include="Microsoft.Azure.Functions.Worker.Extensions.DurableTask.AzureManaged" Version="1.0.0" />
+    <PackageVersion Include="Microsoft.Azure.Functions.Worker.Extensions.DurableTask" Version="1.11.0" />
+    <PackageVersion Include="Microsoft.Azure.Functions.Worker.Extensions.DurableTask.AzureManaged" Version="1.0.1" />
     <PackageVersion Include="Microsoft.Azure.Functions.Worker.Extensions.Http" Version="3.3.0" />
     <PackageVersion Include="Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore" Version="2.1.0" />
     <PackageVersion Include="Microsoft.Azure.Functions.Worker.Extensions.Mcp" Version="1.0.0" />
     <PackageVersion Include="Microsoft.Azure.Functions.Worker.Sdk" Version="2.0.7" />
+    <!-- Redis -->
+    <PackageVersion Include="StackExchange.Redis" Version="2.10.1" />
     <!-- Test -->
     <PackageVersion Include="FluentAssertions" Version="8.8.0" />
     <PackageVersion Include="Microsoft.AspNetCore.TestHost" Condition="'$(TargetFramework)' == 'net8.0'" Version="8.0.22" />

dotnet/agent-framework-dotnet.slnx

@@ -33,6 +33,7 @@
     <Project Path="samples/AzureFunctions/05_AgentOrchestration_HITL/05_AgentOrchestration_HITL.csproj" />
     <Project Path="samples/AzureFunctions/06_LongRunningTools/06_LongRunningTools.csproj" />
     <Project Path="samples/AzureFunctions/07_AgentAsMcpTool/07_AgentAsMcpTool.csproj" />
+    <Project Path="samples/AzureFunctions/08_ReliableStreaming/08_ReliableStreaming.csproj" />
   </Folder>
   <Folder Name="/Samples/GettingStarted/">
     <File Path="samples/GettingStarted/README.md" />

dotnet/nuget/nuget-package.props

@@ -2,9 +2,9 @@
   <PropertyGroup>
     <!-- Central version prefix - applies to all nuget packages. -->
     <VersionPrefix>1.0.0</VersionPrefix>
-    <PackageVersion Condition="'$(VersionSuffix)' != ''">$(VersionPrefix)-$(VersionSuffix).251204.1</PackageVersion>
-    <PackageVersion Condition="'$(VersionSuffix)' == ''">$(VersionPrefix)-preview.251204.1</PackageVersion>
-    <GitTag>1.0.0-preview.251204.1</GitTag>
+    <PackageVersion Condition="'$(VersionSuffix)' != ''">$(VersionPrefix)-$(VersionSuffix).251219.1</PackageVersion>
+    <PackageVersion Condition="'$(VersionSuffix)' == ''">$(VersionPrefix)-preview.251219.1</PackageVersion>
+    <GitTag>1.0.0-preview.251219.1</GitTag>
 
     <Configurations>Debug;Release;Publish</Configurations>
     <IsPackable>true</IsPackable>

dotnet/samples/AGUIClientServer/AGUIDojoServer/AgenticUI/AgenticUIAgent.cs

@@ -19,12 +19,12 @@ internal sealed class AgenticUIAgent : DelegatingAIAgent
         this._jsonSerializerOptions = jsonSerializerOptions;
     }
 
-    public override Task<AgentRunResponse> RunAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
+    protected override Task<AgentRunResponse> RunCoreAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
     {
-        return this.RunStreamingAsync(messages, thread, options, cancellationToken).ToAgentRunResponseAsync(cancellationToken);
+        return this.RunCoreStreamingAsync(messages, thread, options, cancellationToken).ToAgentRunResponseAsync(cancellationToken);
     }
 
-    public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+    protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,

dotnet/samples/AGUIClientServer/AGUIDojoServer/PredictiveStateUpdates/PredictiveStateUpdatesAgent.cs

@@ -20,12 +20,12 @@ internal sealed class PredictiveStateUpdatesAgent : DelegatingAIAgent
         this._jsonSerializerOptions = jsonSerializerOptions;
     }
 
-    public override Task<AgentRunResponse> RunAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
+    protected override Task<AgentRunResponse> RunCoreAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
     {
-        return this.RunStreamingAsync(messages, thread, options, cancellationToken).ToAgentRunResponseAsync(cancellationToken);
+        return this.RunCoreStreamingAsync(messages, thread, options, cancellationToken).ToAgentRunResponseAsync(cancellationToken);
     }
 
-    public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+    protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,

dotnet/samples/AGUIClientServer/AGUIDojoServer/SharedState/SharedStateAgent.cs

@@ -19,12 +19,12 @@ internal sealed class SharedStateAgent : DelegatingAIAgent
         this._jsonSerializerOptions = jsonSerializerOptions;
     }
 
-    public override Task<AgentRunResponse> RunAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
+    protected override Task<AgentRunResponse> RunCoreAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
     {
-        return this.RunStreamingAsync(messages, thread, options, cancellationToken).ToAgentRunResponseAsync(cancellationToken);
+        return this.RunCoreStreamingAsync(messages, thread, options, cancellationToken).ToAgentRunResponseAsync(cancellationToken);
     }
 
-    public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+    protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,

dotnet/samples/AzureFunctions/08_ReliableStreaming/08_ReliableStreaming.csproj

@@ -0,0 +1,47 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+    <AzureFunctionsVersion>v4</AzureFunctionsVersion>
+    <OutputType>Exe</OutputType>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <!-- The Functions build tools don't like namespaces that start with a number -->
+    <AssemblyName>ReliableStreaming</AssemblyName>
+    <RootNamespace>ReliableStreaming</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <FrameworkReference Include="Microsoft.AspNetCore.App" />
+  </ItemGroup>
+
+  <!-- Azure Functions packages -->
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Azure.Functions.Worker" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.DurableTask" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.DurableTask.AzureManaged" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Sdk" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Azure.AI.OpenAI" />
+    <PackageReference Include="Azure.Identity" />
+  </ItemGroup>
+
+  <!-- Redis for reliable streaming -->
+  <ItemGroup>
+    <PackageReference Include="StackExchange.Redis" />
+  </ItemGroup>
+
+  <!-- Local projects that should be switched to package references when using the sample outside of this MAF repo -->
+  <!--
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Agents.AI.Hosting.AzureFunctions" />
+    <PackageReference Include="Microsoft.Agents.AI.OpenAI" />
+  </ItemGroup>
+  -->
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\src\Microsoft.Agents.AI.Hosting.AzureFunctions\Microsoft.Agents.AI.Hosting.AzureFunctions.csproj" />
+    <ProjectReference Include="..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
+  </ItemGroup>
+</Project>

dotnet/samples/AzureFunctions/08_ReliableStreaming/FunctionTriggers.cs

@@ -0,0 +1,319 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Text;
+using Microsoft.Agents.AI;
+using Microsoft.Agents.AI.DurableTask;
+using Microsoft.Agents.AI.Hosting.AzureFunctions;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.Features;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.DurableTask.Client;
+using Microsoft.Extensions.Logging;
+
+namespace ReliableStreaming;
+
+/// <summary>
+/// HTTP trigger functions for reliable streaming of durable agent responses.
+/// </summary>
+/// <remarks>
+/// This class exposes two endpoints:
+/// <list type="bullet">
+/// <item>
+/// <term>Create</term>
+/// <description>Starts an agent run and streams responses. The response format depends on the
+/// <c>Accept</c> header: <c>text/plain</c> returns raw text (ideal for terminals), while
+/// <c>text/event-stream</c> or any other value returns Server-Sent Events (SSE).</description>
+/// </item>
+/// <item>
+/// <term>Stream</term>
+/// <description>Resumes a stream from a cursor position, enabling reliable message delivery</description>
+/// </item>
+/// </list>
+/// </remarks>
+public sealed class FunctionTriggers
+{
+    private readonly RedisStreamResponseHandler _streamHandler;
+    private readonly ILogger<FunctionTriggers> _logger;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="FunctionTriggers"/> class.
+    /// </summary>
+    /// <param name="streamHandler">The Redis stream handler for reading/writing agent responses.</param>
+    /// <param name="logger">The logger instance.</param>
+    public FunctionTriggers(RedisStreamResponseHandler streamHandler, ILogger<FunctionTriggers> logger)
+    {
+        this._streamHandler = streamHandler;
+        this._logger = logger;
+    }
+
+    /// <summary>
+    /// Creates a new agent session, starts an agent run with the provided prompt,
+    /// and streams the response back to the client.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// The response format depends on the <c>Accept</c> header:
+    /// <list type="bullet">
+    /// <item><c>text/plain</c>: Returns raw text output, ideal for terminal display with curl</item>
+    /// <item><c>text/event-stream</c> or other: Returns Server-Sent Events (SSE) with cursor support</item>
+    /// </list>
+    /// </para>
+    /// <para>
+    /// The response includes an <c>x-conversation-id</c> header containing the conversation ID.
+    /// For SSE responses, clients can use this conversation ID to resume the stream if disconnected
+    /// by calling the <see cref="StreamAsync"/> endpoint with the conversation ID and the last received cursor.
+    /// </para>
+    /// <para>
+    /// Each SSE event contains the following fields:
+    /// <list type="bullet">
+    /// <item><c>id</c>: The Redis stream entry ID (use as cursor for resumption)</item>
+    /// <item><c>event</c>: Either "message" for content or "done" for stream completion</item>
+    /// <item><c>data</c>: The text content of the response chunk</item>
+    /// </list>
+    /// </para>
+    /// </remarks>
+    /// <param name="request">The HTTP request containing the prompt in the body.</param>
+    /// <param name="durableClient">The Durable Task client for signaling agents.</param>
+    /// <param name="context">The function invocation context.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>A streaming response in the format specified by the Accept header.</returns>
+    [Function(nameof(CreateAsync))]
+    public async Task<IActionResult> CreateAsync(
+        [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "agent/create")] HttpRequest request,
+        [DurableClient] DurableTaskClient durableClient,
+        FunctionContext context,
+        CancellationToken cancellationToken)
+    {
+        // Read the prompt from the request body
+        string prompt = await new StreamReader(request.Body).ReadToEndAsync(cancellationToken);
+        if (string.IsNullOrWhiteSpace(prompt))
+        {
+            return new BadRequestObjectResult("Request body must contain a prompt.");
+        }
+
+        AIAgent agentProxy = durableClient.AsDurableAgentProxy(context, "TravelPlanner");
+
+        // Create a new agent thread
+        AgentThread thread = agentProxy.GetNewThread();
+        string agentSessionId = thread.GetService<AgentSessionId>().ToString();
+
+        this._logger.LogInformation("Creating new agent session: {AgentSessionId}", agentSessionId);
+
+        // Run the agent in the background (fire-and-forget)
+        DurableAgentRunOptions options = new() { IsFireAndForget = true };
+        await agentProxy.RunAsync(prompt, thread, options, cancellationToken);
+
+        this._logger.LogInformation("Agent run started for session: {AgentSessionId}", agentSessionId);
+
+        // Check Accept header to determine response format
+        // text/plain = raw text output (ideal for terminals)
+        // text/event-stream or other = SSE format (supports resumption)
+        string? acceptHeader = request.Headers.Accept.FirstOrDefault();
+        bool useSseFormat = acceptHeader?.Contains("text/plain", StringComparison.OrdinalIgnoreCase) != true;
+
+        return await this.StreamToClientAsync(
+            conversationId: agentSessionId, cursor: null, useSseFormat, request.HttpContext, cancellationToken);
+    }
+
+    /// <summary>
+    /// Resumes streaming from a specific cursor position for an existing session.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Use this endpoint to resume a stream after disconnection. Pass the conversation ID
+    /// (from the <c>x-conversation-id</c> response header) and the last received cursor
+    /// (Redis stream entry ID) to continue from where you left off.
+    /// </para>
+    /// <para>
+    /// If no cursor is provided, streaming starts from the beginning of the stream.
+    /// This allows clients to replay the entire response if needed.
+    /// </para>
+    /// <para>
+    /// The response format depends on the <c>Accept</c> header:
+    /// <list type="bullet">
+    /// <item><c>text/plain</c>: Returns raw text output, ideal for terminal display with curl</item>
+    /// <item><c>text/event-stream</c> or other: Returns Server-Sent Events (SSE) with cursor support</item>
+    /// </list>
+    /// </para>
+    /// </remarks>
+    /// <param name="request">The HTTP request. Use the <c>cursor</c> query parameter to specify the cursor position.</param>
+    /// <param name="conversationId">The conversation ID to stream from.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>A streaming response in the format specified by the Accept header.</returns>
+    [Function(nameof(StreamAsync))]
+    public async Task<IActionResult> StreamAsync(
+        [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "agent/stream/{conversationId}")] HttpRequest request,
+        string conversationId,
+        CancellationToken cancellationToken)
+    {
+        if (string.IsNullOrWhiteSpace(conversationId))
+        {
+            return new BadRequestObjectResult("Conversation ID is required.");
+        }
+
+        // Get the cursor from query string (optional)
+        string? cursor = request.Query["cursor"].FirstOrDefault();
+
+        this._logger.LogInformation(
+            "Resuming stream for conversation {ConversationId} from cursor: {Cursor}",
+            conversationId,
+            cursor ?? "(beginning)");
+
+        // Check Accept header to determine response format
+        // text/plain = raw text output (ideal for terminals)
+        // text/event-stream or other = SSE format (supports cursor-based resumption)
+        string? acceptHeader = request.Headers.Accept.FirstOrDefault();
+        bool useSseFormat = acceptHeader?.Contains("text/plain", StringComparison.OrdinalIgnoreCase) != true;
+
+        return await this.StreamToClientAsync(conversationId, cursor, useSseFormat, request.HttpContext, cancellationToken);
+    }
+
+    /// <summary>
+    /// Streams chunks from the Redis stream to the HTTP response.
+    /// </summary>
+    /// <param name="conversationId">The conversation ID to stream from.</param>
+    /// <param name="cursor">Optional cursor to resume from. If null, streams from the beginning.</param>
+    /// <param name="useSseFormat">True to use SSE format, false for plain text.</param>
+    /// <param name="httpContext">The HTTP context for writing the response.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>An empty result after streaming completes.</returns>
+    private async Task<IActionResult> StreamToClientAsync(
+        string conversationId,
+        string? cursor,
+        bool useSseFormat,
+        HttpContext httpContext,
+        CancellationToken cancellationToken)
+    {
+        // Set response headers based on format
+        httpContext.Response.Headers.ContentType = useSseFormat
+            ? "text/event-stream"
+            : "text/plain; charset=utf-8";
+        httpContext.Response.Headers.CacheControl = "no-cache";
+        httpContext.Response.Headers.Connection = "keep-alive";
+        httpContext.Response.Headers["x-conversation-id"] = conversationId;
+
+        // Disable response buffering if supported
+        httpContext.Features.Get<IHttpResponseBodyFeature>()?.DisableBuffering();
+
+        try
+        {
+            await foreach (StreamChunk chunk in this._streamHandler.ReadStreamAsync(
+                conversationId,
+                cursor,
+                cancellationToken))
+            {
+                if (chunk.Error != null)
+                {
+                    this._logger.LogWarning("Stream error for conversation {ConversationId}: {Error}", conversationId, chunk.Error);
+                    await WriteErrorAsync(httpContext.Response, chunk.Error, useSseFormat, cancellationToken);
+                    break;
+                }
+
+                if (chunk.IsDone)
+                {
+                    await WriteEndOfStreamAsync(httpContext.Response, chunk.EntryId, useSseFormat, cancellationToken);
+                    break;
+                }
+
+                if (chunk.Text != null)
+                {
+                    await WriteChunkAsync(httpContext.Response, chunk, useSseFormat, cancellationToken);
+                }
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            this._logger.LogInformation("Client disconnected from stream {ConversationId}", conversationId);
+        }
+
+        return new EmptyResult();
+    }
+
+    /// <summary>
+    /// Writes a text chunk to the response.
+    /// </summary>
+    private static async Task WriteChunkAsync(
+        HttpResponse response,
+        StreamChunk chunk,
+        bool useSseFormat,
+        CancellationToken cancellationToken)
+    {
+        if (useSseFormat)
+        {
+            await WriteSSEEventAsync(response, "message", chunk.Text!, chunk.EntryId);
+        }
+        else
+        {
+            await response.WriteAsync(chunk.Text!, cancellationToken);
+        }
+
+        await response.Body.FlushAsync(cancellationToken);
+    }
+
+    /// <summary>
+    /// Writes an end-of-stream marker to the response.
+    /// </summary>
+    private static async Task WriteEndOfStreamAsync(
+        HttpResponse response,
+        string entryId,
+        bool useSseFormat,
+        CancellationToken cancellationToken)
+    {
+        if (useSseFormat)
+        {
+            await WriteSSEEventAsync(response, "done", "[DONE]", entryId);
+        }
+        else
+        {
+            await response.WriteAsync("\n", cancellationToken);
+        }
+
+        await response.Body.FlushAsync(cancellationToken);
+    }
+
+    /// <summary>
+    /// Writes an error message to the response.
+    /// </summary>
+    private static async Task WriteErrorAsync(
+        HttpResponse response,
+        string error,
+        bool useSseFormat,
+        CancellationToken cancellationToken)
+    {
+        if (useSseFormat)
+        {
+            await WriteSSEEventAsync(response, "error", error, null);
+        }
+        else
+        {
+            await response.WriteAsync($"\n[Error: {error}]\n", cancellationToken);
+        }
+
+        await response.Body.FlushAsync(cancellationToken);
+    }
+
+    /// <summary>
+    /// Writes a Server-Sent Event to the response stream.
+    /// </summary>
+    private static async Task WriteSSEEventAsync(
+        HttpResponse response,
+        string eventType,
+        string data,
+        string? id)
+    {
+        StringBuilder sb = new();
+
+        // Include the ID if provided (used as cursor for resumption)
+        if (!string.IsNullOrEmpty(id))
+        {
+            sb.AppendLine($"id: {id}");
+        }
+
+        sb.AppendLine($"event: {eventType}");
+        sb.AppendLine($"data: {data}");
+        sb.AppendLine(); // Empty line marks end of event
+
+        await response.WriteAsync(sb.ToString());
+    }
+}

dotnet/samples/AzureFunctions/08_ReliableStreaming/Program.cs

@@ -0,0 +1,100 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample demonstrates how to implement reliable streaming for durable agents using Redis Streams.
+// It exposes two HTTP endpoints:
+// 1. Create - Starts an agent run and streams responses back via Server-Sent Events (SSE)
+// 2. Stream - Resumes a stream from a specific cursor position, enabling reliable message delivery
+//
+// This pattern is inspired by OpenAI's background mode for the Responses API, which allows clients
+// to disconnect and reconnect to ongoing agent responses without losing messages.
+
+using Azure;
+using Azure.AI.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI.DurableTask;
+using Microsoft.Agents.AI.Hosting.AzureFunctions;
+using Microsoft.Azure.Functions.Worker.Builder;
+using Microsoft.Extensions.AI;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using OpenAI.Chat;
+using ReliableStreaming;
+using StackExchange.Redis;
+
+// Get the Azure OpenAI endpoint and deployment name from environment variables.
+string endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT")
+    ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
+string deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT")
+    ?? throw new InvalidOperationException("AZURE_OPENAI_DEPLOYMENT is not set.");
+
+// Get Redis connection string from environment variable.
+string redisConnectionString = Environment.GetEnvironmentVariable("REDIS_CONNECTION_STRING")
+    ?? "localhost:6379";
+
+// Get the Redis stream TTL from environment variable (default: 10 minutes).
+int redisStreamTtlMinutes = int.TryParse(
+    Environment.GetEnvironmentVariable("REDIS_STREAM_TTL_MINUTES"),
+    out int ttlMinutes) ? ttlMinutes : 10;
+
+// Use Azure Key Credential if provided, otherwise use Azure CLI Credential.
+string? azureOpenAiKey = System.Environment.GetEnvironmentVariable("AZURE_OPENAI_KEY");
+AzureOpenAIClient client = !string.IsNullOrEmpty(azureOpenAiKey)
+    ? new AzureOpenAIClient(new Uri(endpoint), new AzureKeyCredential(azureOpenAiKey))
+    : new AzureOpenAIClient(new Uri(endpoint), new AzureCliCredential());
+
+// Travel Planner agent instructions - designed to produce longer responses for demonstrating streaming.
+const string TravelPlannerName = "TravelPlanner";
+const string TravelPlannerInstructions =
+    """
+    You are an expert travel planner who creates detailed, personalized travel itineraries.
+    When asked to plan a trip, you should:
+    1. Create a comprehensive day-by-day itinerary
+    2. Include specific recommendations for activities, restaurants, and attractions
+    3. Provide practical tips for each destination
+    4. Consider weather and local events when making recommendations
+    5. Include estimated times and logistics between activities
+    
+    Always use the available tools to get current weather forecasts and local events
+    for the destination to make your recommendations more relevant and timely.
+    
+    Format your response with clear headings for each day and include emoji icons
+    to make the itinerary easy to scan and visually appealing.
+    """;
+
+// Configure the function app to host the AI agent.
+FunctionsApplicationBuilder builder = FunctionsApplication
+    .CreateBuilder(args)
+    .ConfigureFunctionsWebApplication()
+    .ConfigureDurableAgents(options =>
+    {
+        // Define the Travel Planner agent with tools for weather and events
+        options.AddAIAgentFactory(TravelPlannerName, sp =>
+        {
+            return client.GetChatClient(deploymentName).CreateAIAgent(
+                instructions: TravelPlannerInstructions,
+                name: TravelPlannerName,
+                services: sp,
+                tools: [
+                    AIFunctionFactory.Create(TravelTools.GetWeatherForecast),
+                    AIFunctionFactory.Create(TravelTools.GetLocalEvents),
+                ]);
+        });
+    });
+
+// Register Redis connection as a singleton
+builder.Services.AddSingleton<IConnectionMultiplexer>(_ =>
+    ConnectionMultiplexer.Connect(redisConnectionString));
+
+// Register the Redis stream response handler - this captures agent responses
+// and publishes them to Redis Streams for reliable delivery.
+// Registered as both the concrete type (for FunctionTriggers) and the interface (for the agent framework).
+builder.Services.AddSingleton(sp =>
+    new RedisStreamResponseHandler(
+        sp.GetRequiredService<IConnectionMultiplexer>(),
+        TimeSpan.FromMinutes(redisStreamTtlMinutes)));
+builder.Services.AddSingleton<IAgentResponseHandler>(sp =>
+    sp.GetRequiredService<RedisStreamResponseHandler>());
+
+using IHost app = builder.Build();
+
+app.Run();

dotnet/samples/AzureFunctions/08_ReliableStreaming/README.md

@@ -0,0 +1,264 @@
+# Reliable Streaming with Redis
+
+This sample demonstrates how to implement reliable streaming for durable agents using Redis Streams as a message broker. It enables clients to disconnect and reconnect to ongoing agent responses without losing messages, inspired by [OpenAI's background mode](https://platform.openai.com/docs/guides/background) for the Responses API.
+
+## Key Concepts Demonstrated
+
+- **Reliable message delivery**: Agent responses are persisted to Redis Streams, allowing clients to resume from any point
+- **Content negotiation**: Use `Accept: text/plain` for raw terminal output, or `Accept: text/event-stream` for SSE format
+- **Server-Sent Events (SSE)**: Standard streaming format that works with `curl`, browsers, and most HTTP clients
+- **Cursor-based resumption**: Each SSE event includes an `id` field that can be used to resume the stream
+- **Fire-and-forget agent invocation**: The agent runs in the background while the client streams from Redis via an HTTP trigger function
+
+## Environment Setup
+
+See the [README.md](../README.md) file in the parent directory for more information on how to configure the environment, including how to install and run common sample dependencies.
+
+### Additional Requirements: Redis
+
+This sample requires a Redis instance. Start a local Redis instance using Docker:
+
+```bash
+docker run -d --name redis -p 6379:6379 redis:latest
+```
+
+To verify Redis is running:
+
+```bash
+docker ps | grep redis
+```
+
+## Running the Sample
+
+Start the Azure Functions host:
+
+```bash
+func start
+```
+
+### 1. Test Streaming with curl
+
+Open a new terminal and start a travel planning request. Use the `-i` flag to see response headers (including the conversation ID) and `Accept: text/plain` for raw text output:
+
+**Bash (Linux/macOS/WSL):**
+
+```bash
+curl -i -N -X POST http://localhost:7071/api/agent/create \
+  -H "Content-Type: text/plain" \
+  -H "Accept: text/plain" \
+  -d "Plan a 7-day trip to Tokyo, Japan for next month. Include daily activities, restaurant recommendations, and tips for getting around."
+```
+
+**PowerShell:**
+
+```powershell
+curl -i -N -X POST http://localhost:7071/api/agent/create `
+  -H "Content-Type: text/plain" `
+  -H "Accept: text/plain" `
+  -d "Plan a 7-day trip to Tokyo, Japan for next month. Include daily activities, restaurant recommendations, and tips for getting around."
+```
+
+You'll first see the response headers, including:
+
+```text
+HTTP/1.1 200 OK
+Content-Type: text/plain; charset=utf-8
+x-conversation-id: @dafx-travelplanner@a1b2c3d4e5f67890abcdef1234567890
+...
+```
+
+Then the agent's response will stream to your terminal in chunks, similar to a ChatGPT-style experience (though not character-by-character).
+
+> **Note:** The `-N` flag in curl disables output buffering, which is essential for seeing the stream in real-time. The `-i` flag includes the HTTP headers in the output.
+
+### 2. Demonstrate Stream Interruption and Resumption
+
+This is the key feature of reliable streaming! Follow these steps to see it in action:
+
+#### Step 1: Start a stream and note the conversation ID
+
+Run the curl command from step 1. Watch for the `x-conversation-id` header in the response - **copy this value**, you'll need it to resume.
+
+```text
+x-conversation-id: @dafx-travelplanner@a1b2c3d4e5f67890abcdef1234567890
+```
+
+#### Step 2: Interrupt the stream
+
+While the agent is still generating text, press **`Ctrl+C`** to interrupt the stream. The agent continues running in the background - your messages are being saved to Redis!
+
+#### Step 3: Resume the stream
+
+Use the conversation ID you copied to resume streaming from where you left off. Include the `Accept: text/plain` header to get raw text output:
+
+**Bash (Linux/macOS/WSL):**
+
+```bash
+# Replace with your actual conversation ID from the x-conversation-id header
+CONVERSATION_ID="@dafx-travelplanner@a1b2c3d4e5f67890abcdef1234567890"
+
+curl -N -H "Accept: text/plain" "http://localhost:7071/api/agent/stream/${CONVERSATION_ID}"
+```
+
+**PowerShell:**
+
+```powershell
+# Replace with your actual conversation ID from the x-conversation-id header
+$conversationId = "@dafx-travelplanner@a1b2c3d4e5f67890abcdef1234567890"
+
+curl -N -H "Accept: text/plain" "http://localhost:7071/api/agent/stream/$conversationId"
+```
+
+You'll see the **entire response replayed from the beginning**, including the parts you already received before interrupting.
+
+#### Step 4 (Advanced): Resume from a specific cursor
+
+If you're using SSE format, each event includes an `id` field that you can use as a cursor to resume from a specific point:
+
+```bash
+# Resume from a specific cursor position
+curl -N "http://localhost:7071/api/agent/stream/${CONVERSATION_ID}?cursor=1734567890123-0"
+```
+
+### 3. Alternative: SSE Format for Programmatic Clients
+
+If you need the full Server-Sent Events format with cursors for resumable streaming, use `Accept: text/event-stream` (or omit the Accept header):
+
+```bash
+curl -i -N -X POST http://localhost:7071/api/agent/create \
+  -H "Content-Type: text/plain" \
+  -H "Accept: text/event-stream" \
+  -d "Plan a 7-day trip to Tokyo, Japan."
+```
+
+This returns SSE-formatted events with `id`, `event`, and `data` fields:
+
+```text
+id: 1734567890123-0
+event: message
+data: # 7-Day Tokyo Adventure
+
+id: 1734567890124-0
+event: message
+data: ## Day 1: Arrival and Exploration
+
+id: 1734567890999-0
+event: done
+data: [DONE]
+```
+
+The `id` field is the Redis stream entry ID - use it as the `cursor` parameter to resume from that exact point.
+
+### Understanding the Response Headers
+
+| Header | Description |
+|--------|-------------|
+| `x-conversation-id` | The conversation ID (session key). Use this to resume the stream. |
+| `Content-Type` | Either `text/plain` or `text/event-stream` depending on your `Accept` header. |
+| `Cache-Control` | Set to `no-cache` to prevent caching of the stream. |
+
+## Architecture Overview
+
+```text
+┌─────────────┐      POST /agent/create     ┌─────────────────────┐
+│   Client    │  (Accept: text/plain or SSE)│  Azure Functions    │
+│   (curl)    │ ──────────────────────────► │  (FunctionTriggers) │
+└─────────────┘                             └──────────┬──────────┘
+       ▲                                               │
+       │ Text or SSE stream                  Signal Entity
+       │                                               │
+       │                                               ▼
+       │                                    ┌─────────────────────┐
+       │                                    │   AgentEntity       │
+       │                                    │   (Durable Entity)  │
+       │                                    └──────────┬──────────┘
+       │                                               │
+       │                                    IAgentResponseHandler
+       │                                               │
+       │                                               ▼
+       │                                    ┌─────────────────────┐
+       │                                    │ RedisStreamResponse │
+       │                                    │      Handler        │
+       │                                    └──────────┬──────────┘
+       │                                               │
+       │                                     XADD (write)
+       │                                               │
+       │                                               ▼
+       │                                    ┌─────────────────────┐
+       └─────────── XREAD (poll) ────────── │   Redis Streams     │
+                                            │  (Durable Log)      │
+                                            └─────────────────────┘
+```
+
+### Data Flow
+
+1. **Client sends prompt**: The `Create` endpoint receives the prompt and generates a new agent thread.
+
+2. **Agent invoked**: The durable entity (`AgentEntity`) is signaled to run the travel planner agent. This is fire-and-forget from the HTTP request's perspective.
+
+3. **Responses captured**: As the agent generates responses, `RedisStreamResponseHandler` (implementing `IAgentResponseHandler`) extracts the text from each `AgentRunResponseUpdate` and publishes it to a Redis Stream keyed by session ID.
+
+4. **Client polls Redis**: The HTTP response streams events by polling the Redis Stream. For SSE format, each event includes the Redis entry ID as the `id` field.
+
+5. **Resumption**: If the client disconnects, it can call the `Stream` endpoint with the conversation ID (from the `x-conversation-id` header) and optionally the last received cursor to resume from that point.
+
+## Message Delivery Guarantees
+
+This sample provides **at-least-once delivery** with the following characteristics:
+
+- **Durability**: Messages are persisted to Redis Streams with configurable TTL (default: 10 minutes).
+- **Ordering**: Messages are delivered in order within a session.
+- **Resumption**: Clients can resume from any point using cursor-based pagination.
+- **Replay**: Clients can replay the entire stream by omitting the cursor.
+
+### Important Considerations
+
+- **No exactly-once delivery**: If a client disconnects exactly when receiving a message, it may receive that message again upon resumption. Clients should handle duplicate messages idempotently.
+- **TTL expiration**: Streams expire after the configured TTL. Clients cannot resume streams that have expired.
+- **Redis guarantees**: Redis streams are backed by Redis persistence mechanisms (RDB/AOF). Ensure your Redis instance is configured for durability as needed.
+
+## When to Use These Patterns
+
+The patterns demonstrated in this sample are ideal for:
+
+- **Long-running agent tasks**: When agent responses take minutes to complete (e.g., deep research, complex planning)
+- **Unreliable network connections**: Mobile apps, unstable WiFi, or connections that may drop
+- **Resumable experiences**: Users should be able to close and reopen an app without losing context
+- **Background processing**: When you want to fire off a task and check on it later
+
+These patterns may be overkill for:
+
+- **Simple, fast responses**: If responses complete in a few seconds, standard streaming is simpler
+- **Stateless interactions**: If there's no need to resume or replay conversations
+- **Very high throughput**: Redis adds latency; for maximum throughput, direct streaming may be better
+
+## Configuration
+
+| Environment Variable | Description | Default |
+|---------------------|-------------|---------|
+| `REDIS_CONNECTION_STRING` | Redis connection string | `localhost:6379` |
+| `REDIS_STREAM_TTL_MINUTES` | How long streams are retained after last write | `10` |
+| `AZURE_OPENAI_ENDPOINT` | Azure OpenAI endpoint URL | (required) |
+| `AZURE_OPENAI_DEPLOYMENT` | Azure OpenAI deployment name | (required) |
+| `AZURE_OPENAI_KEY` | API key (optional, uses Azure CLI auth if not set) | (optional) |
+
+## Cleanup
+
+To stop and remove the Redis Docker containers:
+
+```bash
+docker stop redis
+docker rm redis
+```
+
+## Disclaimer
+
+> ⚠️ **This sample is for illustration purposes only and is not intended to be production-ready.**
+>
+> A production implementation should consider:
+>
+> - Redis cluster configuration for high availability
+> - Authentication and authorization for the streaming endpoints
+> - Rate limiting and abuse prevention
+> - Monitoring and alerting for stream health
+> - Graceful handling of Redis failures

dotnet/samples/AzureFunctions/08_ReliableStreaming/RedisStreamResponseHandler.cs

@@ -0,0 +1,212 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Runtime.CompilerServices;
+using Microsoft.Agents.AI;
+using Microsoft.Agents.AI.DurableTask;
+using StackExchange.Redis;
+
+namespace ReliableStreaming;
+
+/// <summary>
+/// Represents a chunk of data read from a Redis stream.
+/// </summary>
+/// <param name="EntryId">The Redis stream entry ID (can be used as a cursor for resumption).</param>
+/// <param name="Text">The text content of the chunk, or null if this is a completion/error marker.</param>
+/// <param name="IsDone">True if this chunk marks the end of the stream.</param>
+/// <param name="Error">An error message if something went wrong, or null otherwise.</param>
+public readonly record struct StreamChunk(string EntryId, string? Text, bool IsDone, string? Error);
+
+/// <summary>
+/// An implementation of <see cref="IAgentResponseHandler"/> that publishes agent response updates
+/// to Redis Streams for reliable delivery. This enables clients to disconnect and reconnect
+/// to ongoing agent responses without losing messages.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Redis Streams provide a durable, append-only log that supports consumer groups and message
+/// acknowledgment. This implementation uses auto-generated IDs (which are timestamp-based)
+/// as sequence numbers, allowing clients to resume from any point in the stream.
+/// </para>
+/// <para>
+/// Each agent session gets its own Redis Stream, keyed by session ID. The stream entries
+/// contain text chunks extracted from <see cref="AgentRunResponseUpdate"/> objects.
+/// </para>
+/// </remarks>
+public sealed class RedisStreamResponseHandler : IAgentResponseHandler
+{
+    private const int MaxEmptyReads = 300; // 5 minutes at 1 second intervals
+    private const int PollIntervalMs = 1000;
+
+    private readonly IConnectionMultiplexer _redis;
+    private readonly TimeSpan _streamTtl;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="RedisStreamResponseHandler" /> class.
+    /// </summary>
+    /// <param name="redis">The Redis connection multiplexer.</param>
+    /// <param name="streamTtl">The time-to-live for stream entries. Streams will expire after this duration of inactivity.</param>
+    public RedisStreamResponseHandler(IConnectionMultiplexer redis, TimeSpan streamTtl)
+    {
+        this._redis = redis;
+        this._streamTtl = streamTtl;
+    }
+
+    /// <inheritdoc/>
+    public async ValueTask OnStreamingResponseUpdateAsync(
+        IAsyncEnumerable<AgentRunResponseUpdate> messageStream,
+        CancellationToken cancellationToken)
+    {
+        // Get the current session ID from the DurableAgentContext
+        // This is set by the AgentEntity before invoking the response handler
+        DurableAgentContext? context = DurableAgentContext.Current;
+        if (context is null)
+        {
+            throw new InvalidOperationException(
+                "DurableAgentContext.Current is not set. This handler must be used within a durable agent context.");
+        }
+
+        // Get session ID from the current thread context, which is only available in the context of
+        // a durable agent execution.
+        string agentSessionId = context.CurrentThread.GetService<AgentSessionId>().ToString();
+        string streamKey = GetStreamKey(agentSessionId);
+
+        IDatabase db = this._redis.GetDatabase();
+        int sequenceNumber = 0;
+
+        await foreach (AgentRunResponseUpdate update in messageStream.WithCancellation(cancellationToken))
+        {
+            // Extract just the text content - this avoids serialization round-trip issues
+            string text = update.Text;
+
+            // Only publish non-empty text chunks
+            if (!string.IsNullOrEmpty(text))
+            {
+                // Create the stream entry with the text and metadata
+                NameValueEntry[] entries =
+                [
+                    new NameValueEntry("text", text),
+                    new NameValueEntry("sequence", sequenceNumber++),
+                    new NameValueEntry("timestamp", DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()),
+                ];
+
+                // Add to the Redis Stream with auto-generated ID (timestamp-based)
+                await db.StreamAddAsync(streamKey, entries);
+
+                // Refresh the TTL on each write to keep the stream alive during active streaming
+                await db.KeyExpireAsync(streamKey, this._streamTtl);
+            }
+        }
+
+        // Add a sentinel entry to mark the end of the stream
+        NameValueEntry[] endEntries =
+        [
+            new NameValueEntry("text", ""),
+            new NameValueEntry("sequence", sequenceNumber),
+            new NameValueEntry("timestamp", DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()),
+            new NameValueEntry("done", "true"),
+        ];
+        await db.StreamAddAsync(streamKey, endEntries);
+
+        // Set final TTL - the stream will be cleaned up after this duration
+        await db.KeyExpireAsync(streamKey, this._streamTtl);
+    }
+
+    /// <inheritdoc/>
+    public ValueTask OnAgentResponseAsync(AgentRunResponse message, CancellationToken cancellationToken)
+    {
+        // This handler is optimized for streaming responses.
+        // For non-streaming responses, we don't need to store in Redis since
+        // the response is returned directly to the caller.
+        return ValueTask.CompletedTask;
+    }
+
+    /// <summary>
+    /// Reads chunks from a Redis stream for the given session, yielding them as they become available.
+    /// </summary>
+    /// <param name="conversationId">The conversation ID to read from.</param>
+    /// <param name="cursor">Optional cursor to resume from. If null, reads from the beginning.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>An async enumerable of stream chunks.</returns>
+    public async IAsyncEnumerable<StreamChunk> ReadStreamAsync(
+        string conversationId,
+        string? cursor,
+        [EnumeratorCancellation] CancellationToken cancellationToken)
+    {
+        string streamKey = GetStreamKey(conversationId);
+
+        IDatabase db = this._redis.GetDatabase();
+        string startId = string.IsNullOrEmpty(cursor) ? "0-0" : cursor;
+
+        int emptyReadCount = 0;
+        bool hasSeenData = false;
+
+        while (!cancellationToken.IsCancellationRequested)
+        {
+            StreamEntry[]? entries = null;
+            string? errorMessage = null;
+
+            try
+            {
+                entries = await db.StreamReadAsync(streamKey, startId, count: 100);
+            }
+            catch (Exception ex)
+            {
+                errorMessage = ex.Message;
+            }
+
+            if (errorMessage != null)
+            {
+                yield return new StreamChunk(startId, null, false, errorMessage);
+                yield break;
+            }
+
+            // entries is guaranteed to be non-null if errorMessage is null
+            if (entries!.Length == 0)
+            {
+                if (!hasSeenData)
+                {
+                    emptyReadCount++;
+                    if (emptyReadCount >= MaxEmptyReads)
+                    {
+                        yield return new StreamChunk(
+                            startId,
+                            null,
+                            false,
+                            $"Stream not found or timed out after {MaxEmptyReads * PollIntervalMs / 1000} seconds");
+                        yield break;
+                    }
+                }
+
+                await Task.Delay(PollIntervalMs, cancellationToken);
+                continue;
+            }
+
+            hasSeenData = true;
+
+            foreach (StreamEntry entry in entries)
+            {
+                startId = entry.Id.ToString();
+                string? text = entry["text"];
+                string? done = entry["done"];
+
+                if (done == "true")
+                {
+                    yield return new StreamChunk(startId, null, true, null);
+                    yield break;
+                }
+
+                if (!string.IsNullOrEmpty(text))
+                {
+                    yield return new StreamChunk(startId, text, false, null);
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// Gets the Redis Stream key for a given conversation ID.
+    /// </summary>
+    /// <param name="conversationId">The conversation ID.</param>
+    /// <returns>The Redis Stream key.</returns>
+    internal static string GetStreamKey(string conversationId) => $"agent-stream:{conversationId}";
+}

dotnet/samples/AzureFunctions/08_ReliableStreaming/Tools.cs

@@ -0,0 +1,161 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.ComponentModel;
+
+namespace ReliableStreaming;
+
+/// <summary>
+/// Mock travel tools that return hardcoded data for demonstration purposes.
+/// In a real application, these would call actual weather and events APIs.
+/// </summary>
+internal static class TravelTools
+{
+    /// <summary>
+    /// Gets a weather forecast for a destination on a specific date.
+    /// Returns mock weather data for demonstration purposes.
+    /// </summary>
+    /// <param name="destination">The destination city or location.</param>
+    /// <param name="date">The date for the forecast (e.g., "2025-01-15" or "next Monday").</param>
+    /// <returns>A weather forecast summary.</returns>
+    [Description("Gets the weather forecast for a destination on a specific date. Use this to provide weather-aware recommendations in the itinerary.")]
+    public static string GetWeatherForecast(string destination, string date)
+    {
+        // Mock weather data based on destination for realistic responses
+        Dictionary<string, (string condition, int highF, int lowF)> weatherByRegion = new(StringComparer.OrdinalIgnoreCase)
+        {
+            ["Tokyo"] = ("Partly cloudy with a chance of light rain", 58, 45),
+            ["Paris"] = ("Overcast with occasional drizzle", 52, 41),
+            ["New York"] = ("Clear and cold", 42, 28),
+            ["London"] = ("Foggy morning, clearing in afternoon", 48, 38),
+            ["Sydney"] = ("Sunny and warm", 82, 68),
+            ["Rome"] = ("Sunny with light breeze", 62, 48),
+            ["Barcelona"] = ("Partly sunny", 59, 47),
+            ["Amsterdam"] = ("Cloudy with light rain", 46, 38),
+            ["Dubai"] = ("Sunny and hot", 85, 72),
+            ["Singapore"] = ("Tropical thunderstorms in afternoon", 88, 77),
+            ["Bangkok"] = ("Hot and humid, afternoon showers", 91, 78),
+            ["Los Angeles"] = ("Sunny and pleasant", 72, 55),
+            ["San Francisco"] = ("Morning fog, afternoon sun", 62, 52),
+            ["Seattle"] = ("Rainy with breaks", 48, 40),
+            ["Miami"] = ("Warm and sunny", 78, 65),
+            ["Honolulu"] = ("Tropical paradise weather", 82, 72),
+        };
+
+        // Find a matching destination or use a default
+        (string condition, int highF, int lowF) forecast = ("Partly cloudy", 65, 50);
+        foreach (KeyValuePair<string, (string, int, int)> entry in weatherByRegion)
+        {
+            if (destination.Contains(entry.Key, StringComparison.OrdinalIgnoreCase))
+            {
+                forecast = entry.Value;
+                break;
+            }
+        }
+
+        return $"""
+            Weather forecast for {destination} on {date}:
+            Conditions: {forecast.condition}
+            High: {forecast.highF}°F ({(forecast.highF - 32) * 5 / 9}°C)
+            Low: {forecast.lowF}°F ({(forecast.lowF - 32) * 5 / 9}°C)
+            
+            Recommendation: {GetWeatherRecommendation(forecast.condition)}
+            """;
+    }
+
+    /// <summary>
+    /// Gets local events happening at a destination around a specific date.
+    /// Returns mock event data for demonstration purposes.
+    /// </summary>
+    /// <param name="destination">The destination city or location.</param>
+    /// <param name="date">The date to search for events (e.g., "2025-01-15" or "next week").</param>
+    /// <returns>A list of local events and activities.</returns>
+    [Description("Gets local events and activities happening at a destination around a specific date. Use this to suggest timely activities and experiences.")]
+    public static string GetLocalEvents(string destination, string date)
+    {
+        // Mock events data based on destination
+        Dictionary<string, string[]> eventsByCity = new(StringComparer.OrdinalIgnoreCase)
+        {
+            ["Tokyo"] = [
+                "🎭 Kabuki Theater Performance at Kabukiza Theatre - Traditional Japanese drama",
+                "🌸 Winter Illuminations at Yoyogi Park - Spectacular light displays",
+                "🍜 Ramen Festival at Tokyo Station - Sample ramen from across Japan",
+                "🎮 Gaming Expo at Tokyo Big Sight - Latest video games and technology",
+            ],
+            ["Paris"] = [
+                "🎨 Impressionist Exhibition at Musée d'Orsay - Extended evening hours",
+                "🍷 Wine Tasting Tour in Le Marais - Local sommelier guided",
+                "🎵 Jazz Night at Le Caveau de la Huchette - Historic jazz club",
+                "🥐 French Pastry Workshop - Learn from master pâtissiers",
+            ],
+            ["New York"] = [
+                "🎭 Broadway Show: Hamilton - Limited engagement performances",
+                "🏀 Knicks vs Lakers at Madison Square Garden",
+                "🎨 Modern Art Exhibit at MoMA - New installations",
+                "🍕 Pizza Walking Tour of Brooklyn - Artisan pizzerias",
+            ],
+            ["London"] = [
+                "👑 Royal Collection Exhibition at Buckingham Palace",
+                "🎭 West End Musical: The Phantom of the Opera",
+                "🍺 Craft Beer Festival at Brick Lane",
+                "🎪 Winter Wonderland at Hyde Park - Rides and markets",
+            ],
+            ["Sydney"] = [
+                "🏄 Pro Surfing Competition at Bondi Beach",
+                "🎵 Opera at Sydney Opera House - La Bohème",
+                "🦘 Wildlife Night Safari at Taronga Zoo",
+                "🍽️ Harbor Dinner Cruise with fireworks",
+            ],
+            ["Rome"] = [
+                "🏛️ After-Hours Vatican Tour - Skip the crowds",
+                "🍝 Pasta Making Class in Trastevere",
+                "🎵 Classical Concert at Borghese Gallery",
+                "🍷 Wine Tasting in Roman Cellars",
+            ],
+        };
+
+        // Find events for the destination or use generic events
+        string[] events = [
+            "🎭 Local theater performance",
+            "🍽️ Food and wine festival",
+            "🎨 Art gallery opening",
+            "🎵 Live music at local venues",
+        ];
+
+        foreach (KeyValuePair<string, string[]> entry in eventsByCity)
+        {
+            if (destination.Contains(entry.Key, StringComparison.OrdinalIgnoreCase))
+            {
+                events = entry.Value;
+                break;
+            }
+        }
+
+        string eventList = string.Join("\n• ", events);
+        return $"""
+            Local events in {destination} around {date}:
+            
+            • {eventList}
+            
+            💡 Tip: Book popular events in advance as they may sell out quickly!
+            """;
+    }
+
+    private static string GetWeatherRecommendation(string condition)
+    {
+        // Use case-insensitive comparison instead of ToLowerInvariant() to satisfy CA1308
+        return condition switch
+        {
+            string c when c.Contains("rain", StringComparison.OrdinalIgnoreCase) || c.Contains("drizzle", StringComparison.OrdinalIgnoreCase) =>
+                "Bring an umbrella and waterproof jacket. Consider indoor activities for backup.",
+            string c when c.Contains("fog", StringComparison.OrdinalIgnoreCase) =>
+                "Morning visibility may be limited. Plan outdoor sightseeing for afternoon.",
+            string c when c.Contains("cold", StringComparison.OrdinalIgnoreCase) =>
+                "Layer up with warm clothing. Hot drinks and cozy cafés recommended.",
+            string c when c.Contains("hot", StringComparison.OrdinalIgnoreCase) || c.Contains("warm", StringComparison.OrdinalIgnoreCase) =>
+                "Stay hydrated and use sunscreen. Plan strenuous activities for cooler morning hours.",
+            string c when c.Contains("thunder", StringComparison.OrdinalIgnoreCase) || c.Contains("storm", StringComparison.OrdinalIgnoreCase) =>
+                "Keep an eye on weather updates. Have indoor alternatives ready.",
+            _ => "Pleasant conditions expected. Great day for outdoor exploration!"
+        };
+    }
+}

dotnet/samples/AzureFunctions/08_ReliableStreaming/host.json

@@ -0,0 +1,21 @@
+{
+  "version": "2.0",
+  "logging": {
+    "logLevel": {
+      "Microsoft.Agents.AI.DurableTask": "Information",
+      "Microsoft.Agents.AI.Hosting.AzureFunctions": "Information",
+      "DurableTask": "Information",
+      "Microsoft.DurableTask": "Information",
+      "ReliableStreaming": "Information"
+    }
+  },
+  "extensions": {
+    "durableTask": {
+      "hubName": "default",
+      "storageProvider": {
+        "type": "AzureManaged",
+        "connectionStringName": "DURABLE_TASK_SCHEDULER_CONNECTION_STRING"
+      }
+    }
+  }
+}

dotnet/samples/AzureFunctions/08_ReliableStreaming/local.settings.json

@@ -0,0 +1,12 @@
+{
+  "IsEncrypted": false,
+  "Values": {
+    "FUNCTIONS_WORKER_RUNTIME": "dotnet-isolated",
+    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
+    "DURABLE_TASK_SCHEDULER_CONNECTION_STRING": "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None",
+    "AZURE_OPENAI_ENDPOINT": "<AZURE_OPENAI_ENDPOINT>",
+    "AZURE_OPENAI_DEPLOYMENT": "<AZURE_OPENAI_DEPLOYMENT>",
+    "REDIS_CONNECTION_STRING": "localhost:6379",
+    "REDIS_STREAM_TTL_MINUTES": "10"
+  }
+}

dotnet/samples/AzureFunctions/README.md

@@ -9,6 +9,7 @@ This directory contains samples for Azure Functions.
 - **[05_AgentOrchestration_HITL](05_AgentOrchestration_HITL)**: A sample that demonstrates how to implement a human-in-the-loop workflow using durable orchestration, including external event handling for human approval.
 - **[06_LongRunningTools](06_LongRunningTools)**: A sample that demonstrates how agents can start and interact with durable orchestrations from tool calls to enable long-running tool scenarios.
 - **[07_AgentAsMcpTool](07_AgentAsMcpTool)**: A sample that demonstrates how to configure durable AI agents to be accessible as Model Context Protocol (MCP) tools.
+- **[08_ReliableStreaming](08_ReliableStreaming)**: A sample that demonstrates how to implement reliable streaming for durable agents using Redis Streams, enabling clients to disconnect and reconnect without losing messages.
 
 ## Running the Samples
 

dotnet/samples/GettingStarted/AGUI/Step04_HumanInLoop/Client/ServerFunctionApprovalClientAgent.cs

@@ -22,17 +22,17 @@ internal sealed class ServerFunctionApprovalClientAgent : DelegatingAIAgent
         this._jsonSerializerOptions = jsonSerializerOptions;
     }
 
-    public override Task<AgentRunResponse> RunAsync(
+    protected override Task<AgentRunResponse> RunCoreAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,
         CancellationToken cancellationToken = default)
     {
-        return this.RunStreamingAsync(messages, thread, options, cancellationToken)
+        return this.RunCoreStreamingAsync(messages, thread, options, cancellationToken)
             .ToAgentRunResponseAsync(cancellationToken);
     }
 
-    public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+    protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,

dotnet/samples/GettingStarted/AGUI/Step04_HumanInLoop/Server/ServerFunctionApprovalServerAgent.cs

@@ -22,17 +22,17 @@ internal sealed class ServerFunctionApprovalAgent : DelegatingAIAgent
         this._jsonSerializerOptions = jsonSerializerOptions;
     }
 
-    public override Task<AgentRunResponse> RunAsync(
+    protected override Task<AgentRunResponse> RunCoreAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,
         CancellationToken cancellationToken = default)
     {
-        return this.RunStreamingAsync(messages, thread, options, cancellationToken)
+        return this.RunCoreStreamingAsync(messages, thread, options, cancellationToken)
             .ToAgentRunResponseAsync(cancellationToken);
     }
 
-    public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+    protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,

dotnet/samples/GettingStarted/AGUI/Step05_StateManagement/Client/StatefulAgent.cs

@@ -35,18 +35,18 @@ internal sealed class StatefulAgent<TState> : DelegatingAIAgent
     }
 
     /// <inheritdoc />
-    public override Task<AgentRunResponse> RunAsync(
+    protected override Task<AgentRunResponse> RunCoreAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,
         CancellationToken cancellationToken = default)
     {
-        return this.RunStreamingAsync(messages, thread, options, cancellationToken)
+        return this.RunCoreStreamingAsync(messages, thread, options, cancellationToken)
             .ToAgentRunResponseAsync(cancellationToken);
     }
 
     /// <inheritdoc />
-    public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+    protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,

dotnet/samples/GettingStarted/AGUI/Step05_StateManagement/Server/SharedStateAgent.cs

@@ -17,17 +17,17 @@ internal sealed class SharedStateAgent : DelegatingAIAgent
         this._jsonSerializerOptions = jsonSerializerOptions;
     }
 
-    public override Task<AgentRunResponse> RunAsync(
+    protected override Task<AgentRunResponse> RunCoreAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,
         CancellationToken cancellationToken = default)
     {
-        return this.RunStreamingAsync(messages, thread, options, cancellationToken)
+        return this.RunCoreStreamingAsync(messages, thread, options, cancellationToken)
             .ToAgentRunResponseAsync(cancellationToken);
     }
 
-    public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+    protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,

dotnet/samples/GettingStarted/AgentProviders/Agent_With_CustomImplementation/Program.cs

@@ -34,7 +34,7 @@ namespace SampleApp
         public override AgentThread DeserializeThread(JsonElement serializedThread, JsonSerializerOptions? jsonSerializerOptions = null)
             => new CustomAgentThread(serializedThread, jsonSerializerOptions);
 
-        public override async Task<AgentRunResponse> RunAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
+        protected override async Task<AgentRunResponse> RunCoreAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
         {
             // Create a thread if the user didn't supply one.
             thread ??= this.GetNewThread();
@@ -44,11 +44,19 @@ namespace SampleApp
                 throw new ArgumentException($"The provided thread is not of type {nameof(CustomAgentThread)}.", nameof(thread));
             }
 
+            // Get existing messages from the store
+            var invokingContext = new ChatMessageStore.InvokingContext(messages);
+            var storeMessages = await typedThread.MessageStore.InvokingAsync(invokingContext, cancellationToken);
+
             // Clone the input messages and turn them into response messages with upper case text.
             List<ChatMessage> responseMessages = CloneAndToUpperCase(messages, this.Name).ToList();
 
             // Notify the thread of the input and output messages.
-            await typedThread.MessageStore.AddMessagesAsync(messages.Concat(responseMessages), cancellationToken);
+            var invokedContext = new ChatMessageStore.InvokedContext(messages, storeMessages)
+            {
+                ResponseMessages = responseMessages
+            };
+            await typedThread.MessageStore.InvokedAsync(invokedContext, cancellationToken);
 
             return new AgentRunResponse
             {
@@ -58,7 +66,7 @@ namespace SampleApp
             };
         }
 
-        public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, [EnumeratorCancellation] CancellationToken cancellationToken = default)
+        protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, [EnumeratorCancellation] CancellationToken cancellationToken = default)
         {
             // Create a thread if the user didn't supply one.
             thread ??= this.GetNewThread();
@@ -68,11 +76,19 @@ namespace SampleApp
                 throw new ArgumentException($"The provided thread is not of type {nameof(CustomAgentThread)}.", nameof(thread));
             }
 
+            // Get existing messages from the store
+            var invokingContext = new ChatMessageStore.InvokingContext(messages);
+            var storeMessages = await typedThread.MessageStore.InvokingAsync(invokingContext, cancellationToken);
+
             // Clone the input messages and turn them into response messages with upper case text.
             List<ChatMessage> responseMessages = CloneAndToUpperCase(messages, this.Name).ToList();
 
             // Notify the thread of the input and output messages.
-            await typedThread.MessageStore.AddMessagesAsync(messages.Concat(responseMessages), cancellationToken);
+            var invokedContext = new ChatMessageStore.InvokedContext(messages, storeMessages)
+            {
+                ResponseMessages = responseMessages
+            };
+            await typedThread.MessageStore.InvokedAsync(invokedContext, cancellationToken);
 
             foreach (var message in responseMessages)
             {

dotnet/samples/GettingStarted/AgentWithOpenAI/Agent_OpenAI_Step03_CreateFromChatClient/OpenAIChatClientAgent.cs

@@ -87,10 +87,10 @@ public class OpenAIChatClientAgent : DelegatingAIAgent
     }
 
     /// <inheritdoc/>
-    public sealed override Task<AgentRunResponse> RunAsync(IEnumerable<Microsoft.Extensions.AI.ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default) =>
-        base.RunAsync(messages, thread, options, cancellationToken);
+    protected sealed override Task<AgentRunResponse> RunCoreAsync(IEnumerable<Microsoft.Extensions.AI.ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default) =>
+        base.RunCoreAsync(messages, thread, options, cancellationToken);
 
     /// <inheritdoc/>
-    public override IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(IEnumerable<Microsoft.Extensions.AI.ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default) =>
-        base.RunStreamingAsync(messages, thread, options, cancellationToken);
+    protected override IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(IEnumerable<Microsoft.Extensions.AI.ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default) =>
+        base.RunCoreStreamingAsync(messages, thread, options, cancellationToken);
 }

dotnet/samples/GettingStarted/AgentWithOpenAI/Agent_OpenAI_Step04_CreateFromOpenAIResponseClient/OpenAIResponseClientAgent.cs

@@ -105,10 +105,10 @@ public class OpenAIResponseClientAgent : DelegatingAIAgent
     }
 
     /// <inheritdoc/>
-    public sealed override Task<AgentRunResponse> RunAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default) =>
-        base.RunAsync(messages, thread, options, cancellationToken);
+    protected sealed override Task<AgentRunResponse> RunCoreAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default) =>
+        base.RunCoreAsync(messages, thread, options, cancellationToken);
 
     /// <inheritdoc/>
-    public sealed override IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default) =>
-        base.RunStreamingAsync(messages, thread, options, cancellationToken);
+    protected sealed override IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default) =>
+        base.RunCoreStreamingAsync(messages, thread, options, cancellationToken);
 }

dotnet/samples/GettingStarted/AgentWithRAG/AgentWithRAG_Step01_BasicTextRAG/Program.cs

@@ -62,7 +62,12 @@ AIAgent agent = azureOpenAIClient
     .CreateAIAgent(new ChatClientAgentOptions
     {
         ChatOptions = new() { Instructions = "You are a helpful support specialist for Contoso Outdoors. Answer questions using the provided context and cite the source document when available." },
-        AIContextProviderFactory = ctx => new TextSearchProvider(SearchAdapter, ctx.SerializedState, ctx.JsonSerializerOptions, textSearchOptions)
+        AIContextProviderFactory = ctx => new TextSearchProvider(SearchAdapter, ctx.SerializedState, ctx.JsonSerializerOptions, textSearchOptions),
+        // Since we are using ChatCompletion which stores chat history locally, we can also add a message removal policy
+        // that removes messages produced by the TextSearchProvider before they are added to the chat history, so that
+        // we don't bloat chat history with all the search result messages.
+        ChatMessageStoreFactory = ctx => new InMemoryChatMessageStore(ctx.SerializedState, ctx.JsonSerializerOptions)
+            .WithAIContextProviderMessageRemoval(),
     });
 
 AgentThread thread = agent.GetNewThread();

dotnet/samples/GettingStarted/Agents/Agent_Step07_3rdPartyThreadStorage/Program.cs

@@ -89,24 +89,7 @@ namespace SampleApp
 
         public string? ThreadDbKey { get; private set; }
 
-        public override async Task AddMessagesAsync(IEnumerable<ChatMessage> messages, CancellationToken cancellationToken = default)
-        {
-            this.ThreadDbKey ??= Guid.NewGuid().ToString("N");
-
-            var collection = this._vectorStore.GetCollection<string, ChatHistoryItem>("ChatHistory");
-            await collection.EnsureCollectionExistsAsync(cancellationToken);
-
-            await collection.UpsertAsync(messages.Select(x => new ChatHistoryItem()
-            {
-                Key = this.ThreadDbKey + x.MessageId,
-                Timestamp = DateTimeOffset.UtcNow,
-                ThreadId = this.ThreadDbKey,
-                SerializedMessage = JsonSerializer.Serialize(x),
-                MessageText = x.Text
-            }), cancellationToken);
-        }
-
-        public override async Task<IEnumerable<ChatMessage>> GetMessagesAsync(CancellationToken cancellationToken = default)
+        public override async ValueTask<IEnumerable<ChatMessage>> InvokingAsync(InvokingContext context, CancellationToken cancellationToken = default)
         {
             var collection = this._vectorStore.GetCollection<string, ChatHistoryItem>("ChatHistory");
             await collection.EnsureCollectionExistsAsync(cancellationToken);
@@ -124,6 +107,33 @@ namespace SampleApp
             return messages;
         }
 
+        public override async ValueTask InvokedAsync(InvokedContext context, CancellationToken cancellationToken = default)
+        {
+            // Don't store messages if the request failed.
+            if (context.InvokeException is not null)
+            {
+                return;
+            }
+
+            this.ThreadDbKey ??= Guid.NewGuid().ToString("N");
+
+            var collection = this._vectorStore.GetCollection<string, ChatHistoryItem>("ChatHistory");
+            await collection.EnsureCollectionExistsAsync(cancellationToken);
+
+            // Add both request and response messages to the store
+            // Optionally messages produced by the AIContextProvider can also be persisted (not shown).
+            var allNewMessages = context.RequestMessages.Concat(context.AIContextProviderMessages ?? []).Concat(context.ResponseMessages ?? []);
+
+            await collection.UpsertAsync(allNewMessages.Select(x => new ChatHistoryItem()
+            {
+                Key = this.ThreadDbKey + x.MessageId,
+                Timestamp = DateTimeOffset.UtcNow,
+                ThreadId = this.ThreadDbKey,
+                SerializedMessage = JsonSerializer.Serialize(x),
+                MessageText = x.Text
+            }), cancellationToken);
+        }
+
         public override JsonElement Serialize(JsonSerializerOptions? jsonSerializerOptions = null) =>
             // We have to serialize the thread id, so that on deserialization we can retrieve the messages using the same thread id.
             JsonSerializer.SerializeToElement(this.ThreadDbKey);

dotnet/samples/M365Agent/Agents/WeatherForecastAgent.cs

@@ -48,9 +48,9 @@ public class WeatherForecastAgent : DelegatingAIAgent
     {
     }
 
-    public override async Task<AgentRunResponse> RunAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
+    protected override async Task<AgentRunResponse> RunCoreAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
     {
-        var response = await base.RunAsync(messages, thread, options, cancellationToken);
+        var response = await base.RunCoreAsync(messages, thread, options, cancellationToken);
 
         // If the agent returned a valid structured output response
         // we might be able to enhance the response with an adaptive card.

dotnet/src/Microsoft.Agents.AI.A2A/A2AAgent.cs

@@ -68,7 +68,7 @@ internal sealed class A2AAgent : AIAgent
         => new A2AAgentThread(serializedThread, jsonSerializerOptions);
 
     /// <inheritdoc/>
-    public override async Task<AgentRunResponse> RunAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
+    protected override async Task<AgentRunResponse> RunCoreAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
     {
         _ = Throw.IfNull(messages);
 
@@ -131,7 +131,7 @@ internal sealed class A2AAgent : AIAgent
     }
 
     /// <inheritdoc/>
-    public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, [EnumeratorCancellation] CancellationToken cancellationToken = default)
+    protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, [EnumeratorCancellation] CancellationToken cancellationToken = default)
     {
         _ = Throw.IfNull(messages);
 

dotnet/src/Microsoft.Agents.AI.Abstractions/AIAgent.cs

@@ -218,6 +218,35 @@ public abstract class AIAgent
     /// <returns>A task that represents the asynchronous operation. The task result contains an <see cref="AgentRunResponse"/> with the agent's output.</returns>
     /// <remarks>
     /// <para>
+    /// This method delegates to <see cref="RunCoreAsync"/> to perform the actual agent invocation. It handles collections of messages,
+    /// allowing for complex conversational scenarios including multi-turn interactions, function calls, and
+    /// context-rich conversations.
+    /// </para>
+    /// <para>
+    /// The messages are processed in the order provided and become part of the conversation history.
+    /// The agent's response will also be added to <paramref name="thread"/> if one is provided.
+    /// </para>
+    /// </remarks>
+    public Task<AgentRunResponse> RunAsync(
+        IEnumerable<ChatMessage> messages,
+        AgentThread? thread = null,
+        AgentRunOptions? options = null,
+        CancellationToken cancellationToken = default) =>
+        this.RunCoreAsync(messages, thread, options, cancellationToken);
+
+    /// <summary>
+    /// Core implementation of the agent invocation logic with a collection of chat messages.
+    /// </summary>
+    /// <param name="messages">The collection of messages to send to the agent for processing.</param>
+    /// <param name="thread">
+    /// The conversation thread to use for this invocation. If <see langword="null"/>, a new thread will be created.
+    /// The thread will be updated with the input messages and any response messages generated during invocation.
+    /// </param>
+    /// <param name="options">Optional configuration parameters for controlling the agent's invocation behavior.</param>
+    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
+    /// <returns>A task that represents the asynchronous operation. The task result contains an <see cref="AgentRunResponse"/> with the agent's output.</returns>
+    /// <remarks>
+    /// <para>
     /// This is the primary invocation method that implementations must override. It handles collections of messages,
     /// allowing for complex conversational scenarios including multi-turn interactions, function calls, and
     /// context-rich conversations.
@@ -227,7 +256,7 @@ public abstract class AIAgent
     /// The agent's response will also be added to <paramref name="thread"/> if one is provided.
     /// </para>
     /// </remarks>
-    public abstract Task<AgentRunResponse> RunAsync(
+    protected abstract Task<AgentRunResponse> RunCoreAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,
@@ -312,6 +341,34 @@ public abstract class AIAgent
     /// <returns>An asynchronous enumerable of <see cref="AgentRunResponseUpdate"/> instances representing the streaming response.</returns>
     /// <remarks>
     /// <para>
+    /// This method delegates to <see cref="RunCoreStreamingAsync"/> to perform the actual streaming invocation. It provides real-time
+    /// updates as the agent processes the input and generates its response, enabling more responsive user experiences.
+    /// </para>
+    /// <para>
+    /// Each <see cref="AgentRunResponseUpdate"/> represents a portion of the complete response, allowing consumers
+    /// to display partial results, implement progressive loading, or provide immediate feedback to users.
+    /// </para>
+    /// </remarks>
+    public IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+        IEnumerable<ChatMessage> messages,
+        AgentThread? thread = null,
+        AgentRunOptions? options = null,
+        CancellationToken cancellationToken = default) =>
+        this.RunCoreStreamingAsync(messages, thread, options, cancellationToken);
+
+    /// <summary>
+    /// Core implementation of the agent streaming invocation logic with a collection of chat messages.
+    /// </summary>
+    /// <param name="messages">The collection of messages to send to the agent for processing.</param>
+    /// <param name="thread">
+    /// The conversation thread to use for this invocation. If <see langword="null"/>, a new thread will be created.
+    /// The thread will be updated with the input messages and any response updates generated during invocation.
+    /// </param>
+    /// <param name="options">Optional configuration parameters for controlling the agent's invocation behavior.</param>
+    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
+    /// <returns>An asynchronous enumerable of <see cref="AgentRunResponseUpdate"/> instances representing the streaming response.</returns>
+    /// <remarks>
+    /// <para>
     /// This is the primary streaming invocation method that implementations must override. It provides real-time
     /// updates as the agent processes the input and generates its response, enabling more responsive user experiences.
     /// </para>
@@ -320,7 +377,7 @@ public abstract class AIAgent
     /// to display partial results, implement progressive loading, or provide immediate feedback to users.
     /// </para>
     /// </remarks>
-    public abstract IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+    protected abstract IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,

dotnet/src/Microsoft.Agents.AI.Abstractions/AgentThread.cs

@@ -68,7 +68,7 @@ public abstract class AgentThread
     /// <exception cref="ArgumentNullException"><paramref name="serviceType"/> is <see langword="null"/>.</exception>
     /// <remarks>
     /// The purpose of this method is to allow for the retrieval of strongly-typed services that might be provided by the <see cref="AgentThread"/>,
-    /// including itself or any services it might be wrapping. For example, to access the <see cref="AgentThreadMetadata"/> for the instance,
+    /// including itself or any services it might be wrapping. For example, to access a <see cref="ChatMessageStore"/> if available for the instance,
     /// <see cref="GetService"/> may be used to request it.
     /// </remarks>
     public virtual object? GetService(Type serviceType, object? serviceKey = null)

dotnet/src/Microsoft.Agents.AI.Abstractions/AgentThreadMetadata.cs

@@ -1,29 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using System.Diagnostics;
-
-namespace Microsoft.Agents.AI;
-
-/// <summary>
-/// Provides metadata information about an <see cref="AgentThread"/> instance.
-/// </summary>
-[DebuggerDisplay("ConversationId = {ConversationId}")]
-public class AgentThreadMetadata
-{
-    /// <summary>
-    /// Initializes a new instance of the <see cref="AgentThreadMetadata"/> class.
-    /// </summary>
-    /// <param name="conversationId">The unique identifier for the conversation, if available.</param>
-    public AgentThreadMetadata(string? conversationId)
-    {
-        this.ConversationId = conversationId;
-    }
-
-    /// <summary>
-    /// Gets the unique identifier for the conversation, if available.
-    /// </summary>
-    /// <remarks>
-    /// The meaning of this ID may vary depending on the agent implementation.
-    /// </remarks>
-    public string? ConversationId { get; }
-}

dotnet/src/Microsoft.Agents.AI.Abstractions/ChatMessageStore.cs

@@ -32,8 +32,9 @@ namespace Microsoft.Agents.AI;
 public abstract class ChatMessageStore
 {
     /// <summary>
-    /// Asynchronously retrieves all messages from the store that should be provided as context for the next agent invocation.
+    /// Called at the start of agent invocation to retrieve all messages from the store that should be provided as context for the next agent invocation.
     /// </summary>
+    /// <param name="context">Contains the request context including the caller provided messages that will be used by the agent for this invocation.</param>
     /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
     /// <returns>
     /// A task that represents the asynchronous operation. The task result contains a collection of <see cref="ChatMessage"/>
@@ -59,20 +60,19 @@ public abstract class ChatMessageStore
     /// and context management.
     /// </para>
     /// </remarks>
-    public abstract Task<IEnumerable<ChatMessage>> GetMessagesAsync(CancellationToken cancellationToken = default);
+    public abstract ValueTask<IEnumerable<ChatMessage>> InvokingAsync(InvokingContext context, CancellationToken cancellationToken = default);
 
     /// <summary>
-    /// Asynchronously adds new messages to the store.
+    /// Called at the end of the agent invocation to add new messages to the store.
     /// </summary>
-    /// <param name="messages">The collection of chat messages to add to the store.</param>
+    /// <param name="context">Contains the invocation context including request messages, response messages, and any exception that occurred.</param>
     /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
     /// <returns>A task that represents the asynchronous add operation.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="messages"/> is <see langword="null"/>.</exception>
     /// <remarks>
     /// <para>
     /// Messages should be added in the order they were generated to maintain proper chronological sequence.
     /// The store is responsible for preserving message ordering and ensuring that subsequent calls to
-    /// <see cref="GetMessagesAsync"/> return messages in the correct chronological order.
+    /// <see cref="InvokingAsync"/> return messages in the correct chronological order.
     /// </para>
     /// <para>
     /// Implementations may perform additional processing during message addition, such as:
@@ -83,8 +83,12 @@ public abstract class ChatMessageStore
     /// <item><description>Updating indices or search capabilities</description></item>
     /// </list>
     /// </para>
+    /// <para>
+    /// This method is called regardless of whether the invocation succeeded or failed.
+    /// To check if the invocation was successful, inspect the <see cref="InvokedContext.InvokeException"/> property.
+    /// </para>
     /// </remarks>
-    public abstract Task AddMessagesAsync(IEnumerable<ChatMessage> messages, CancellationToken cancellationToken = default);
+    public abstract ValueTask InvokedAsync(InvokedContext context, CancellationToken cancellationToken = default);
 
     /// <summary>
     /// Serializes the current object's state to a <see cref="JsonElement"/> using the specified serialization options.
@@ -121,4 +125,100 @@ public abstract class ChatMessageStore
     /// </remarks>
     public TService? GetService<TService>(object? serviceKey = null)
         => this.GetService(typeof(TService), serviceKey) is TService service ? service : default;
+
+    /// <summary>
+    /// Contains the context information provided to <see cref="InvokingAsync(InvokingContext, CancellationToken)"/>.
+    /// </summary>
+    /// <remarks>
+    /// This class provides context about the invocation before the messages are retrieved from the store,
+    /// including the new messages that will be used. Stores can use this information to determine what
+    /// messages should be retrieved for the invocation.
+    /// </remarks>
+    public sealed class InvokingContext
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InvokingContext"/> class with the specified request messages.
+        /// </summary>
+        /// <param name="requestMessages">The new messages to be used by the agent for this invocation.</param>
+        /// <exception cref="ArgumentNullException"><paramref name="requestMessages"/> is <see langword="null"/>.</exception>
+        public InvokingContext(IEnumerable<ChatMessage> requestMessages)
+        {
+            this.RequestMessages = requestMessages ?? throw new ArgumentNullException(nameof(requestMessages));
+        }
+
+        /// <summary>
+        /// Gets the caller provided messages that will be used by the agent for this invocation.
+        /// </summary>
+        /// <value>
+        /// A collection of <see cref="ChatMessage"/> instances representing new messages that were provided by the caller.
+        /// </value>
+        public IEnumerable<ChatMessage> RequestMessages { get; }
+    }
+
+    /// <summary>
+    /// Contains the context information provided to <see cref="InvokedAsync(InvokedContext, CancellationToken)"/>.
+    /// </summary>
+    /// <remarks>
+    /// This class provides context about a completed agent invocation, including both the
+    /// request messages that were used and the response messages that were generated. It also indicates
+    /// whether the invocation succeeded or failed.
+    /// </remarks>
+    public sealed class InvokedContext
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InvokedContext"/> class with the specified request messages.
+        /// </summary>
+        /// <param name="requestMessages">The caller provided messages that were used by the agent for this invocation.</param>
+        /// <param name="chatMessageStoreMessages">The messages retrieved from the <see cref="ChatMessageStore"/> for this invocation.</param>
+        /// <exception cref="ArgumentNullException"><paramref name="requestMessages"/> is <see langword="null"/>.</exception>
+        public InvokedContext(IEnumerable<ChatMessage> requestMessages, IEnumerable<ChatMessage> chatMessageStoreMessages)
+        {
+            this.RequestMessages = Throw.IfNull(requestMessages);
+            this.ChatMessageStoreMessages = chatMessageStoreMessages;
+        }
+
+        /// <summary>
+        /// Gets the caller provided messages that were used by the agent for this invocation.
+        /// </summary>
+        /// <value>
+        /// A collection of <see cref="ChatMessage"/> instances representing new messages that were provided by the caller.
+        /// This does not include any <see cref="ChatMessageStore"/> supplied messages.
+        /// </value>
+        public IEnumerable<ChatMessage> RequestMessages { get; }
+
+        /// <summary>
+        /// Gets the messages retrieved from the <see cref="ChatMessageStore"/> for this invocation, if any.
+        /// </summary>
+        /// <value>
+        /// A collection of <see cref="ChatMessage"/> instances that were retrieved from the <see cref="ChatMessageStore"/>,
+        /// and were used by the agent as part of the invocation.
+        /// </value>
+        public IEnumerable<ChatMessage> ChatMessageStoreMessages { get; }
+
+        /// <summary>
+        /// Gets or sets the messages provided by the <see cref="AIContextProvider"/> for this invocation, if any.
+        /// </summary>
+        /// <value>
+        /// A collection of <see cref="ChatMessage"/> instances that were provided by the <see cref="AIContextProvider"/>,
+        /// and were used by the agent as part of the invocation.
+        /// </value>
+        public IEnumerable<ChatMessage>? AIContextProviderMessages { get; set; }
+
+        /// <summary>
+        /// Gets the collection of response messages generated during this invocation if the invocation succeeded.
+        /// </summary>
+        /// <value>
+        /// A collection of <see cref="ChatMessage"/> instances representing the response,
+        /// or <see langword="null"/> if the invocation failed or did not produce response messages.
+        /// </value>
+        public IEnumerable<ChatMessage>? ResponseMessages { get; set; }
+
+        /// <summary>
+        /// Gets the <see cref="Exception"/> that was thrown during the invocation, if the invocation failed.
+        /// </summary>
+        /// <value>
+        /// The exception that caused the invocation to fail, or <see langword="null"/> if the invocation succeeded.
+        /// </value>
+        public Exception? InvokeException { get; set; }
+    }
 }

dotnet/src/Microsoft.Agents.AI.Abstractions/ChatMessageStoreExtensions.cs

@@ -0,0 +1,50 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI;
+
+/// <summary>
+/// Contains extension methods for the <see cref="ChatMessageStore"/> class.
+/// </summary>
+public static class ChatMessageStoreExtensions
+{
+    /// <summary>
+    /// Adds message filtering to an existing store, so that messages passed to the store and messages produced by the store
+    /// can be filtered, updated or replaced.
+    /// </summary>
+    /// <param name="store">The store to add the message filter to.</param>
+    /// <param name="invokingMessagesFilter">An optional filter function to apply to messages produced by the store. If null, no filter is applied at this
+    /// stage.</param>
+    /// <param name="invokedMessagesFilter">An optional filter function to apply to the invoked context messages before they are passed to the store. If null, no
+    /// filter is applied at this stage.</param>
+    /// <returns>The <see cref="ChatMessageStore"/> with filtering applied.</returns>
+    public static ChatMessageStore WithMessageFilters(
+        this ChatMessageStore store,
+        Func<IEnumerable<ChatMessage>, IEnumerable<ChatMessage>>? invokingMessagesFilter = null,
+        Func<ChatMessageStore.InvokedContext, ChatMessageStore.InvokedContext>? invokedMessagesFilter = null)
+    {
+        return new ChatMessageStoreMessageFilter(
+            innerChatMessageStore: store,
+            invokingMessagesFilter: invokingMessagesFilter,
+            invokedMessagesFilter: invokedMessagesFilter);
+    }
+
+    /// <summary>
+    /// Decorates the provided chat message store so that it does not store messages produced by any <see cref="AIContextProvider"/>.
+    /// </summary>
+    /// <param name="store">The store to add the message filter to.</param>
+    /// <returns>A new <see cref="ChatMessageStore"/> instance that filters out <see cref="AIContextProvider"/> messages so they do not get stored.</returns>
+    public static ChatMessageStore WithAIContextProviderMessageRemoval(this ChatMessageStore store)
+    {
+        return new ChatMessageStoreMessageFilter(
+            innerChatMessageStore: store,
+            invokedMessagesFilter: (ctx) =>
+            {
+                ctx.AIContextProviderMessages = null;
+                return ctx;
+            });
+    }
+}

dotnet/src/Microsoft.Agents.AI.Abstractions/ChatMessageStoreMessageFilter.cs

@@ -0,0 +1,74 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.AI;
+using Microsoft.Shared.Diagnostics;
+
+namespace Microsoft.Agents.AI;
+
+/// <summary>
+/// A <see cref="ChatMessageStore"/> decorator that allows filtering the messages
+/// passed into and out of an inner <see cref="ChatMessageStore"/>.
+/// </summary>
+public sealed class ChatMessageStoreMessageFilter : ChatMessageStore
+{
+    private readonly ChatMessageStore _innerChatMessageStore;
+    private readonly Func<IEnumerable<ChatMessage>, IEnumerable<ChatMessage>>? _invokingMessagesFilter;
+    private readonly Func<InvokedContext, InvokedContext>? _invokedMessagesFilter;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ChatMessageStoreMessageFilter"/> class.
+    /// </summary>
+    /// <remarks>Use this constructor to customize how messages are filtered before and after invocation by
+    /// providing appropriate filter functions. If no filters are provided, the message store operates without
+    /// additional filtering.</remarks>
+    /// <param name="innerChatMessageStore">The underlying chat message store to be wrapped. Cannot be null.</param>
+    /// <param name="invokingMessagesFilter">An optional filter function to apply to messages before they are invoked. If null, no filter is applied at this
+    /// stage.</param>
+    /// <param name="invokedMessagesFilter">An optional filter function to apply to the invocation context after messages have been invoked. If null, no
+    /// filter is applied at this stage.</param>
+    /// <exception cref="ArgumentNullException">Thrown if innerChatMessageStore is null.</exception>
+    public ChatMessageStoreMessageFilter(
+        ChatMessageStore innerChatMessageStore,
+        Func<IEnumerable<ChatMessage>, IEnumerable<ChatMessage>>? invokingMessagesFilter = null,
+        Func<InvokedContext, InvokedContext>? invokedMessagesFilter = null)
+    {
+        this._innerChatMessageStore = Throw.IfNull(innerChatMessageStore);
+
+        if (invokingMessagesFilter == null && invokedMessagesFilter == null)
+        {
+            throw new ArgumentException("At least one filter function, invokingMessagesFilter or invokedMessagesFilter, must be provided.");
+        }
+
+        this._invokingMessagesFilter = invokingMessagesFilter;
+        this._invokedMessagesFilter = invokedMessagesFilter;
+    }
+
+    /// <inheritdoc />
+    public override async ValueTask<IEnumerable<ChatMessage>> InvokingAsync(InvokingContext context, CancellationToken cancellationToken = default)
+    {
+        var messages = await this._innerChatMessageStore.InvokingAsync(context, cancellationToken).ConfigureAwait(false);
+        return this._invokingMessagesFilter != null ? this._invokingMessagesFilter(messages) : messages;
+    }
+
+    /// <inheritdoc />
+    public override ValueTask InvokedAsync(InvokedContext context, CancellationToken cancellationToken = default)
+    {
+        if (this._invokedMessagesFilter != null)
+        {
+            context = this._invokedMessagesFilter(context);
+        }
+
+        return this._innerChatMessageStore.InvokedAsync(context, cancellationToken);
+    }
+
+    /// <inheritdoc />
+    public override JsonElement Serialize(JsonSerializerOptions? jsonSerializerOptions = null)
+    {
+        return this._innerChatMessageStore.Serialize(jsonSerializerOptions);
+    }
+}

dotnet/src/Microsoft.Agents.AI.Abstractions/DelegatingAIAgent.cs

@@ -81,7 +81,7 @@ public abstract class DelegatingAIAgent : AIAgent
         => this.InnerAgent.DeserializeThread(serializedThread, jsonSerializerOptions);
 
     /// <inheritdoc />
-    public override Task<AgentRunResponse> RunAsync(
+    protected override Task<AgentRunResponse> RunCoreAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,
@@ -89,7 +89,7 @@ public abstract class DelegatingAIAgent : AIAgent
         => this.InnerAgent.RunAsync(messages, thread, options, cancellationToken);
 
     /// <inheritdoc />
-    public override IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+    protected override IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,

dotnet/src/Microsoft.Agents.AI.Abstractions/InMemoryChatMessageStore.cs

@@ -134,21 +134,10 @@ public sealed class InMemoryChatMessageStore : ChatMessageStore, IList<ChatMessa
     }
 
     /// <inheritdoc />
-    public override async Task AddMessagesAsync(IEnumerable<ChatMessage> messages, CancellationToken cancellationToken = default)
+    public override async ValueTask<IEnumerable<ChatMessage>> InvokingAsync(InvokingContext context, CancellationToken cancellationToken = default)
     {
-        _ = Throw.IfNull(messages);
+        _ = Throw.IfNull(context);
 
-        this._messages.AddRange(messages);
-
-        if (this.ReducerTriggerEvent is ChatReducerTriggerEvent.AfterMessageAdded && this.ChatReducer is not null)
-        {
-            this._messages = (await this.ChatReducer.ReduceAsync(this._messages, cancellationToken).ConfigureAwait(false)).ToList();
-        }
-    }
-
-    /// <inheritdoc />
-    public override async Task<IEnumerable<ChatMessage>> GetMessagesAsync(CancellationToken cancellationToken = default)
-    {
         if (this.ReducerTriggerEvent is ChatReducerTriggerEvent.BeforeMessagesRetrieval && this.ChatReducer is not null)
         {
             this._messages = (await this.ChatReducer.ReduceAsync(this._messages, cancellationToken).ConfigureAwait(false)).ToList();
@@ -157,6 +146,26 @@ public sealed class InMemoryChatMessageStore : ChatMessageStore, IList<ChatMessa
         return this._messages;
     }
 
+    /// <inheritdoc />
+    public override async ValueTask InvokedAsync(InvokedContext context, CancellationToken cancellationToken = default)
+    {
+        _ = Throw.IfNull(context);
+
+        if (context.InvokeException is not null)
+        {
+            return;
+        }
+
+        // Add request, AI context provider, and response messages to the store
+        var allNewMessages = context.RequestMessages.Concat(context.AIContextProviderMessages ?? []).Concat(context.ResponseMessages ?? []);
+        this._messages.AddRange(allNewMessages);
+
+        if (this.ReducerTriggerEvent is ChatReducerTriggerEvent.AfterMessageAdded && this.ChatReducer is not null)
+        {
+            this._messages = (await this.ChatReducer.ReduceAsync(this._messages, cancellationToken).ConfigureAwait(false)).ToList();
+        }
+    }
+
     /// <inheritdoc />
     public override JsonElement Serialize(JsonSerializerOptions? jsonSerializerOptions = null)
     {
@@ -221,7 +230,7 @@ public sealed class InMemoryChatMessageStore : ChatMessageStore, IList<ChatMessa
     {
         /// <summary>
         /// Trigger the reducer when a new message is added.
-        /// <see cref="AddMessagesAsync(IEnumerable{ChatMessage}, CancellationToken)"/> will only complete when reducer processing is done.
+        /// <see cref="InvokedAsync(InvokedContext, CancellationToken)"/> will only complete when reducer processing is done.
         /// </summary>
         AfterMessageAdded,
 

dotnet/src/Microsoft.Agents.AI.CopilotStudio/CopilotStudioAgent.cs

@@ -58,7 +58,7 @@ public class CopilotStudioAgent : AIAgent
         => new CopilotStudioAgentThread(serializedThread, jsonSerializerOptions);
 
     /// <inheritdoc/>
-    public override async Task<AgentRunResponse> RunAsync(
+    protected override async Task<AgentRunResponse> RunCoreAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,
@@ -96,7 +96,7 @@ public class CopilotStudioAgent : AIAgent
     }
 
     /// <inheritdoc/>
-    public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+    protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,

dotnet/src/Microsoft.Agents.AI.CosmosNoSql/CosmosChatMessageStore.cs

@@ -287,7 +287,7 @@ public sealed class CosmosChatMessageStore : ChatMessageStore, IDisposable
     }
 
     /// <inheritdoc />
-    public override async Task<IEnumerable<ChatMessage>> GetMessagesAsync(CancellationToken cancellationToken = default)
+    public override async ValueTask<IEnumerable<ChatMessage>> InvokingAsync(InvokingContext context, CancellationToken cancellationToken = default)
     {
 #pragma warning disable CA1513 // Use ObjectDisposedException.ThrowIf - not available on all target frameworks
         if (this._disposed)
@@ -347,11 +347,14 @@ public sealed class CosmosChatMessageStore : ChatMessageStore, IDisposable
     }
 
     /// <inheritdoc />
-    public override async Task AddMessagesAsync(IEnumerable<ChatMessage> messages, CancellationToken cancellationToken = default)
+    public override async ValueTask InvokedAsync(InvokedContext context, CancellationToken cancellationToken = default)
     {
-        if (messages is null)
+        Throw.IfNull(context);
+
+        if (context.InvokeException is not null)
         {
-            throw new ArgumentNullException(nameof(messages));
+            // Do not store messages if there was an exception during invocation
+            return;
         }
 
 #pragma warning disable CA1513 // Use ObjectDisposedException.ThrowIf - not available on all target frameworks
@@ -361,7 +364,7 @@ public sealed class CosmosChatMessageStore : ChatMessageStore, IDisposable
         }
 #pragma warning restore CA1513
 
-        var messageList = messages as IReadOnlyCollection<ChatMessage> ?? messages.ToList();
+        var messageList = context.RequestMessages.Concat(context.AIContextProviderMessages ?? []).Concat(context.ResponseMessages ?? []).ToList();
         if (messageList.Count == 0)
         {
             return;
@@ -381,7 +384,7 @@ public sealed class CosmosChatMessageStore : ChatMessageStore, IDisposable
     /// <summary>
     /// Adds multiple messages using transactional batch operations for atomicity.
     /// </summary>
-    private async Task AddMessagesInBatchAsync(IReadOnlyCollection<ChatMessage> messages, CancellationToken cancellationToken)
+    private async Task AddMessagesInBatchAsync(List<ChatMessage> messages, CancellationToken cancellationToken)
     {
         var currentTimestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
 

dotnet/src/Microsoft.Agents.AI.DurableTask/CHANGELOG.md

@@ -6,6 +6,7 @@
 
 - Added TTL configuration for durable agent entities ([#2679](https://github.com/microsoft/agent-framework/pull/2679))
 - Switch to new "Run" method name ([#2843](https://github.com/microsoft/agent-framework/pull/2843))
+- Removed AgentThreadMetadata and used AgentSessionId directly instead ([#3067](https://github.com/microsoft/agent-framework/pull/3067));
 
 ## v1.0.0-preview.251204.1
 

dotnet/src/Microsoft.Agents.AI.DurableTask/DurableAIAgent.cs

@@ -63,7 +63,7 @@ public sealed class DurableAIAgent : AIAgent
     /// <exception cref="AgentNotRegisteredException">Thrown when the agent has not been registered.</exception>
     /// <exception cref="ArgumentException">Thrown when the provided thread is not valid for a durable agent.</exception>
     /// <exception cref="NotSupportedException">Thrown when cancellation is requested (cancellation is not supported for durable agents).</exception>
-    public override async Task<AgentRunResponse> RunAsync(
+    protected override async Task<AgentRunResponse> RunCoreAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,
@@ -128,7 +128,7 @@ public sealed class DurableAIAgent : AIAgent
     /// <param name="options">Optional run options.</param>
     /// <param name="cancellationToken">The cancellation token.</param>
     /// <returns>A streaming response enumerable.</returns>
-    public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+    protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,

dotnet/src/Microsoft.Agents.AI.DurableTask/DurableAIAgentProxy.cs

@@ -23,7 +23,7 @@ internal class DurableAIAgentProxy(string name, IDurableAgentClient agentClient)
         return new DurableAgentThread(AgentSessionId.WithRandomKey(this.Name!));
     }
 
-    public override async Task<AgentRunResponse> RunAsync(
+    protected override async Task<AgentRunResponse> RunCoreAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,
@@ -70,7 +70,7 @@ internal class DurableAIAgentProxy(string name, IDurableAgentClient agentClient)
         return await agentRunHandle.ReadAgentResponseAsync(cancellationToken);
     }
 
-    public override IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+    protected override IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,

dotnet/src/Microsoft.Agents.AI.DurableTask/DurableAgentThread.cs

@@ -55,12 +55,6 @@ public sealed class DurableAgentThread : AgentThread
     /// <inheritdoc/>
     public override object? GetService(Type serviceType, object? serviceKey = null)
     {
-        // This is a common convention for MAF agents.
-        if (serviceType == typeof(AgentThreadMetadata))
-        {
-            return new AgentThreadMetadata(conversationId: this.SessionId.ToString());
-        }
-
         if (serviceType == typeof(AgentSessionId))
         {
             return this.SessionId;

dotnet/src/Microsoft.Agents.AI.DurableTask/EntityAgentWrapper.cs

@@ -21,13 +21,13 @@ internal sealed class EntityAgentWrapper(
     // The ID of the agent is always the entity ID.
     protected override string? IdCore => this._entityContext.Id.ToString();
 
-    public override async Task<AgentRunResponse> RunAsync(
+    protected override async Task<AgentRunResponse> RunCoreAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,
         CancellationToken cancellationToken = default)
     {
-        AgentRunResponse response = await base.RunAsync(
+        AgentRunResponse response = await base.RunCoreAsync(
             messages,
             thread,
             this.GetAgentEntityRunOptions(options),
@@ -37,13 +37,13 @@ internal sealed class EntityAgentWrapper(
         return response;
     }
 
-    public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+    protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,
         [EnumeratorCancellation] CancellationToken cancellationToken = default)
     {
-        await foreach (AgentRunResponseUpdate update in base.RunStreamingAsync(
+        await foreach (AgentRunResponseUpdate update in base.RunCoreStreamingAsync(
             messages,
             thread,
             this.GetAgentEntityRunOptions(options),

dotnet/src/Microsoft.Agents.AI.Hosting.AzureFunctions/BuiltInFunctionExecutor.cs

@@ -32,7 +32,7 @@ internal sealed class BuiltInFunctionExecutor : IFunctionExecutor
         }
 
         HttpRequestData? httpRequestData = null;
-        TaskEntityDispatcher? dispatcher = null;
+        string? encodedEntityRequest = null;
         DurableTaskClient? durableTaskClient = null;
         ToolInvocationContext? mcpToolInvocationContext = null;
 
@@ -43,8 +43,8 @@ internal sealed class BuiltInFunctionExecutor : IFunctionExecutor
                 case HttpRequestData request:
                     httpRequestData = request;
                     break;
-                case TaskEntityDispatcher entityDispatcher:
-                    dispatcher = entityDispatcher;
+                case string entityRequest:
+                    encodedEntityRequest = entityRequest;
                     break;
                 case DurableTaskClient client:
                     durableTaskClient = client;
@@ -78,14 +78,14 @@ internal sealed class BuiltInFunctionExecutor : IFunctionExecutor
 
         if (context.FunctionDefinition.EntryPoint == BuiltInFunctions.RunAgentEntityFunctionEntryPoint)
         {
-            if (dispatcher is null)
+            if (encodedEntityRequest is null)
             {
                 throw new InvalidOperationException($"Task entity dispatcher binding is missing for the invocation {context.InvocationId}.");
             }
 
-            await BuiltInFunctions.InvokeAgentAsync(
-                dispatcher,
+            context.GetInvocationResult().Value = await BuiltInFunctions.InvokeAgentAsync(
                 durableTaskClient,
+                encodedEntityRequest,
                 context);
             return;
         }

dotnet/src/Microsoft.Agents.AI.Hosting.AzureFunctions/BuiltInFunctions.cs

@@ -7,6 +7,7 @@ using Microsoft.Azure.Functions.Worker;
 using Microsoft.Azure.Functions.Worker.Extensions.Mcp;
 using Microsoft.Azure.Functions.Worker.Http;
 using Microsoft.DurableTask.Client;
+using Microsoft.DurableTask.Worker.Grpc;
 using Microsoft.Extensions.AI;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -22,14 +23,14 @@ internal static class BuiltInFunctions
     internal static readonly string RunAgentMcpToolFunctionEntryPoint = $"{typeof(BuiltInFunctions).FullName!}.{nameof(RunMcpToolAsync)}";
 
     // Exposed as an entity trigger via AgentFunctionsProvider
-    public static async Task InvokeAgentAsync(
-        [EntityTrigger] TaskEntityDispatcher dispatcher,
+    public static Task<string> InvokeAgentAsync(
         [DurableClient] DurableTaskClient client,
+        string encodedEntityRequest,
         FunctionContext functionContext)
     {
         // This should never be null except if the function trigger is misconfigured.
-        ArgumentNullException.ThrowIfNull(dispatcher);
         ArgumentNullException.ThrowIfNull(client);
+        ArgumentNullException.ThrowIfNull(encodedEntityRequest);
         ArgumentNullException.ThrowIfNull(functionContext);
 
         // Create a combined service provider that includes both the existing services
@@ -38,7 +39,8 @@ internal static class BuiltInFunctions
 
         // This method is the entry point for the agent entity.
         // It will be invoked by the Azure Functions runtime when the entity is called.
-        await dispatcher.DispatchAsync(new AgentEntity(combinedServiceProvider, functionContext.CancellationToken));
+        AgentEntity entity = new(combinedServiceProvider, functionContext.CancellationToken);
+        return GrpcEntityRunner.LoadAndRunAsync(encodedEntityRequest, entity, combinedServiceProvider);
     }
 
     public static async Task<HttpResponseData> RunAgentHttpAsync(

dotnet/src/Microsoft.Agents.AI.Hosting.AzureFunctions/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Release History
 
+## <version>
+
+- Addressed incompatibility issue with `Microsoft.Azure.Functions.Worker.Extensions.DurableTask` >= 1.11.0 ([#2759](https://github.com/microsoft/agent-framework/pull/2759))
+
 ## v1.0.0-preview.251125.1
 
 - Added support for .NET 10 ([#2128](https://github.com/microsoft/agent-framework/pull/2128))

dotnet/src/Microsoft.Agents.AI.Hosting.AzureFunctions/DurableAgentFunctionMetadataTransformer.cs

@@ -73,7 +73,7 @@ internal sealed class DurableAgentFunctionMetadataTransformer : IFunctionMetadat
             Language = "dotnet-isolated",
             RawBindings =
             [
-                """{"name":"dispatcher","type":"entityTrigger","direction":"In"}""",
+                """{"name":"encodedEntityRequest","type":"entityTrigger","direction":"In"}""",
                 """{"name":"client","type":"durableClient","direction":"In"}"""
             ],
             EntryPoint = BuiltInFunctions.RunAgentEntityFunctionEntryPoint,

dotnet/src/Microsoft.Agents.AI.Purview/PurviewAgent.cs

@@ -42,13 +42,13 @@ internal class PurviewAgent : AIAgent, IDisposable
     }
 
     /// <inheritdoc/>
-    public override Task<AgentRunResponse> RunAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
+    protected override Task<AgentRunResponse> RunCoreAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
     {
         return this._purviewWrapper.ProcessAgentContentAsync(messages, thread, options, this._innerAgent, cancellationToken);
     }
 
     /// <inheritdoc/>
-    public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, [EnumeratorCancellation] CancellationToken cancellationToken = default)
+    protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, [EnumeratorCancellation] CancellationToken cancellationToken = default)
     {
         var response = await this._purviewWrapper.ProcessAgentContentAsync(messages, thread, options, this._innerAgent, cancellationToken).ConfigureAwait(false);
         foreach (var update in response.ToAgentRunResponseUpdates())

dotnet/src/Microsoft.Agents.AI.Workflows/WorkflowHostAgent.cs

@@ -66,7 +66,7 @@ internal sealed class WorkflowHostAgent : AIAgent
     public override AgentThread DeserializeThread(JsonElement serializedThread, JsonSerializerOptions? jsonSerializerOptions = null)
         => new WorkflowThread(this._workflow, serializedThread, this._executionEnvironment, this._checkpointManager, jsonSerializerOptions);
 
-    private async ValueTask<WorkflowThread> UpdateThreadAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, CancellationToken cancellationToken = default)
+    private ValueTask<WorkflowThread> UpdateThreadAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, CancellationToken cancellationToken = default)
     {
         thread ??= this.GetNewThread();
 
@@ -75,12 +75,14 @@ internal sealed class WorkflowHostAgent : AIAgent
             throw new ArgumentException($"Incompatible thread type: {thread.GetType()} (expecting {typeof(WorkflowThread)})", nameof(thread));
         }
 
-        await workflowThread.MessageStore.AddMessagesAsync(messages, cancellationToken).ConfigureAwait(false);
-        return workflowThread;
+        // For workflow threads, messages are added directly via the internal AddMessages method
+        // The MessageStore methods are used for agent invocation scenarios
+        workflowThread.MessageStore.AddMessages(messages);
+        return new ValueTask<WorkflowThread>(workflowThread);
     }
 
-    public override async
-    Task<AgentRunResponse> RunAsync(
+    protected override async
+    Task<AgentRunResponse> RunCoreAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,
@@ -101,8 +103,8 @@ internal sealed class WorkflowHostAgent : AIAgent
         return merger.ComputeMerged(workflowThread.LastResponseId!, this.Id, this.Name);
     }
 
-    public override async
-    IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+    protected override async
+    IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,

dotnet/src/Microsoft.Agents.AI.Workflows/WorkflowMessageStore.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft. All rights reserved.
 
 using System.Collections.Generic;
+using System.Linq;
 using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
@@ -45,15 +46,22 @@ internal sealed class WorkflowMessageStore : ChatMessageStore
 
     internal void AddMessages(params IEnumerable<ChatMessage> messages) => this._chatMessages.AddRange(messages);
 
-    public override Task AddMessagesAsync(IEnumerable<ChatMessage> messages, CancellationToken cancellationToken = default)
+    public override ValueTask<IEnumerable<ChatMessage>> InvokingAsync(InvokingContext context, CancellationToken cancellationToken = default)
+        => new(this._chatMessages.AsReadOnly());
+
+    public override ValueTask InvokedAsync(InvokedContext context, CancellationToken cancellationToken = default)
     {
-        this._chatMessages.AddRange(messages);
+        if (context.InvokeException is not null)
+        {
+            return default;
+        }
 
-        return Task.CompletedTask;
+        var allNewMessages = context.RequestMessages.Concat(context.AIContextProviderMessages ?? []).Concat(context.ResponseMessages ?? []);
+        this._chatMessages.AddRange(allNewMessages);
+
+        return default;
     }
 
-    public override Task<IEnumerable<ChatMessage>> GetMessagesAsync(CancellationToken cancellationToken = default) => Task.FromResult<IEnumerable<ChatMessage>>(this._chatMessages.AsReadOnly());
-
     public IEnumerable<ChatMessage> GetFromBookmark()
     {
         for (int i = this._bookmark; i < this._chatMessages.Count; i++)

dotnet/src/Microsoft.Agents.AI/AnonymousDelegatingAIAgent.cs

@@ -17,18 +17,18 @@ namespace Microsoft.Agents.AI;
 /// </remarks>
 internal sealed class AnonymousDelegatingAIAgent : DelegatingAIAgent
 {
-    /// <summary>The delegate to use as the implementation of <see cref="RunAsync"/>.</summary>
+    /// <summary>The delegate to use as the implementation of <see cref="RunCoreAsync"/>.</summary>
     private readonly Func<IEnumerable<ChatMessage>, AgentThread?, AgentRunOptions?, AIAgent, CancellationToken, Task<AgentRunResponse>>? _runFunc;
 
-    /// <summary>The delegate to use as the implementation of <see cref="RunStreamingAsync"/>.</summary>
+    /// <summary>The delegate to use as the implementation of <see cref="RunCoreStreamingAsync"/>.</summary>
     /// <remarks>
-    /// When non-<see langword="null"/>, this delegate is used as the implementation of <see cref="RunStreamingAsync"/> and
+    /// When non-<see langword="null"/>, this delegate is used as the implementation of <see cref="RunCoreStreamingAsync"/> and
     /// will be invoked with the same arguments as the method itself.
-    /// When <see langword="null"/>, <see cref="RunStreamingAsync"/> will delegate directly to the inner agent.
+    /// When <see langword="null"/>, <see cref="RunCoreStreamingAsync"/> will delegate directly to the inner agent.
     /// </remarks>
     private readonly Func<IEnumerable<ChatMessage>, AgentThread?, AgentRunOptions?, AIAgent, CancellationToken, IAsyncEnumerable<AgentRunResponseUpdate>>? _runStreamingFunc;
 
-    /// <summary>The delegate to use as the implementation of both <see cref="RunAsync"/> and <see cref="RunStreamingAsync"/>.</summary>
+    /// <summary>The delegate to use as the implementation of both <see cref="RunCoreAsync"/> and <see cref="RunCoreStreamingAsync"/>.</summary>
     private readonly Func<IEnumerable<ChatMessage>, AgentThread?, AgentRunOptions?, Func<IEnumerable<ChatMessage>, AgentThread?, AgentRunOptions?, CancellationToken, Task>, CancellationToken, Task>? _sharedFunc;
 
     /// <summary>
@@ -36,7 +36,7 @@ internal sealed class AnonymousDelegatingAIAgent : DelegatingAIAgent
     /// </summary>
     /// <param name="innerAgent">The inner agent.</param>
     /// <param name="sharedFunc">
-    /// A delegate that provides the implementation for both <see cref="RunAsync"/> and <see cref="RunStreamingAsync"/>.
+    /// A delegate that provides the implementation for both <see cref="RunCoreAsync"/> and <see cref="RunCoreStreamingAsync"/>.
     /// In addition to the arguments for the operation, it's provided with a delegate to the inner agent that should be
     /// used to perform the operation on the inner agent. It will handle both the non-streaming and streaming cases.
     /// </param>
@@ -61,13 +61,13 @@ internal sealed class AnonymousDelegatingAIAgent : DelegatingAIAgent
     /// </summary>
     /// <param name="innerAgent">The inner agent.</param>
     /// <param name="runFunc">
-    /// A delegate that provides the implementation for <see cref="RunAsync"/>. When <see langword="null"/>,
-    /// <paramref name="runStreamingFunc"/> must be non-null, and the implementation of <see cref="RunAsync"/>
+    /// A delegate that provides the implementation for <see cref="RunCoreAsync"/>. When <see langword="null"/>,
+    /// <paramref name="runStreamingFunc"/> must be non-null, and the implementation of <see cref="RunCoreAsync"/>
     /// will use <paramref name="runStreamingFunc"/> for the implementation.
     /// </param>
     /// <param name="runStreamingFunc">
-    /// A delegate that provides the implementation for <see cref="RunStreamingAsync"/>. When <see langword="null"/>,
-    /// <paramref name="runFunc"/> must be non-null, and the implementation of <see cref="RunStreamingAsync"/>
+    /// A delegate that provides the implementation for <see cref="RunCoreStreamingAsync"/>. When <see langword="null"/>,
+    /// <paramref name="runFunc"/> must be non-null, and the implementation of <see cref="RunCoreStreamingAsync"/>
     /// will use <paramref name="runFunc"/> for the implementation.
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="innerAgent"/> is <see langword="null"/>.</exception>
@@ -85,7 +85,7 @@ internal sealed class AnonymousDelegatingAIAgent : DelegatingAIAgent
     }
 
     /// <inheritdoc/>
-    public override Task<AgentRunResponse> RunAsync(
+    protected override Task<AgentRunResponse> RunCoreAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,
@@ -132,7 +132,7 @@ internal sealed class AnonymousDelegatingAIAgent : DelegatingAIAgent
     }
 
     /// <inheritdoc/>
-    public override IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+    protected override IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,

dotnet/src/Microsoft.Agents.AI/ChatClient/ChatClientAgent.cs

@@ -149,7 +149,7 @@ public sealed partial class ChatClientAgent : AIAgent
     internal ChatOptions? ChatOptions => this._agentOptions?.ChatOptions;
 
     /// <inheritdoc/>
-    public override Task<AgentRunResponse> RunAsync(
+    protected override Task<AgentRunResponse> RunCoreAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,
@@ -193,7 +193,7 @@ public sealed partial class ChatClientAgent : AIAgent
     }
 
     /// <inheritdoc/>
-    public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+    protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,
@@ -201,7 +201,7 @@ public sealed partial class ChatClientAgent : AIAgent
     {
         var inputMessages = Throw.IfNull(messages) as IReadOnlyCollection<ChatMessage> ?? messages.ToList();
 
-        (ChatClientAgentThread safeThread, ChatOptions? chatOptions, List<ChatMessage> inputMessagesForChatClient, IList<ChatMessage>? aiContextProviderMessages) =
+        (ChatClientAgentThread safeThread, ChatOptions? chatOptions, List<ChatMessage> inputMessagesForChatClient, IList<ChatMessage>? aiContextProviderMessages, IList<ChatMessage>? chatMessageStoreMessages) =
             await this.PrepareThreadAndMessagesAsync(thread, inputMessages, options, cancellationToken).ConfigureAwait(false);
 
         ValidateStreamResumptionAllowed(chatOptions?.ContinuationToken, safeThread);
@@ -225,6 +225,7 @@ public sealed partial class ChatClientAgent : AIAgent
         }
         catch (Exception ex)
         {
+            await NotifyMessageStoreOfFailureAsync(safeThread, ex, inputMessages, chatMessageStoreMessages, aiContextProviderMessages, cancellationToken).ConfigureAwait(false);
             await NotifyAIContextProviderOfFailureAsync(safeThread, ex, inputMessages, aiContextProviderMessages, cancellationToken).ConfigureAwait(false);
             throw;
         }
@@ -239,6 +240,7 @@ public sealed partial class ChatClientAgent : AIAgent
         }
         catch (Exception ex)
         {
+            await NotifyMessageStoreOfFailureAsync(safeThread, ex, inputMessages, chatMessageStoreMessages, aiContextProviderMessages, cancellationToken).ConfigureAwait(false);
             await NotifyAIContextProviderOfFailureAsync(safeThread, ex, inputMessages, aiContextProviderMessages, cancellationToken).ConfigureAwait(false);
             throw;
         }
@@ -260,6 +262,7 @@ public sealed partial class ChatClientAgent : AIAgent
             }
             catch (Exception ex)
             {
+                await NotifyMessageStoreOfFailureAsync(safeThread, ex, inputMessages, chatMessageStoreMessages, aiContextProviderMessages, cancellationToken).ConfigureAwait(false);
                 await NotifyAIContextProviderOfFailureAsync(safeThread, ex, inputMessages, aiContextProviderMessages, cancellationToken).ConfigureAwait(false);
                 throw;
             }
@@ -272,7 +275,7 @@ public sealed partial class ChatClientAgent : AIAgent
         this.UpdateThreadWithTypeAndConversationId(safeThread, chatResponse.ConversationId);
 
         // To avoid inconsistent state we only notify the thread of the input messages if no error occurs after the initial request.
-        await NotifyMessageStoreOfNewMessagesAsync(safeThread, inputMessages.Concat(aiContextProviderMessages ?? []).Concat(chatResponse.Messages), cancellationToken).ConfigureAwait(false);
+        await NotifyMessageStoreOfNewMessagesAsync(safeThread, inputMessages, chatMessageStoreMessages, aiContextProviderMessages, chatResponse.Messages, cancellationToken).ConfigureAwait(false);
 
         // Notify the AIContextProvider of all new messages.
         await NotifyAIContextProviderOfSuccessAsync(safeThread, inputMessages, aiContextProviderMessages, chatResponse.Messages, cancellationToken).ConfigureAwait(false);
@@ -379,7 +382,7 @@ public sealed partial class ChatClientAgent : AIAgent
     {
         var inputMessages = Throw.IfNull(messages) as IReadOnlyCollection<ChatMessage> ?? messages.ToList();
 
-        (ChatClientAgentThread safeThread, ChatOptions? chatOptions, List<ChatMessage> inputMessagesForChatClient, IList<ChatMessage>? aiContextProviderMessages) =
+        (ChatClientAgentThread safeThread, ChatOptions? chatOptions, List<ChatMessage> inputMessagesForChatClient, IList<ChatMessage>? aiContextProviderMessages, IList<ChatMessage>? chatMessageStoreMessages) =
             await this.PrepareThreadAndMessagesAsync(thread, inputMessages, options, cancellationToken).ConfigureAwait(false);
 
         var chatClient = this.ChatClient;
@@ -398,6 +401,7 @@ public sealed partial class ChatClientAgent : AIAgent
         }
         catch (Exception ex)
         {
+            await NotifyMessageStoreOfFailureAsync(safeThread, ex, inputMessages, chatMessageStoreMessages, aiContextProviderMessages, cancellationToken).ConfigureAwait(false);
             await NotifyAIContextProviderOfFailureAsync(safeThread, ex, inputMessages, aiContextProviderMessages, cancellationToken).ConfigureAwait(false);
             throw;
         }
@@ -415,7 +419,7 @@ public sealed partial class ChatClientAgent : AIAgent
         }
 
         // Only notify the thread of new messages if the chatResponse was successful to avoid inconsistent message state in the thread.
-        await NotifyMessageStoreOfNewMessagesAsync(safeThread, inputMessages.Concat(aiContextProviderMessages ?? []).Concat(chatResponse.Messages), cancellationToken).ConfigureAwait(false);
+        await NotifyMessageStoreOfNewMessagesAsync(safeThread, inputMessages, chatMessageStoreMessages, aiContextProviderMessages, chatResponse.Messages, cancellationToken).ConfigureAwait(false);
 
         // Notify the AIContextProvider of all new messages.
         await NotifyAIContextProviderOfSuccessAsync(safeThread, inputMessages, aiContextProviderMessages, chatResponse.Messages, cancellationToken).ConfigureAwait(false);
@@ -603,7 +607,14 @@ public sealed partial class ChatClientAgent : AIAgent
     /// <param name="runOptions">Optional parameters for agent invocation.</param>
     /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
     /// <returns>A tuple containing the thread, chat options, and thread messages.</returns>
-    private async Task<(ChatClientAgentThread AgentThread, ChatOptions? ChatOptions, List<ChatMessage> InputMessagesForChatClient, IList<ChatMessage>? AIContextProviderMessages)> PrepareThreadAndMessagesAsync(
+    private async Task
+        <(
+            ChatClientAgentThread AgentThread,
+            ChatOptions? ChatOptions,
+            List<ChatMessage> InputMessagesForChatClient,
+            IList<ChatMessage>? AIContextProviderMessages,
+            IList<ChatMessage>? ChatMessageStoreMessages
+        )> PrepareThreadAndMessagesAsync(
         AgentThread? thread,
         IEnumerable<ChatMessage> inputMessages,
         AgentRunOptions? runOptions,
@@ -637,6 +648,7 @@ public sealed partial class ChatClientAgent : AIAgent
 
         List<ChatMessage> inputMessagesForChatClient = [];
         IList<ChatMessage>? aiContextProviderMessages = null;
+        IList<ChatMessage>? chatMessageStoreMessages = null;
 
         // Populate the thread messages only if we are not continuing an existing response as it's not allowed
         if (chatOptions?.ContinuationToken is null)
@@ -644,9 +656,15 @@ public sealed partial class ChatClientAgent : AIAgent
             // Add any existing messages from the thread to the messages to be sent to the chat client.
             if (typedThread.MessageStore is not null)
             {
-                inputMessagesForChatClient.AddRange(await typedThread.MessageStore.GetMessagesAsync(cancellationToken).ConfigureAwait(false));
+                var invokingContext = new ChatMessageStore.InvokingContext(inputMessages);
+                var storeMessages = await typedThread.MessageStore.InvokingAsync(invokingContext, cancellationToken).ConfigureAwait(false);
+                inputMessagesForChatClient.AddRange(storeMessages);
+                chatMessageStoreMessages = storeMessages as IList<ChatMessage> ?? storeMessages.ToList();
             }
 
+            // Add the input messages before getting context from AIContextProvider.
+            inputMessagesForChatClient.AddRange(inputMessages);
+
             // If we have an AIContextProvider, we should get context from it, and update our
             // messages and options with the additional context.
             if (typedThread.AIContextProvider is not null)
@@ -675,9 +693,6 @@ public sealed partial class ChatClientAgent : AIAgent
                     chatOptions.Instructions = string.IsNullOrWhiteSpace(chatOptions.Instructions) ? aiContext.Instructions : $"{chatOptions.Instructions}\n{aiContext.Instructions}";
                 }
             }
-
-            // Add the input messages to the end of thread messages.
-            inputMessagesForChatClient.AddRange(inputMessages);
         }
 
         // If a user provided two different thread ids, via the thread object and options, we should throw
@@ -698,7 +713,7 @@ public sealed partial class ChatClientAgent : AIAgent
             chatOptions.ConversationId = typedThread.ConversationId;
         }
 
-        return (typedThread, chatOptions, inputMessagesForChatClient, aiContextProviderMessages);
+        return (typedThread, chatOptions, inputMessagesForChatClient, aiContextProviderMessages, chatMessageStoreMessages);
     }
 
     private void UpdateThreadWithTypeAndConversationId(ChatClientAgentThread thread, string? responseConversationId)
@@ -725,7 +740,13 @@ public sealed partial class ChatClientAgent : AIAgent
         }
     }
 
-    private static Task NotifyMessageStoreOfNewMessagesAsync(ChatClientAgentThread thread, IEnumerable<ChatMessage> newMessages, CancellationToken cancellationToken)
+    private static Task NotifyMessageStoreOfFailureAsync(
+        ChatClientAgentThread thread,
+        Exception ex,
+        IEnumerable<ChatMessage> requestMessages,
+        IEnumerable<ChatMessage>? chatMessageStoreMessages,
+        IEnumerable<ChatMessage>? aiContextProviderMessages,
+        CancellationToken cancellationToken)
     {
         var messageStore = thread.MessageStore;
 
@@ -733,7 +754,38 @@ public sealed partial class ChatClientAgent : AIAgent
         // If we don't have one, it means that the chat history is service managed and the underlying service is responsible for storing messages.
         if (messageStore is not null)
         {
-            return messageStore.AddMessagesAsync(newMessages, cancellationToken);
+            var invokedContext = new ChatMessageStore.InvokedContext(requestMessages, chatMessageStoreMessages!)
+            {
+                AIContextProviderMessages = aiContextProviderMessages,
+                InvokeException = ex
+            };
+
+            return messageStore.InvokedAsync(invokedContext, cancellationToken).AsTask();
+        }
+
+        return Task.CompletedTask;
+    }
+
+    private static Task NotifyMessageStoreOfNewMessagesAsync(
+        ChatClientAgentThread thread,
+        IEnumerable<ChatMessage> requestMessages,
+        IEnumerable<ChatMessage>? chatMessageStoreMessages,
+        IEnumerable<ChatMessage>? aiContextProviderMessages,
+        IEnumerable<ChatMessage> responseMessages,
+        CancellationToken cancellationToken)
+    {
+        var messageStore = thread.MessageStore;
+
+        // Only notify the message store if we have one.
+        // If we don't have one, it means that the chat history is service managed and the underlying service is responsible for storing messages.
+        if (messageStore is not null)
+        {
+            var invokedContext = new ChatMessageStore.InvokedContext(requestMessages, chatMessageStoreMessages!)
+            {
+                AIContextProviderMessages = aiContextProviderMessages,
+                ResponseMessages = responseMessages
+            };
+            return messageStore.InvokedAsync(invokedContext, cancellationToken).AsTask();
         }
 
         return Task.CompletedTask;

dotnet/src/Microsoft.Agents.AI/ChatClient/ChatClientAgentThread.cs

@@ -11,7 +11,7 @@ namespace Microsoft.Agents.AI;
 /// Provides a thread implementation for use with <see cref="ChatClientAgent"/>.
 /// </summary>
 [DebuggerDisplay("{DebuggerDisplay,nq}")]
-public class ChatClientAgentThread : AgentThread
+public sealed class ChatClientAgentThread : AgentThread
 {
     private ChatMessageStore? _messageStore;
 
@@ -171,9 +171,7 @@ public class ChatClientAgentThread : AgentThread
 
     /// <inheritdoc/>
     public override object? GetService(Type serviceType, object? serviceKey = null) =>
-        serviceType == typeof(AgentThreadMetadata)
-            ? new AgentThreadMetadata(this.ConversationId)
-            : base.GetService(serviceType, serviceKey)
+        base.GetService(serviceType, serviceKey)
             ?? this.AIContextProvider?.GetService(serviceType, serviceKey)
             ?? this.MessageStore?.GetService(serviceType, serviceKey);
 

dotnet/src/Microsoft.Agents.AI/FunctionInvocationDelegatingAgent.cs

@@ -21,10 +21,10 @@ internal sealed class FunctionInvocationDelegatingAgent : DelegatingAIAgent
         this._delegateFunc = delegateFunc;
     }
 
-    public override Task<AgentRunResponse> RunAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
+    protected override Task<AgentRunResponse> RunCoreAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
         => this.InnerAgent.RunAsync(messages, thread, this.AgentRunOptionsWithFunctionMiddleware(options), cancellationToken);
 
-    public override IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
+    protected override IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
         => this.InnerAgent.RunStreamingAsync(messages, thread, this.AgentRunOptionsWithFunctionMiddleware(options), cancellationToken);
 
     // Decorate options to add the middleware function

dotnet/src/Microsoft.Agents.AI/LoggingAgent.cs

@@ -55,7 +55,7 @@ public sealed partial class LoggingAgent : DelegatingAIAgent
     }
 
     /// <inheritdoc/>
-    public override async Task<AgentRunResponse> RunAsync(
+    protected override async Task<AgentRunResponse> RunCoreAsync(
         IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
     {
         if (this._logger.IsEnabled(LogLevel.Debug))
@@ -72,7 +72,7 @@ public sealed partial class LoggingAgent : DelegatingAIAgent
 
         try
         {
-            AgentRunResponse response = await base.RunAsync(messages, thread, options, cancellationToken).ConfigureAwait(false);
+            AgentRunResponse response = await base.RunCoreAsync(messages, thread, options, cancellationToken).ConfigureAwait(false);
 
             if (this._logger.IsEnabled(LogLevel.Debug))
             {
@@ -101,7 +101,7 @@ public sealed partial class LoggingAgent : DelegatingAIAgent
     }
 
     /// <inheritdoc/>
-    public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+    protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
         IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, [EnumeratorCancellation] CancellationToken cancellationToken = default)
     {
         if (this._logger.IsEnabled(LogLevel.Debug))
@@ -119,7 +119,7 @@ public sealed partial class LoggingAgent : DelegatingAIAgent
         IAsyncEnumerator<AgentRunResponseUpdate> e;
         try
         {
-            e = base.RunStreamingAsync(messages, thread, options, cancellationToken).GetAsyncEnumerator(cancellationToken);
+            e = base.RunCoreStreamingAsync(messages, thread, options, cancellationToken).GetAsyncEnumerator(cancellationToken);
         }
         catch (OperationCanceledException)
         {

dotnet/src/Microsoft.Agents.AI/OpenTelemetryAgent.cs

@@ -78,7 +78,7 @@ public sealed class OpenTelemetryAgent : DelegatingAIAgent, IDisposable
     }
 
     /// <inheritdoc/>
-    public override async Task<AgentRunResponse> RunAsync(
+    protected override async Task<AgentRunResponse> RunCoreAsync(
         IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
     {
         ChatOptions co = new ForwardedOptions(options, thread, Activity.Current);
@@ -89,7 +89,7 @@ public sealed class OpenTelemetryAgent : DelegatingAIAgent, IDisposable
     }
 
     /// <inheritdoc/>
-    public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+    protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
         IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, [EnumeratorCancellation] CancellationToken cancellationToken = default)
     {
         ChatOptions co = new ForwardedOptions(options, thread, Activity.Current);

dotnet/tests/AnthropicChatCompletion.IntegrationTests/AnthropicChatCompletionFixture.cs

@@ -39,7 +39,12 @@ public class AnthropicChatCompletionFixture : IChatClientAgentFixture
     {
         var typedThread = (ChatClientAgentThread)thread;
 
-        return typedThread.MessageStore is null ? [] : (await typedThread.MessageStore.GetMessagesAsync()).ToList();
+        if (typedThread.MessageStore is null)
+        {
+            return [];
+        }
+
+        return (await typedThread.MessageStore.InvokingAsync(new([]))).ToList();
     }
 
     public Task<ChatClientAgent> CreateChatClientAgentAsync(

dotnet/tests/AzureAI.IntegrationTests/AIProjectClientFixture.cs

@@ -48,7 +48,12 @@ public class AIProjectClientFixture : IChatClientAgentFixture
             return await this.GetChatHistoryFromResponsesChainAsync(chatClientThread.ConversationId);
         }
 
-        return chatClientThread.MessageStore is null ? [] : (await chatClientThread.MessageStore.GetMessagesAsync()).ToList();
+        if (chatClientThread.MessageStore is null)
+        {
+            return [];
+        }
+
+        return (await chatClientThread.MessageStore.InvokingAsync(new([]))).ToList();
     }
 
     private async Task<List<ChatMessage>> GetChatHistoryFromResponsesChainAsync(string conversationId)

dotnet/tests/Microsoft.Agents.AI.Abstractions.UnitTests/AIAgentTests.cs

@@ -8,6 +8,7 @@ using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.AI;
 using Moq;
+using Moq.Protected;
 
 namespace Microsoft.Agents.AI.Abstractions.UnitTests;
 
@@ -33,18 +34,20 @@ public class AIAgentTests
 
         this._agentMock = new Mock<AIAgent> { CallBase = true };
         this._agentMock
-            .Setup(x => x.RunAsync(
-                It.IsAny<IReadOnlyCollection<ChatMessage>>(),
-                this._agentThreadMock.Object,
-                It.IsAny<AgentRunOptions?>(),
-                It.IsAny<CancellationToken>()))
+            .Protected()
+            .Setup<Task<AgentRunResponse>>("RunCoreAsync",
+                ItExpr.IsAny<IEnumerable<ChatMessage>>(),
+                ItExpr.Is<AgentThread?>(t => t == this._agentThreadMock.Object),
+                ItExpr.IsAny<AgentRunOptions?>(),
+                ItExpr.IsAny<CancellationToken>())
             .ReturnsAsync(this._invokeResponse);
         this._agentMock
-            .Setup(x => x.RunStreamingAsync(
-                It.IsAny<IReadOnlyCollection<ChatMessage>>(),
-                this._agentThreadMock.Object,
-                It.IsAny<AgentRunOptions?>(),
-                It.IsAny<CancellationToken>()))
+            .Protected()
+            .Setup<IAsyncEnumerable<AgentRunResponseUpdate>>("RunCoreStreamingAsync",
+                ItExpr.IsAny<IEnumerable<ChatMessage>>(),
+                ItExpr.Is<AgentThread?>(t => t == this._agentThreadMock.Object),
+                ItExpr.IsAny<AgentRunOptions?>(),
+                ItExpr.IsAny<CancellationToken>())
             .Returns(ToAsyncEnumerableAsync(this._invokeStreamingResponses));
     }
 
@@ -64,13 +67,14 @@ public class AIAgentTests
         Assert.Equal(this._invokeResponse, response);
 
         // Verify that the mocked method was called with the expected parameters
-        this._agentMock.Verify(
-            x => x.RunAsync(
-                It.Is<IReadOnlyCollection<ChatMessage>>(messages => messages.Count == 0),
-                this._agentThreadMock.Object,
-                options,
-                cancellationToken),
-            Times.Once);
+        this._agentMock
+            .Protected()
+            .Verify<Task<AgentRunResponse>>("RunCoreAsync",
+                Times.Once(),
+                ItExpr.Is<IEnumerable<ChatMessage>>(messages => !messages.Any()),
+                ItExpr.Is<AgentThread?>(t => t == this._agentThreadMock.Object),
+                ItExpr.Is<AgentRunOptions?>(o => o == options),
+                ItExpr.Is<CancellationToken>(ct => ct == cancellationToken));
     }
 
     /// <summary>
@@ -90,13 +94,14 @@ public class AIAgentTests
         Assert.Equal(this._invokeResponse, response);
 
         // Verify that the mocked method was called with the expected parameters
-        this._agentMock.Verify(
-            x => x.RunAsync(
-                It.Is<IReadOnlyCollection<ChatMessage>>(messages => messages.Count == 1 && messages.First().Text == Message),
-                this._agentThreadMock.Object,
-                options,
-                cancellationToken),
-            Times.Once);
+        this._agentMock
+            .Protected()
+            .Verify<Task<AgentRunResponse>>("RunCoreAsync",
+                Times.Once(),
+                ItExpr.Is<IEnumerable<ChatMessage>>(messages => messages.Count() == 1 && messages.First().Text == Message),
+                ItExpr.Is<AgentThread?>(t => t == this._agentThreadMock.Object),
+                ItExpr.Is<AgentRunOptions?>(o => o == options),
+                ItExpr.Is<CancellationToken>(ct => ct == cancellationToken));
     }
 
     /// <summary>
@@ -116,13 +121,14 @@ public class AIAgentTests
         Assert.Equal(this._invokeResponse, response);
 
         // Verify that the mocked method was called with the expected parameters
-        this._agentMock.Verify(
-            x => x.RunAsync(
-                It.Is<IReadOnlyCollection<ChatMessage>>(messages => messages.Count == 1 && messages.First() == message),
-                this._agentThreadMock.Object,
-                options,
-                cancellationToken),
-            Times.Once);
+        this._agentMock
+            .Protected()
+            .Verify<Task<AgentRunResponse>>("RunCoreAsync",
+                Times.Once(),
+                ItExpr.Is<IEnumerable<ChatMessage>>(messages => messages.Count() == 1 && messages.First() == message),
+                ItExpr.Is<AgentThread?>(t => t == this._agentThreadMock.Object),
+                ItExpr.Is<AgentRunOptions?>(o => o == options),
+                ItExpr.Is<CancellationToken>(ct => ct == cancellationToken));
     }
 
     /// <summary>
@@ -144,13 +150,14 @@ public class AIAgentTests
         }
 
         // Verify that the mocked method was called with the expected parameters
-        this._agentMock.Verify(
-            x => x.RunStreamingAsync(
-                It.Is<IReadOnlyCollection<ChatMessage>>(messages => messages.Count == 0),
-                this._agentThreadMock.Object,
-                options,
-                cancellationToken),
-            Times.Once);
+        this._agentMock
+            .Protected()
+            .Verify<IAsyncEnumerable<AgentRunResponseUpdate>>("RunCoreStreamingAsync",
+                Times.Once(),
+                ItExpr.Is<IEnumerable<ChatMessage>>(messages => !messages.Any()),
+                ItExpr.Is<AgentThread?>(t => t == this._agentThreadMock.Object),
+                ItExpr.Is<AgentRunOptions?>(o => o == options),
+                ItExpr.Is<CancellationToken>(ct => ct == cancellationToken));
     }
 
     /// <summary>
@@ -173,13 +180,14 @@ public class AIAgentTests
         }
 
         // Verify that the mocked method was called with the expected parameters
-        this._agentMock.Verify(
-            x => x.RunStreamingAsync(
-                It.Is<IReadOnlyCollection<ChatMessage>>(messages => messages.Count == 1 && messages.First().Text == Message),
-                this._agentThreadMock.Object,
-                options,
-                cancellationToken),
-            Times.Once);
+        this._agentMock
+            .Protected()
+            .Verify<IAsyncEnumerable<AgentRunResponseUpdate>>("RunCoreStreamingAsync",
+                Times.Once(),
+                ItExpr.Is<IEnumerable<ChatMessage>>(messages => messages.Count() == 1 && messages.First().Text == Message),
+                ItExpr.Is<AgentThread?>(t => t == this._agentThreadMock.Object),
+                ItExpr.Is<AgentRunOptions?>(o => o == options),
+                ItExpr.Is<CancellationToken>(ct => ct == cancellationToken));
     }
 
     /// <summary>
@@ -202,13 +210,14 @@ public class AIAgentTests
         }
 
         // Verify that the mocked method was called with the expected parameters
-        this._agentMock.Verify(
-            x => x.RunStreamingAsync(
-                It.Is<IReadOnlyCollection<ChatMessage>>(messages => messages.Count == 1 && messages.First() == message),
-                this._agentThreadMock.Object,
-                options,
-                cancellationToken),
-            Times.Once);
+        this._agentMock
+            .Protected()
+            .Verify<IAsyncEnumerable<AgentRunResponseUpdate>>("RunCoreStreamingAsync",
+                Times.Once(),
+                ItExpr.Is<IEnumerable<ChatMessage>>(messages => messages.Count() == 1 && messages.First() == message),
+                ItExpr.Is<AgentThread?>(t => t == this._agentThreadMock.Object),
+                ItExpr.Is<AgentRunOptions?>(o => o == options),
+                ItExpr.Is<CancellationToken>(ct => ct == cancellationToken));
     }
 
     [Fact]
@@ -375,14 +384,14 @@ public class AIAgentTests
         public override AgentThread DeserializeThread(JsonElement serializedThread, JsonSerializerOptions? jsonSerializerOptions = null)
             => throw new NotImplementedException();
 
-        public override Task<AgentRunResponse> RunAsync(
+        protected override Task<AgentRunResponse> RunCoreAsync(
             IEnumerable<ChatMessage> messages,
             AgentThread? thread = null,
             AgentRunOptions? options = null,
             CancellationToken cancellationToken = default) =>
             throw new NotImplementedException();
 
-        public override IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+        protected override IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
             IEnumerable<ChatMessage> messages,
             AgentThread? thread = null,
             AgentRunOptions? options = null,

dotnet/tests/Microsoft.Agents.AI.Abstractions.UnitTests/ChatMessageStoreMessageFilterTests.cs

@@ -0,0 +1,205 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.AI;
+using Moq;
+
+namespace Microsoft.Agents.AI.Abstractions.UnitTests;
+
+/// <summary>
+/// Contains tests for the <see cref="ChatMessageStoreMessageFilter"/> class.
+/// </summary>
+public sealed class ChatMessageStoreMessageFilterTests
+{
+    [Fact]
+    public void Constructor_WithNullInnerStore_ThrowsArgumentNullException()
+    {
+        // Arrange, Act & Assert
+        Assert.Throws<ArgumentNullException>(() => new ChatMessageStoreMessageFilter(null!));
+    }
+
+    [Fact]
+    public void Constructor_WithOnlyInnerStore_Throws()
+    {
+        // Arrange
+        var innerStoreMock = new Mock<ChatMessageStore>();
+
+        // Act & Assert
+        Assert.Throws<ArgumentException>(() => new ChatMessageStoreMessageFilter(innerStoreMock.Object));
+    }
+
+    [Fact]
+    public void Constructor_WithAllParameters_CreatesInstance()
+    {
+        // Arrange
+        var innerStoreMock = new Mock<ChatMessageStore>();
+
+        IEnumerable<ChatMessage> InvokingFilter(IEnumerable<ChatMessage> msgs) => msgs;
+        ChatMessageStore.InvokedContext InvokedFilter(ChatMessageStore.InvokedContext ctx) => ctx;
+
+        // Act
+        var filter = new ChatMessageStoreMessageFilter(innerStoreMock.Object, InvokingFilter, InvokedFilter);
+
+        // Assert
+        Assert.NotNull(filter);
+    }
+
+    [Fact]
+    public async Task InvokingAsync_WithNoOpFilters_ReturnsInnerStoreMessagesAsync()
+    {
+        // Arrange
+        var innerStoreMock = new Mock<ChatMessageStore>();
+        var expectedMessages = new List<ChatMessage>
+        {
+            new(ChatRole.User, "Hello"),
+            new(ChatRole.Assistant, "Hi there!")
+        };
+        var context = new ChatMessageStore.InvokingContext([new ChatMessage(ChatRole.User, "Test")]);
+
+        innerStoreMock
+            .Setup(s => s.InvokingAsync(context, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(expectedMessages);
+
+        var filter = new ChatMessageStoreMessageFilter(innerStoreMock.Object, x => x, x => x);
+
+        // Act
+        var result = (await filter.InvokingAsync(context, CancellationToken.None)).ToList();
+
+        // Assert
+        Assert.Equal(2, result.Count);
+        Assert.Equal("Hello", result[0].Text);
+        Assert.Equal("Hi there!", result[1].Text);
+        innerStoreMock.Verify(s => s.InvokingAsync(context, It.IsAny<CancellationToken>()), Times.Once);
+    }
+
+    [Fact]
+    public async Task InvokingAsync_WithInvokingFilter_AppliesFilterAsync()
+    {
+        // Arrange
+        var innerStoreMock = new Mock<ChatMessageStore>();
+        var innerMessages = new List<ChatMessage>
+        {
+            new(ChatRole.User, "Hello"),
+            new(ChatRole.Assistant, "Hi there!"),
+            new(ChatRole.User, "How are you?")
+        };
+        var context = new ChatMessageStore.InvokingContext([new ChatMessage(ChatRole.User, "Test")]);
+
+        innerStoreMock
+            .Setup(s => s.InvokingAsync(context, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(innerMessages);
+
+        // Filter to only user messages
+        IEnumerable<ChatMessage> InvokingFilter(IEnumerable<ChatMessage> msgs) => msgs.Where(m => m.Role == ChatRole.User);
+
+        var filter = new ChatMessageStoreMessageFilter(innerStoreMock.Object, InvokingFilter);
+
+        // Act
+        var result = (await filter.InvokingAsync(context, CancellationToken.None)).ToList();
+
+        // Assert
+        Assert.Equal(2, result.Count);
+        Assert.All(result, msg => Assert.Equal(ChatRole.User, msg.Role));
+        innerStoreMock.Verify(s => s.InvokingAsync(context, It.IsAny<CancellationToken>()), Times.Once);
+    }
+
+    [Fact]
+    public async Task InvokingAsync_WithInvokingFilter_CanModifyMessagesAsync()
+    {
+        // Arrange
+        var innerStoreMock = new Mock<ChatMessageStore>();
+        var innerMessages = new List<ChatMessage>
+        {
+            new(ChatRole.User, "Hello"),
+            new(ChatRole.Assistant, "Hi there!")
+        };
+        var context = new ChatMessageStore.InvokingContext([new ChatMessage(ChatRole.User, "Test")]);
+
+        innerStoreMock
+            .Setup(s => s.InvokingAsync(context, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(innerMessages);
+
+        // Filter that transforms messages
+        IEnumerable<ChatMessage> InvokingFilter(IEnumerable<ChatMessage> msgs) =>
+            msgs.Select(m => new ChatMessage(m.Role, $"[FILTERED] {m.Text}"));
+
+        var filter = new ChatMessageStoreMessageFilter(innerStoreMock.Object, InvokingFilter);
+
+        // Act
+        var result = (await filter.InvokingAsync(context, CancellationToken.None)).ToList();
+
+        // Assert
+        Assert.Equal(2, result.Count);
+        Assert.Equal("[FILTERED] Hello", result[0].Text);
+        Assert.Equal("[FILTERED] Hi there!", result[1].Text);
+    }
+
+    [Fact]
+    public async Task InvokedAsync_WithInvokedFilter_AppliesFilterAsync()
+    {
+        // Arrange
+        var innerStoreMock = new Mock<ChatMessageStore>();
+        var requestMessages = new List<ChatMessage> { new(ChatRole.User, "Hello") };
+        var chatMessageStoreMessages = new List<ChatMessage> { new(ChatRole.System, "System") };
+        var responseMessages = new List<ChatMessage> { new(ChatRole.Assistant, "Response") };
+        var context = new ChatMessageStore.InvokedContext(requestMessages, chatMessageStoreMessages)
+        {
+            ResponseMessages = responseMessages
+        };
+
+        ChatMessageStore.InvokedContext? capturedContext = null;
+        innerStoreMock
+            .Setup(s => s.InvokedAsync(It.IsAny<ChatMessageStore.InvokedContext>(), It.IsAny<CancellationToken>()))
+            .Callback<ChatMessageStore.InvokedContext, CancellationToken>((ctx, ct) => capturedContext = ctx)
+            .Returns(default(ValueTask));
+
+        // Filter that modifies the context
+        ChatMessageStore.InvokedContext InvokedFilter(ChatMessageStore.InvokedContext ctx)
+        {
+            var modifiedRequestMessages = ctx.RequestMessages.Select(m => new ChatMessage(m.Role, $"[FILTERED] {m.Text}")).ToList();
+            return new ChatMessageStore.InvokedContext(modifiedRequestMessages, ctx.ChatMessageStoreMessages)
+            {
+                ResponseMessages = ctx.ResponseMessages,
+                AIContextProviderMessages = ctx.AIContextProviderMessages,
+                InvokeException = ctx.InvokeException
+            };
+        }
+
+        var filter = new ChatMessageStoreMessageFilter(innerStoreMock.Object, invokedMessagesFilter: InvokedFilter);
+
+        // Act
+        await filter.InvokedAsync(context, CancellationToken.None);
+
+        // Assert
+        Assert.NotNull(capturedContext);
+        Assert.Single(capturedContext.RequestMessages);
+        Assert.Equal("[FILTERED] Hello", capturedContext.RequestMessages.First().Text);
+        innerStoreMock.Verify(s => s.InvokedAsync(It.IsAny<ChatMessageStore.InvokedContext>(), It.IsAny<CancellationToken>()), Times.Once);
+    }
+
+    [Fact]
+    public void Serialize_DelegatesToInnerStore()
+    {
+        // Arrange
+        var innerStoreMock = new Mock<ChatMessageStore>();
+        var expectedJson = JsonSerializer.SerializeToElement("data", TestJsonSerializerContext.Default.String);
+
+        innerStoreMock
+            .Setup(s => s.Serialize(It.IsAny<JsonSerializerOptions>()))
+            .Returns(expectedJson);
+
+        var filter = new ChatMessageStoreMessageFilter(innerStoreMock.Object, x => x, x => x);
+
+        // Act
+        var result = filter.Serialize();
+
+        // Assert
+        Assert.Equal(expectedJson.GetRawText(), result.GetRawText());
+        innerStoreMock.Verify(s => s.Serialize(null), Times.Once);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Abstractions.UnitTests/ChatMessageStoreTests.cs

@@ -78,11 +78,11 @@ public class ChatMessageStoreTests
 
     private sealed class TestChatMessageStore : ChatMessageStore
     {
-        public override Task<IEnumerable<ChatMessage>> GetMessagesAsync(CancellationToken cancellationToken = default)
-            => Task.FromResult<IEnumerable<ChatMessage>>([]);
+        public override ValueTask<IEnumerable<ChatMessage>> InvokingAsync(InvokingContext context, CancellationToken cancellationToken = default)
+            => new(Array.Empty<ChatMessage>());
 
-        public override Task AddMessagesAsync(IEnumerable<ChatMessage> messages, CancellationToken cancellationToken = default)
-            => Task.CompletedTask;
+        public override ValueTask InvokedAsync(InvokedContext context, CancellationToken cancellationToken = default)
+            => default;
 
         public override JsonElement Serialize(JsonSerializerOptions? jsonSerializerOptions = null)
             => default;

dotnet/tests/Microsoft.Agents.AI.Abstractions.UnitTests/DelegatingAIAgentTests.cs

@@ -38,19 +38,21 @@ public class DelegatingAIAgentTests
         this._innerAgentMock.Setup(x => x.GetNewThread()).Returns(this._testThread);
 
         this._innerAgentMock
-            .Setup(x => x.RunAsync(
-                It.IsAny<IReadOnlyCollection<ChatMessage>>(),
-                It.IsAny<AgentThread?>(),
-                It.IsAny<AgentRunOptions?>(),
-                It.IsAny<CancellationToken>()))
+            .Protected()
+            .Setup<Task<AgentRunResponse>>("RunCoreAsync",
+                ItExpr.IsAny<IEnumerable<ChatMessage>>(),
+                ItExpr.IsAny<AgentThread?>(),
+                ItExpr.IsAny<AgentRunOptions?>(),
+                ItExpr.IsAny<CancellationToken>())
             .ReturnsAsync(this._testResponse);
 
         this._innerAgentMock
-            .Setup(x => x.RunStreamingAsync(
-                It.IsAny<IReadOnlyCollection<ChatMessage>>(),
-                It.IsAny<AgentThread?>(),
-                It.IsAny<AgentRunOptions?>(),
-                It.IsAny<CancellationToken>()))
+            .Protected()
+            .Setup<IAsyncEnumerable<AgentRunResponseUpdate>>("RunCoreStreamingAsync",
+                ItExpr.IsAny<IEnumerable<ChatMessage>>(),
+                ItExpr.IsAny<AgentThread?>(),
+                ItExpr.IsAny<AgentRunOptions?>(),
+                ItExpr.IsAny<CancellationToken>())
             .Returns(ToAsyncEnumerableAsync(this._testStreamingResponses));
 
         this._delegatingAgent = new TestDelegatingAIAgent(this._innerAgentMock.Object);
@@ -159,7 +161,12 @@ public class DelegatingAIAgentTests
 
         var innerAgentMock = new Mock<AIAgent>();
         innerAgentMock
-            .Setup(x => x.RunAsync(expectedMessages, expectedThread, expectedOptions, expectedCancellationToken))
+            .Protected()
+            .Setup<Task<AgentRunResponse>>("RunCoreAsync",
+                ItExpr.Is<IEnumerable<ChatMessage>>(m => m == expectedMessages),
+                ItExpr.Is<AgentThread?>(t => t == expectedThread),
+                ItExpr.Is<AgentRunOptions?>(o => o == expectedOptions),
+                ItExpr.Is<CancellationToken>(ct => ct == expectedCancellationToken))
             .Returns(expectedResult.Task);
 
         var delegatingAgent = new TestDelegatingAIAgent(innerAgentMock.Object);
@@ -193,7 +200,12 @@ public class DelegatingAIAgentTests
 
         var innerAgentMock = new Mock<AIAgent>();
         innerAgentMock
-            .Setup(x => x.RunStreamingAsync(expectedMessages, expectedThread, expectedOptions, expectedCancellationToken))
+            .Protected()
+            .Setup<IAsyncEnumerable<AgentRunResponseUpdate>>("RunCoreStreamingAsync",
+                ItExpr.Is<IEnumerable<ChatMessage>>(m => m == expectedMessages),
+                ItExpr.Is<AgentThread?>(t => t == expectedThread),
+                ItExpr.Is<AgentRunOptions?>(o => o == expectedOptions),
+                ItExpr.Is<CancellationToken>(ct => ct == expectedCancellationToken))
             .Returns(ToAsyncEnumerableAsync(expectedResults));
 
         var delegatingAgent = new TestDelegatingAIAgent(innerAgentMock.Object);

dotnet/tests/Microsoft.Agents.AI.Abstractions.UnitTests/InMemoryChatMessageStoreTests.cs

@@ -47,34 +47,54 @@ public class InMemoryChatMessageStoreTests
     }
 
     [Fact]
-    public async Task AddMessagesAsyncAddsMessagesAndReturnsNullThreadIdAsync()
+    public async Task InvokedAsyncAddsMessagesAsync()
     {
-        var store = new InMemoryChatMessageStore();
-        var messages = new List<ChatMessage>
+        var requestMessages = new List<ChatMessage>
+        {
+            new(ChatRole.User, "Hello")
+        };
+        var responseMessages = new List<ChatMessage>
         {
-            new(ChatRole.User, "Hello"),
             new(ChatRole.Assistant, "Hi there!")
         };
+        var messageStoreMessages = new List<ChatMessage>()
+        {
+            new(ChatRole.System, "original instructions")
+        };
+        var aiContextProviderMessages = new List<ChatMessage>()
+        {
+            new(ChatRole.System, "additional context")
+        };
 
-        await store.AddMessagesAsync(messages, CancellationToken.None);
+        var store = new InMemoryChatMessageStore();
+        store.Add(messageStoreMessages[0]);
+        var context = new ChatMessageStore.InvokedContext(requestMessages, messageStoreMessages)
+        {
+            AIContextProviderMessages = aiContextProviderMessages,
+            ResponseMessages = responseMessages
+        };
+        await store.InvokedAsync(context, CancellationToken.None);
 
-        Assert.Equal(2, store.Count);
-        Assert.Equal("Hello", store[0].Text);
-        Assert.Equal("Hi there!", store[1].Text);
+        Assert.Equal(4, store.Count);
+        Assert.Equal("original instructions", store[0].Text);
+        Assert.Equal("Hello", store[1].Text);
+        Assert.Equal("additional context", store[2].Text);
+        Assert.Equal("Hi there!", store[3].Text);
     }
 
     [Fact]
-    public async Task AddMessagesAsyncWithEmptyDoesNotFailAsync()
+    public async Task InvokedAsyncWithEmptyDoesNotFailAsync()
     {
         var store = new InMemoryChatMessageStore();
 
-        await store.AddMessagesAsync([], CancellationToken.None);
+        var context = new ChatMessageStore.InvokedContext([], []);
+        await store.InvokedAsync(context, CancellationToken.None);
 
         Assert.Empty(store);
     }
 
     [Fact]
-    public async Task GetMessagesAsyncReturnsAllMessagesAsync()
+    public async Task InvokingAsyncReturnsAllMessagesAsync()
     {
         var store = new InMemoryChatMessageStore
         {
@@ -82,7 +102,8 @@ public class InMemoryChatMessageStoreTests
             new ChatMessage(ChatRole.Assistant, "Test2")
         };
 
-        var result = (await store.GetMessagesAsync(CancellationToken.None)).ToList();
+        var context = new ChatMessageStore.InvokingContext([]);
+        var result = (await store.InvokingAsync(context, CancellationToken.None)).ToList();
 
         Assert.Equal(2, result.Count);
         Assert.Contains(result, m => m.Text == "Test1");
@@ -157,24 +178,25 @@ public class InMemoryChatMessageStoreTests
     }
 
     [Fact]
-    public async Task AddMessagesAsyncWithEmptyMessagesDoesNotChangeStoreAsync()
+    public async Task InvokedAsyncWithEmptyMessagesDoesNotChangeStoreAsync()
     {
         var store = new InMemoryChatMessageStore();
         var messages = new List<ChatMessage>();
 
-        await store.AddMessagesAsync(messages, CancellationToken.None);
+        var context = new ChatMessageStore.InvokedContext(messages, []);
+        await store.InvokedAsync(context, CancellationToken.None);
 
         Assert.Empty(store);
     }
 
     [Fact]
-    public async Task AddMessagesAsync_WithNullMessages_ThrowsArgumentNullExceptionAsync()
+    public async Task InvokedAsync_WithNullContext_ThrowsArgumentNullExceptionAsync()
     {
         // Arrange
         var store = new InMemoryChatMessageStore();
 
         // Act & Assert
-        await Assert.ThrowsAsync<ArgumentNullException>(() => store.AddMessagesAsync(null!, CancellationToken.None));
+        await Assert.ThrowsAsync<ArgumentNullException>(() => store.InvokedAsync(null!, CancellationToken.None).AsTask());
     }
 
     [Fact]
@@ -498,7 +520,8 @@ public class InMemoryChatMessageStoreTests
         var store = new InMemoryChatMessageStore(reducerMock.Object, InMemoryChatMessageStore.ChatReducerTriggerEvent.AfterMessageAdded);
 
         // Act
-        await store.AddMessagesAsync(originalMessages, CancellationToken.None);
+        var context = new ChatMessageStore.InvokedContext(originalMessages, []);
+        await store.InvokedAsync(context, CancellationToken.None);
 
         // Assert
         Assert.Single(store);
@@ -526,10 +549,15 @@ public class InMemoryChatMessageStoreTests
             .ReturnsAsync(reducedMessages);
 
         var store = new InMemoryChatMessageStore(reducerMock.Object, InMemoryChatMessageStore.ChatReducerTriggerEvent.BeforeMessagesRetrieval);
-        await store.AddMessagesAsync(originalMessages, CancellationToken.None);
+        // Add messages directly to the store for this test
+        foreach (var msg in originalMessages)
+        {
+            store.Add(msg);
+        }
 
         // Act
-        var result = (await store.GetMessagesAsync(CancellationToken.None)).ToList();
+        var invokingContext = new ChatMessageStore.InvokingContext(Array.Empty<ChatMessage>());
+        var result = (await store.InvokingAsync(invokingContext, CancellationToken.None)).ToList();
 
         // Assert
         Assert.Single(result);
@@ -551,7 +579,8 @@ public class InMemoryChatMessageStoreTests
         var store = new InMemoryChatMessageStore(reducerMock.Object, InMemoryChatMessageStore.ChatReducerTriggerEvent.BeforeMessagesRetrieval);
 
         // Act
-        await store.AddMessagesAsync(originalMessages, CancellationToken.None);
+        var context = new ChatMessageStore.InvokedContext(originalMessages, []);
+        await store.InvokedAsync(context, CancellationToken.None);
 
         // Assert
         Assert.Single(store);
@@ -576,7 +605,8 @@ public class InMemoryChatMessageStoreTests
         };
 
         // Act
-        var result = (await store.GetMessagesAsync(CancellationToken.None)).ToList();
+        var invokingContext = new ChatMessageStore.InvokingContext(Array.Empty<ChatMessage>());
+        var result = (await store.InvokingAsync(invokingContext, CancellationToken.None)).ToList();
 
         // Assert
         Assert.Single(result);

dotnet/tests/Microsoft.Agents.AI.CosmosNoSql.UnitTests/CosmosChatMessageStoreTests.cs

@@ -202,11 +202,11 @@ public sealed class CosmosChatMessageStoreTests : IAsyncLifetime, IDisposable
 
     #endregion
 
-    #region AddMessagesAsync Tests
+    #region InvokedAsync Tests
 
     [SkippableFact]
     [Trait("Category", "CosmosDB")]
-    public async Task AddMessagesAsync_WithSingleMessage_ShouldAddMessageAsync()
+    public async Task InvokedAsync_WithSingleMessage_ShouldAddMessageAsync()
     {
         // Arrange
         this.SkipIfEmulatorNotAvailable();
@@ -214,14 +214,20 @@ public sealed class CosmosChatMessageStoreTests : IAsyncLifetime, IDisposable
         using var store = new CosmosChatMessageStore(this._connectionString, s_testDatabaseId, TestContainerId, conversationId);
         var message = new ChatMessage(ChatRole.User, "Hello, world!");
 
+        var context = new ChatMessageStore.InvokedContext([message], [])
+        {
+            ResponseMessages = []
+        };
+
         // Act
-        await store.AddMessagesAsync([message]);
+        await store.InvokedAsync(context);
 
         // Wait a moment for eventual consistency
         await Task.Delay(100);
 
         // Assert
-        var messages = await store.GetMessagesAsync();
+        var invokingContext = new ChatMessageStore.InvokingContext([]);
+        var messages = await store.InvokingAsync(invokingContext);
         var messageList = messages.ToList();
 
         // Simple assertion - if this fails, we know the deserialization is the issue
@@ -256,7 +262,7 @@ public sealed class CosmosChatMessageStoreTests : IAsyncLifetime, IDisposable
             }
 
             string rawJson = rawResults.Count > 0 ? Newtonsoft.Json.JsonConvert.SerializeObject(rawResults[0], Newtonsoft.Json.Formatting.Indented) : "null";
-            Assert.Fail($"GetMessagesAsync returned 0 messages, but direct count query found {count} items for conversation {conversationId}. Raw document: {rawJson}");
+            Assert.Fail($"InvokingAsync returned 0 messages, but direct count query found {count} items for conversation {conversationId}. Raw document: {rawJson}");
         }
 
         Assert.Single(messageList);
@@ -266,45 +272,63 @@ public sealed class CosmosChatMessageStoreTests : IAsyncLifetime, IDisposable
 
     [SkippableFact]
     [Trait("Category", "CosmosDB")]
-    public async Task AddMessagesAsync_WithMultipleMessages_ShouldAddAllMessagesAsync()
+    public async Task InvokedAsync_WithMultipleMessages_ShouldAddAllMessagesAsync()
     {
         // Arrange
         this.SkipIfEmulatorNotAvailable();
         var conversationId = Guid.NewGuid().ToString();
         using var store = new CosmosChatMessageStore(this._connectionString, s_testDatabaseId, TestContainerId, conversationId);
-        var messages = new[]
+        var requestMessages = new[]
         {
             new ChatMessage(ChatRole.User, "First message"),
             new ChatMessage(ChatRole.Assistant, "Second message"),
             new ChatMessage(ChatRole.User, "Third message")
         };
+        var aiContextProviderMessages = new[]
+        {
+            new ChatMessage(ChatRole.System, "System context message")
+        };
+        var responseMessages = new[]
+        {
+            new ChatMessage(ChatRole.Assistant, "Response message")
+        };
+
+        var context = new ChatMessageStore.InvokedContext(requestMessages, [])
+        {
+            AIContextProviderMessages = aiContextProviderMessages,
+            ResponseMessages = responseMessages
+        };
 
         // Act
-        await store.AddMessagesAsync(messages);
+        await store.InvokedAsync(context);
 
         // Assert
-        var retrievedMessages = await store.GetMessagesAsync();
+        var invokingContext = new ChatMessageStore.InvokingContext([]);
+        var retrievedMessages = await store.InvokingAsync(invokingContext);
         var messageList = retrievedMessages.ToList();
-        Assert.Equal(3, messageList.Count);
+        Assert.Equal(5, messageList.Count);
         Assert.Equal("First message", messageList[0].Text);
         Assert.Equal("Second message", messageList[1].Text);
         Assert.Equal("Third message", messageList[2].Text);
+        Assert.Equal("System context message", messageList[3].Text);
+        Assert.Equal("Response message", messageList[4].Text);
     }
 
     #endregion
 
-    #region GetMessagesAsync Tests
+    #region InvokingAsync Tests
 
     [SkippableFact]
     [Trait("Category", "CosmosDB")]
-    public async Task GetMessagesAsync_WithNoMessages_ShouldReturnEmptyAsync()
+    public async Task InvokingAsync_WithNoMessages_ShouldReturnEmptyAsync()
     {
         // Arrange
         this.SkipIfEmulatorNotAvailable();
         using var store = new CosmosChatMessageStore(this._connectionString, s_testDatabaseId, TestContainerId, Guid.NewGuid().ToString());
 
         // Act
-        var messages = await store.GetMessagesAsync();
+        var invokingContext = new ChatMessageStore.InvokingContext([]);
+        var messages = await store.InvokingAsync(invokingContext);
 
         // Assert
         Assert.Empty(messages);
@@ -312,7 +336,7 @@ public sealed class CosmosChatMessageStoreTests : IAsyncLifetime, IDisposable
 
     [SkippableFact]
     [Trait("Category", "CosmosDB")]
-    public async Task GetMessagesAsync_WithConversationIsolation_ShouldOnlyReturnMessagesForConversationAsync()
+    public async Task InvokingAsync_WithConversationIsolation_ShouldOnlyReturnMessagesForConversationAsync()
     {
         // Arrange
         this.SkipIfEmulatorNotAvailable();
@@ -322,12 +346,18 @@ public sealed class CosmosChatMessageStoreTests : IAsyncLifetime, IDisposable
         using var store1 = new CosmosChatMessageStore(this._connectionString, s_testDatabaseId, TestContainerId, conversation1);
         using var store2 = new CosmosChatMessageStore(this._connectionString, s_testDatabaseId, TestContainerId, conversation2);
 
-        await store1.AddMessagesAsync([new ChatMessage(ChatRole.User, "Message for conversation 1")]);
-        await store2.AddMessagesAsync([new ChatMessage(ChatRole.User, "Message for conversation 2")]);
+        var context1 = new ChatMessageStore.InvokedContext([new ChatMessage(ChatRole.User, "Message for conversation 1")], []);
+        var context2 = new ChatMessageStore.InvokedContext([new ChatMessage(ChatRole.User, "Message for conversation 2")], []);
+
+        await store1.InvokedAsync(context1);
+        await store2.InvokedAsync(context2);
 
         // Act
-        var messages1 = await store1.GetMessagesAsync();
-        var messages2 = await store2.GetMessagesAsync();
+        var invokingContext1 = new ChatMessageStore.InvokingContext([]);
+        var invokingContext2 = new ChatMessageStore.InvokingContext([]);
+
+        var messages1 = await store1.InvokingAsync(invokingContext1);
+        var messages2 = await store2.InvokingAsync(invokingContext2);
 
         // Assert
         var messageList1 = messages1.ToList();
@@ -361,16 +391,18 @@ public sealed class CosmosChatMessageStoreTests : IAsyncLifetime, IDisposable
         };
 
         // Act 1: Add messages
-        await originalStore.AddMessagesAsync(messages);
+        var invokedContext = new ChatMessageStore.InvokedContext(messages, []);
+        await originalStore.InvokedAsync(invokedContext);
 
         // Act 2: Verify messages were added
-        var retrievedMessages = await originalStore.GetMessagesAsync();
+        var invokingContext = new ChatMessageStore.InvokingContext([]);
+        var retrievedMessages = await originalStore.InvokingAsync(invokingContext);
         var retrievedList = retrievedMessages.ToList();
         Assert.Equal(5, retrievedList.Count);
 
         // Act 3: Create new store instance for same conversation (test persistence)
         using var newStore = new CosmosChatMessageStore(this._connectionString, s_testDatabaseId, TestContainerId, conversationId);
-        var persistedMessages = await newStore.GetMessagesAsync();
+        var persistedMessages = await newStore.InvokingAsync(invokingContext);
         var persistedList = persistedMessages.ToList();
 
         // Assert final state
@@ -502,7 +534,7 @@ public sealed class CosmosChatMessageStoreTests : IAsyncLifetime, IDisposable
 
     [SkippableFact]
     [Trait("Category", "CosmosDB")]
-    public async Task AddMessagesAsync_WithHierarchicalPartitioning_ShouldAddMessageWithMetadataAsync()
+    public async Task InvokedAsync_WithHierarchicalPartitioning_ShouldAddMessageWithMetadataAsync()
     {
         // Arrange
         this.SkipIfEmulatorNotAvailable();
@@ -513,14 +545,17 @@ public sealed class CosmosChatMessageStoreTests : IAsyncLifetime, IDisposable
         using var store = new CosmosChatMessageStore(this._connectionString, s_testDatabaseId, HierarchicalTestContainerId, TenantId, UserId, SessionId);
         var message = new ChatMessage(ChatRole.User, "Hello from hierarchical partitioning!");
 
+        var context = new ChatMessageStore.InvokedContext([message], []);
+
         // Act
-        await store.AddMessagesAsync([message]);
+        await store.InvokedAsync(context);
 
         // Wait a moment for eventual consistency
         await Task.Delay(100);
 
         // Assert
-        var messages = await store.GetMessagesAsync();
+        var invokingContext = new ChatMessageStore.InvokingContext([]);
+        var messages = await store.InvokingAsync(invokingContext);
         var messageList = messages.ToList();
 
         Assert.Single(messageList);
@@ -551,7 +586,7 @@ public sealed class CosmosChatMessageStoreTests : IAsyncLifetime, IDisposable
 
     [SkippableFact]
     [Trait("Category", "CosmosDB")]
-    public async Task AddMessagesAsync_WithHierarchicalMultipleMessages_ShouldAddAllMessagesAsync()
+    public async Task InvokedAsync_WithHierarchicalMultipleMessages_ShouldAddAllMessagesAsync()
     {
         // Arrange
         this.SkipIfEmulatorNotAvailable();
@@ -567,14 +602,17 @@ public sealed class CosmosChatMessageStoreTests : IAsyncLifetime, IDisposable
             new ChatMessage(ChatRole.User, "Third hierarchical message")
         };
 
+        var context = new ChatMessageStore.InvokedContext(messages, []);
+
         // Act
-        await store.AddMessagesAsync(messages);
+        await store.InvokedAsync(context);
 
         // Wait a moment for eventual consistency
         await Task.Delay(100);
 
         // Assert
-        var retrievedMessages = await store.GetMessagesAsync();
+        var invokingContext = new ChatMessageStore.InvokingContext([]);
+        var retrievedMessages = await store.InvokingAsync(invokingContext);
         var messageList = retrievedMessages.ToList();
 
         Assert.Equal(3, messageList.Count);
@@ -585,7 +623,7 @@ public sealed class CosmosChatMessageStoreTests : IAsyncLifetime, IDisposable
 
     [SkippableFact]
     [Trait("Category", "CosmosDB")]
-    public async Task GetMessagesAsync_WithHierarchicalPartitionIsolation_ShouldIsolateMessagesByUserIdAsync()
+    public async Task InvokingAsync_WithHierarchicalPartitionIsolation_ShouldIsolateMessagesByUserIdAsync()
     {
         // Arrange
         this.SkipIfEmulatorNotAvailable();
@@ -599,17 +637,23 @@ public sealed class CosmosChatMessageStoreTests : IAsyncLifetime, IDisposable
         using var store2 = new CosmosChatMessageStore(this._connectionString, s_testDatabaseId, HierarchicalTestContainerId, TenantId, UserId2, SessionId);
 
         // Add messages to both stores
-        await store1.AddMessagesAsync([new ChatMessage(ChatRole.User, "Message from user 1")]);
-        await store2.AddMessagesAsync([new ChatMessage(ChatRole.User, "Message from user 2")]);
+        var context1 = new ChatMessageStore.InvokedContext([new ChatMessage(ChatRole.User, "Message from user 1")], []);
+        var context2 = new ChatMessageStore.InvokedContext([new ChatMessage(ChatRole.User, "Message from user 2")], []);
+
+        await store1.InvokedAsync(context1);
+        await store2.InvokedAsync(context2);
 
         // Wait a moment for eventual consistency
         await Task.Delay(100);
 
         // Act & Assert
-        var messages1 = await store1.GetMessagesAsync();
+        var invokingContext1 = new ChatMessageStore.InvokingContext([]);
+        var invokingContext2 = new ChatMessageStore.InvokingContext([]);
+
+        var messages1 = await store1.InvokingAsync(invokingContext1);
         var messageList1 = messages1.ToList();
 
-        var messages2 = await store2.GetMessagesAsync();
+        var messages2 = await store2.InvokingAsync(invokingContext2);
         var messageList2 = messages2.ToList();
 
         // With true hierarchical partitioning, each user sees only their own messages
@@ -630,7 +674,9 @@ public sealed class CosmosChatMessageStoreTests : IAsyncLifetime, IDisposable
         const string SessionId = "session-serialize";
 
         using var originalStore = new CosmosChatMessageStore(this._connectionString, s_testDatabaseId, HierarchicalTestContainerId, TenantId, UserId, SessionId);
-        await originalStore.AddMessagesAsync([new ChatMessage(ChatRole.User, "Test serialization message")]);
+
+        var context = new ChatMessageStore.InvokedContext([new ChatMessage(ChatRole.User, "Test serialization message")], []);
+        await originalStore.InvokedAsync(context);
 
         // Act - Serialize the store state
         var serializedState = originalStore.Serialize();
@@ -647,7 +693,8 @@ public sealed class CosmosChatMessageStoreTests : IAsyncLifetime, IDisposable
         await Task.Delay(100);
 
         // Assert - The deserialized store should have the same functionality
-        var messages = await deserializedStore.GetMessagesAsync();
+        var invokingContext = new ChatMessageStore.InvokingContext([]);
+        var messages = await deserializedStore.InvokingAsync(invokingContext);
         var messageList = messages.ToList();
 
         Assert.Single(messageList);
@@ -670,17 +717,22 @@ public sealed class CosmosChatMessageStoreTests : IAsyncLifetime, IDisposable
         using var hierarchicalStore = new CosmosChatMessageStore(this._connectionString, s_testDatabaseId, HierarchicalTestContainerId, "tenant-coexist", "user-coexist", SessionId);
 
         // Add messages to both
-        await simpleStore.AddMessagesAsync([new ChatMessage(ChatRole.User, "Simple partitioning message")]);
-        await hierarchicalStore.AddMessagesAsync([new ChatMessage(ChatRole.User, "Hierarchical partitioning message")]);
+        var simpleContext = new ChatMessageStore.InvokedContext([new ChatMessage(ChatRole.User, "Simple partitioning message")], []);
+        var hierarchicalContext = new ChatMessageStore.InvokedContext([new ChatMessage(ChatRole.User, "Hierarchical partitioning message")], []);
+
+        await simpleStore.InvokedAsync(simpleContext);
+        await hierarchicalStore.InvokedAsync(hierarchicalContext);
 
         // Wait a moment for eventual consistency
         await Task.Delay(100);
 
         // Act & Assert
-        var simpleMessages = await simpleStore.GetMessagesAsync();
+        var invokingContext = new ChatMessageStore.InvokingContext([]);
+
+        var simpleMessages = await simpleStore.InvokingAsync(invokingContext);
         var simpleMessageList = simpleMessages.ToList();
 
-        var hierarchicalMessages = await hierarchicalStore.GetMessagesAsync();
+        var hierarchicalMessages = await hierarchicalStore.InvokingAsync(invokingContext);
         var hierarchicalMessageList = hierarchicalMessages.ToList();
 
         // Each should only see its own messages since they use different containers
@@ -707,14 +759,17 @@ public sealed class CosmosChatMessageStoreTests : IAsyncLifetime, IDisposable
             messages.Add(new ChatMessage(ChatRole.User, $"Message {i}"));
             await Task.Delay(10); // Small delay to ensure different timestamps
         }
-        await store.AddMessagesAsync(messages);
+
+        var context = new ChatMessageStore.InvokedContext(messages, []);
+        await store.InvokedAsync(context);
 
         // Wait for eventual consistency
         await Task.Delay(100);
 
         // Act - Set max to 5 and retrieve
         store.MaxMessagesToRetrieve = 5;
-        var retrievedMessages = await store.GetMessagesAsync();
+        var invokingContext = new ChatMessageStore.InvokingContext([]);
+        var retrievedMessages = await store.InvokingAsync(invokingContext);
         var messageList = retrievedMessages.ToList();
 
         // Assert - Should get the 5 most recent messages (6-10) in ascending order
@@ -742,13 +797,16 @@ public sealed class CosmosChatMessageStoreTests : IAsyncLifetime, IDisposable
         {
             messages.Add(new ChatMessage(ChatRole.User, $"Message {i}"));
         }
-        await store.AddMessagesAsync(messages);
+
+        var context = new ChatMessageStore.InvokedContext(messages, []);
+        await store.InvokedAsync(context);
 
         // Wait for eventual consistency
         await Task.Delay(100);
 
         // Act - No limit set (default null)
-        var retrievedMessages = await store.GetMessagesAsync();
+        var invokingContext = new ChatMessageStore.InvokingContext([]);
+        var retrievedMessages = await store.InvokingAsync(invokingContext);
         var messageList = retrievedMessages.ToList();
 
         // Assert - Should get all 10 messages

dotnet/tests/Microsoft.Agents.AI.Declarative.UnitTests/AggregatorPromptAgentFactoryTests.cs

@@ -76,12 +76,12 @@ public sealed class AggregatorPromptAgentFactoryTests
             throw new NotImplementedException();
         }
 
-        public override Task<AgentRunResponse> RunAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
+        protected override Task<AgentRunResponse> RunCoreAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
         {
             throw new NotImplementedException();
         }
 
-        public override IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
+        protected override IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
         {
             throw new NotImplementedException();
         }

dotnet/tests/Microsoft.Agents.AI.Hosting.AGUI.AspNetCore.IntegrationTests/BasicStreamingTests.cs

@@ -290,7 +290,7 @@ internal sealed class FakeChatClientAgent : AIAgent
         return new FakeInMemoryAgentThread(serializedThread, jsonSerializerOptions);
     }
 
-    public override async Task<AgentRunResponse> RunAsync(
+    protected override async Task<AgentRunResponse> RunCoreAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,
@@ -305,7 +305,7 @@ internal sealed class FakeChatClientAgent : AIAgent
         return updates.ToAgentRunResponse();
     }
 
-    public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+    protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,
@@ -358,7 +358,7 @@ internal sealed class FakeMultiMessageAgent : AIAgent
         return new FakeInMemoryAgentThread(serializedThread, jsonSerializerOptions);
     }
 
-    public override async Task<AgentRunResponse> RunAsync(
+    protected override async Task<AgentRunResponse> RunCoreAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,
@@ -373,7 +373,7 @@ internal sealed class FakeMultiMessageAgent : AIAgent
         return updates.ToAgentRunResponse();
     }
 
-    public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+    protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,

dotnet/tests/Microsoft.Agents.AI.Hosting.AGUI.AspNetCore.IntegrationTests/ForwardedPropertiesTests.cs

@@ -303,12 +303,12 @@ internal sealed class FakeForwardedPropsAgent : AIAgent
 
     public JsonElement ReceivedForwardedProperties { get; private set; }
 
-    public override Task<AgentRunResponse> RunAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
+    protected override Task<AgentRunResponse> RunCoreAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
     {
-        return this.RunStreamingAsync(messages, thread, options, cancellationToken).ToAgentRunResponseAsync(cancellationToken);
+        return this.RunCoreStreamingAsync(messages, thread, options, cancellationToken).ToAgentRunResponseAsync(cancellationToken);
     }
 
-    public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+    protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,

dotnet/tests/Microsoft.Agents.AI.Hosting.AGUI.AspNetCore.IntegrationTests/SharedStateTests.cs

@@ -342,12 +342,12 @@ internal sealed class FakeStateAgent : AIAgent
 {
     public override string? Description => "Agent for state testing";
 
-    public override Task<AgentRunResponse> RunAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
+    protected override Task<AgentRunResponse> RunCoreAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
     {
-        return this.RunStreamingAsync(messages, thread, options, cancellationToken).ToAgentRunResponseAsync(cancellationToken);
+        return this.RunCoreStreamingAsync(messages, thread, options, cancellationToken).ToAgentRunResponseAsync(cancellationToken);
     }
 
-    public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+    protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,

dotnet/tests/Microsoft.Agents.AI.Hosting.AGUI.AspNetCore.UnitTests/AGUIEndpointRouteBuilderExtensionsTests.cs

@@ -430,12 +430,12 @@ public sealed class AGUIEndpointRouteBuilderExtensionsTests
         public override AgentThread DeserializeThread(JsonElement serializedThread, JsonSerializerOptions? jsonSerializerOptions = null) =>
             new TestInMemoryAgentThread(serializedThread, jsonSerializerOptions);
 
-        public override Task<AgentRunResponse> RunAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
+        protected override Task<AgentRunResponse> RunCoreAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
         {
             throw new NotImplementedException();
         }
 
-        public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+        protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
             IEnumerable<ChatMessage> messages,
             AgentThread? thread = null,
             AgentRunOptions? options = null,
@@ -519,12 +519,12 @@ public sealed class AGUIEndpointRouteBuilderExtensionsTests
         public override AgentThread DeserializeThread(JsonElement serializedThread, JsonSerializerOptions? jsonSerializerOptions = null) =>
             new TestInMemoryAgentThread(serializedThread, jsonSerializerOptions);
 
-        public override Task<AgentRunResponse> RunAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
+        protected override Task<AgentRunResponse> RunCoreAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
         {
             throw new NotImplementedException();
         }
 
-        public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+        protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
             IEnumerable<ChatMessage> messages,
             AgentThread? thread = null,
             AgentRunOptions? options = null,

dotnet/tests/Microsoft.Agents.AI.Hosting.AzureFunctions.IntegrationTests/SamplesValidation.cs

@@ -19,6 +19,7 @@ public sealed class SamplesValidation(ITestOutputHelper outputHelper) : IAsyncLi
     private const string AzureFunctionsPort = "7071";
     private const string AzuritePort = "10000";
     private const string DtsPort = "8080";
+    private const string RedisPort = "6379";
 
     private static readonly string s_dotnetTargetFramework = GetTargetFramework();
     private static readonly HttpClient s_sharedHttpClient = new();
@@ -392,6 +393,136 @@ public sealed class SamplesValidation(ITestOutputHelper outputHelper) : IAsyncLi
         });
     }
 
+    [Fact]
+    public async Task ReliableStreamingSampleValidationAsync()
+    {
+        string samplePath = Path.Combine(s_samplesPath, "08_ReliableStreaming");
+        await this.RunSampleTestAsync(samplePath, async (logs) =>
+        {
+            Uri createUri = new($"http://localhost:{AzureFunctionsPort}/api/agent/create");
+            this._outputHelper.WriteLine($"Starting reliable streaming agent via POST request to {createUri}...");
+
+            // Test the agent endpoint with a simple prompt
+            const string RequestBody = "Plan a 3-day trip to Seattle. Include daily activities.";
+            using HttpContent content = new StringContent(RequestBody, Encoding.UTF8, "text/plain");
+            using HttpRequestMessage request = new(HttpMethod.Post, createUri)
+            {
+                Content = content
+            };
+            request.Headers.Add("Accept", "text/plain");
+
+            using HttpResponseMessage response = await s_sharedHttpClient.SendAsync(
+                request,
+                HttpCompletionOption.ResponseHeadersRead);
+
+            // The response should be successful
+            Assert.True(response.IsSuccessStatusCode, $"Agent request failed with status: {response.StatusCode}");
+            Assert.Equal("text/plain", response.Content.Headers.ContentType?.MediaType);
+
+            // The response headers should include the conversation ID
+            string? conversationId = response.Headers.GetValues("x-conversation-id")?.FirstOrDefault();
+            Assert.NotNull(conversationId);
+            Assert.NotEmpty(conversationId);
+            this._outputHelper.WriteLine($"Agent conversation ID: {conversationId}");
+
+            // Read the streamed response
+            using Stream responseStream = await response.Content.ReadAsStreamAsync();
+            using StreamReader reader = new(responseStream);
+            StringBuilder responseText = new();
+            char[] buffer = new char[1024];
+            int bytesRead;
+
+            // Read for a reasonable amount of time to get some content
+            using CancellationTokenSource readTimeout = new(TimeSpan.FromSeconds(30));
+            try
+            {
+                while (!readTimeout.Token.IsCancellationRequested)
+                {
+                    bytesRead = await reader.ReadAsync(buffer, 0, buffer.Length);
+                    if (bytesRead == 0)
+                    {
+                        // Check if we've received enough content
+                        if (responseText.Length > 50)
+                        {
+                            break;
+                        }
+                        await Task.Delay(100, readTimeout.Token);
+                        continue;
+                    }
+
+                    responseText.Append(buffer, 0, bytesRead);
+                    if (responseText.Length > 200)
+                    {
+                        // We've received enough content to validate
+                        break;
+                    }
+                }
+            }
+            catch (OperationCanceledException)
+            {
+                // Timeout is acceptable if we got some content
+            }
+
+            string responseContent = responseText.ToString();
+            Assert.True(responseContent.Length > 0, "Expected to receive some streamed content");
+            this._outputHelper.WriteLine($"Received {responseContent.Length} characters of streamed content");
+
+            // Test resumption by calling the stream endpoint
+            Uri streamUri = new($"http://localhost:{AzureFunctionsPort}/api/agent/stream/{conversationId}");
+            this._outputHelper.WriteLine($"Testing stream resumption via GET request to {streamUri}...");
+
+            using HttpRequestMessage streamRequest = new(HttpMethod.Get, streamUri);
+            streamRequest.Headers.Add("Accept", "text/plain");
+
+            using HttpResponseMessage streamResponse = await s_sharedHttpClient.SendAsync(
+                streamRequest,
+                HttpCompletionOption.ResponseHeadersRead);
+            Assert.True(streamResponse.IsSuccessStatusCode, $"Stream request failed with status: {streamResponse.StatusCode}");
+            Assert.Equal("text/plain", streamResponse.Content.Headers.ContentType?.MediaType);
+
+            // Verify the conversation ID header is present
+            string? resumedConversationId = streamResponse.Headers.GetValues("x-conversation-id")?.FirstOrDefault();
+            Assert.Equal(conversationId, resumedConversationId);
+
+            // Read some content from the resumed stream
+            using Stream resumedStream = await streamResponse.Content.ReadAsStreamAsync();
+            using StreamReader resumedReader = new(resumedStream);
+            StringBuilder resumedText = new();
+
+            using CancellationTokenSource resumedReadTimeout = new(TimeSpan.FromSeconds(10));
+            try
+            {
+                while (!resumedReadTimeout.Token.IsCancellationRequested)
+                {
+                    bytesRead = await resumedReader.ReadAsync(buffer, 0, buffer.Length);
+                    if (bytesRead == 0)
+                    {
+                        if (resumedText.Length > 50)
+                        {
+                            break;
+                        }
+                        await Task.Delay(100, resumedReadTimeout.Token);
+                        continue;
+                    }
+
+                    resumedText.Append(buffer, 0, bytesRead);
+                    if (resumedText.Length > 100)
+                    {
+                        break;
+                    }
+                }
+            }
+            catch (OperationCanceledException)
+            {
+                // Timeout is acceptable if we got some content
+            }
+
+            string resumedContent = resumedText.ToString();
+            Assert.True(resumedContent.Length > 0, "Expected to receive some content from resumed stream");
+            this._outputHelper.WriteLine($"Received {resumedContent.Length} characters from resumed stream");
+        });
+    }
+
     private async Task<string> InvokeMcpToolAsync(McpClient mcpClient, string toolName, string query)
     {
         this._outputHelper.WriteLine($"Invoking MCP tool '{toolName}'...");
@@ -482,6 +613,21 @@ public sealed class SamplesValidation(ITestOutputHelper outputHelper) : IAsyncLi
                 message: "DTS emulator is running",
                 timeout: TimeSpan.FromSeconds(30));
         }
+
+        // Start Redis if it's not already running
+        if (!await this.IsRedisRunningAsync())
+        {
+            await this.StartDockerContainerAsync(
+                containerName: "redis",
+                image: "redis:latest",
+                ports: ["-p", "6379:6379"]);
+
+            // Wait for Redis
+            await this.WaitForConditionAsync(
+                condition: this.IsRedisRunningAsync,
+                message: "Redis is running",
+                timeout: TimeSpan.FromSeconds(30));
+        }
     }
 
     private async Task<bool> IsAzuriteRunningAsync()
@@ -562,6 +708,49 @@ public sealed class SamplesValidation(ITestOutputHelper outputHelper) : IAsyncLi
         }
     }
 
+    private async Task<bool> IsRedisRunningAsync()
+    {
+        this._outputHelper.WriteLine($"Checking if Redis is running at localhost:{RedisPort}...");
+
+        try
+        {
+            using CancellationTokenSource timeoutCts = new(TimeSpan.FromSeconds(30));
+            ProcessStartInfo startInfo = new()
+            {
+                FileName = "docker",
+                Arguments = "exec redis redis-cli ping",
+                UseShellExecute = false,
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                CreateNoWindow = true
+            };
+
+            using Process process = new() { StartInfo = startInfo };
+            if (!process.Start())
+            {
+                this._outputHelper.WriteLine("Failed to start docker exec command");
+                return false;
+            }
+
+            string output = await process.StandardOutput.ReadToEndAsync(timeoutCts.Token);
+            await process.WaitForExitAsync(timeoutCts.Token);
+
+            if (process.ExitCode == 0 && output.Contains("PONG", StringComparison.OrdinalIgnoreCase))
+            {
+                this._outputHelper.WriteLine("Redis is running");
+                return true;
+            }
+
+            this._outputHelper.WriteLine($"Redis is not running. Exit code: {process.ExitCode}, Output: {output}");
+            return false;
+        }
+        catch (Exception ex)
+        {
+            this._outputHelper.WriteLine($"Redis is not running: {ex.Message}");
+            return false;
+        }
+    }
+
     private async Task StartDockerContainerAsync(string containerName, string image, string[] ports)
     {
         // Stop existing container if it exists
@@ -646,6 +835,7 @@ public sealed class SamplesValidation(ITestOutputHelper outputHelper) : IAsyncLi
         startInfo.EnvironmentVariables["DURABLE_TASK_SCHEDULER_CONNECTION_STRING"] =
             $"Endpoint=http://localhost:{DtsPort};TaskHub=default;Authentication=None";
         startInfo.EnvironmentVariables["AzureWebJobsStorage"] = "UseDevelopmentStorage=true";
+        startInfo.EnvironmentVariables["REDIS_CONNECTION_STRING"] = $"localhost:{RedisPort}";
 
         Process process = new() { StartInfo = startInfo };
 

dotnet/tests/Microsoft.Agents.AI.Hosting.AzureFunctions.UnitTests/TestAgent.cs

@@ -17,13 +17,13 @@ internal sealed class TestAgent(string name, string description) : AIAgent
         JsonElement serializedThread,
         JsonSerializerOptions? jsonSerializerOptions = null) => new DummyAgentThread();
 
-    public override Task<AgentRunResponse> RunAsync(
+    protected override Task<AgentRunResponse> RunCoreAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,
         CancellationToken cancellationToken = default) => Task.FromResult(new AgentRunResponse([.. messages]));
 
-    public override IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+    protected override IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
         IEnumerable<ChatMessage> messages,
         AgentThread? thread = null,
         AgentRunOptions? options = null,

dotnet/tests/Microsoft.Agents.AI.OpenAI.UnitTests/Extensions/AIAgentWithOpenAIExtensionsTests.cs

@@ -6,6 +6,7 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Moq;
+using Moq.Protected;
 using ChatMessage = Microsoft.Extensions.AI.ChatMessage;
 using ChatRole = Microsoft.Extensions.AI.ChatRole;
 using OpenAIChatMessage = OpenAI.Chat.ChatMessage;
@@ -76,22 +77,28 @@ public sealed class AIAgentWithOpenAIExtensionsTests
         var responseMessage = new ChatMessage(ChatRole.Assistant, [new TextContent(ResponseText)]);
 
         mockAgent
-            .Setup(a => a.RunAsync(It.IsAny<IEnumerable<ChatMessage>>(), It.IsAny<AgentThread?>(), It.IsAny<AgentRunOptions?>(), It.IsAny<CancellationToken>()))
+            .Protected()
+            .Setup<Task<AgentRunResponse>>("RunCoreAsync",
+                ItExpr.IsAny<IEnumerable<ChatMessage>>(),
+                ItExpr.IsAny<AgentThread?>(),
+                ItExpr.IsAny<AgentRunOptions?>(),
+                ItExpr.IsAny<CancellationToken>())
             .ReturnsAsync(new AgentRunResponse([responseMessage]));
 
         // Act
         var result = await mockAgent.Object.RunAsync(openAiMessages, mockThread.Object, options, cancellationToken);
 
         // Assert
-        mockAgent.Verify(
-            a => a.RunAsync(
-                It.Is<IEnumerable<ChatMessage>>(msgs =>
+        mockAgent.Protected()
+            .Verify("RunCoreAsync",
+                Times.Once(),
+                ItExpr.Is<IEnumerable<ChatMessage>>(msgs =>
                     msgs.ToList().Count == 1 &&
                     msgs.ToList()[0].Text == TestMessageText),
                 mockThread.Object,
                 options,
-                cancellationToken),
-            Times.Once);
+                cancellationToken
+        );
 
         Assert.NotNull(result);
         Assert.NotEmpty(result.Content);
@@ -160,7 +167,12 @@ public sealed class AIAgentWithOpenAIExtensionsTests
         };
 
         mockAgent
-            .Setup(a => a.RunStreamingAsync(It.IsAny<IEnumerable<ChatMessage>>(), It.IsAny<AgentThread?>(), It.IsAny<AgentRunOptions?>(), It.IsAny<CancellationToken>()))
+            .Protected()
+            .Setup<IAsyncEnumerable<AgentRunResponseUpdate>>("RunCoreStreamingAsync",
+                ItExpr.IsAny<IEnumerable<ChatMessage>>(),
+                ItExpr.IsAny<AgentThread?>(),
+                ItExpr.IsAny<AgentRunOptions?>(),
+                ItExpr.IsAny<CancellationToken>())
             .Returns(ToAsyncEnumerableAsync(responseUpdates));
 
         // Act
@@ -172,15 +184,16 @@ public sealed class AIAgentWithOpenAIExtensionsTests
         }
 
         // Assert
-        mockAgent.Verify(
-            a => a.RunStreamingAsync(
-                It.Is<IEnumerable<ChatMessage>>(msgs =>
+        mockAgent.Protected()
+            .Verify("RunCoreStreamingAsync",
+                Times.Once(),
+                ItExpr.Is<IEnumerable<ChatMessage>>(msgs =>
                     msgs.ToList().Count == 1 &&
                     msgs.ToList()[0].Text == TestMessageText),
                 mockThread.Object,
                 options,
-                cancellationToken),
-            Times.Once);
+                cancellationToken
+            );
 
         Assert.True(updateCount > 0, "Expected at least one streaming update");
     }

dotnet/tests/Microsoft.Agents.AI.Purview.UnitTests/PurviewWrapperTests.cs

@@ -8,6 +8,7 @@ using Microsoft.Agents.AI.Purview.Models.Common;
 using Microsoft.Extensions.AI;
 using Microsoft.Extensions.Logging.Abstractions;
 using Moq;
+using Moq.Protected;
 
 namespace Microsoft.Agents.AI.Purview.UnitTests;
 
@@ -277,11 +278,13 @@ public sealed class PurviewWrapperTests : IDisposable
         Assert.Single(result.Messages);
         Assert.Equal(ChatRole.System, result.Messages[0].Role);
         Assert.Equal("Prompt blocked by policy", result.Messages[0].Text);
-        mockAgent.Verify(x => x.RunAsync(
-            It.IsAny<IEnumerable<ChatMessage>>(),
-            It.IsAny<AgentThread>(),
-            It.IsAny<AgentRunOptions>(),
-            It.IsAny<CancellationToken>()), Times.Never);
+
+        mockAgent.Protected().Verify("RunCoreAsync",
+            Times.Never(),
+            ItExpr.IsAny<IEnumerable<ChatMessage>>(),
+            ItExpr.IsAny<AgentThread>(),
+            ItExpr.IsAny<AgentRunOptions>(),
+            ItExpr.IsAny<CancellationToken>());
     }
 
     [Fact]
@@ -295,11 +298,12 @@ public sealed class PurviewWrapperTests : IDisposable
         var mockAgent = new Mock<AIAgent>();
         var innerResponse = new AgentRunResponse(new ChatMessage(ChatRole.Assistant, "Sensitive response"));
 
-        mockAgent.Setup(x => x.RunAsync(
-            It.IsAny<IEnumerable<ChatMessage>>(),
-            It.IsAny<AgentThread>(),
-            It.IsAny<AgentRunOptions>(),
-            It.IsAny<CancellationToken>()))
+        mockAgent.Protected()
+            .Setup<Task<AgentRunResponse>>("RunCoreAsync",
+                ItExpr.IsAny<IEnumerable<ChatMessage>>(),
+                ItExpr.IsAny<AgentThread>(),
+                ItExpr.IsAny<AgentRunOptions>(),
+                ItExpr.IsAny<CancellationToken>())
             .ReturnsAsync(innerResponse);
 
         this._mockProcessor.SetupSequence(x => x.ProcessMessagesAsync(
@@ -333,11 +337,12 @@ public sealed class PurviewWrapperTests : IDisposable
         var mockAgent = new Mock<AIAgent>();
         var innerResponse = new AgentRunResponse(new ChatMessage(ChatRole.Assistant, "Safe response"));
 
-        mockAgent.Setup(x => x.RunAsync(
-            It.IsAny<IEnumerable<ChatMessage>>(),
-            It.IsAny<AgentThread>(),
-            It.IsAny<AgentRunOptions>(),
-            It.IsAny<CancellationToken>()))
+        mockAgent.Protected()
+            .Setup<Task<AgentRunResponse>>("RunCoreAsync",
+                ItExpr.IsAny<IEnumerable<ChatMessage>>(),
+                ItExpr.IsAny<AgentThread>(),
+                ItExpr.IsAny<AgentRunOptions>(),
+                ItExpr.IsAny<CancellationToken>())
             .ReturnsAsync(innerResponse);
 
         this._mockProcessor.Setup(x => x.ProcessMessagesAsync(
@@ -375,11 +380,12 @@ public sealed class PurviewWrapperTests : IDisposable
 
         var expectedResponse = new AgentRunResponse(new ChatMessage(ChatRole.Assistant, "Response from inner agent"));
         var mockAgent = new Mock<AIAgent>();
-        mockAgent.Setup(x => x.RunAsync(
-            It.IsAny<IEnumerable<ChatMessage>>(),
-            It.IsAny<AgentThread>(),
-            It.IsAny<AgentRunOptions>(),
-            It.IsAny<CancellationToken>()))
+        mockAgent.Protected()
+            .Setup<Task<AgentRunResponse>>("RunCoreAsync",
+                ItExpr.IsAny<IEnumerable<ChatMessage>>(),
+                ItExpr.IsAny<AgentThread>(),
+                ItExpr.IsAny<AgentRunOptions>(),
+                ItExpr.IsAny<CancellationToken>())
             .ReturnsAsync(expectedResponse);
 
         this._mockProcessor.SetupSequence(x => x.ProcessMessagesAsync(
@@ -441,11 +447,12 @@ public sealed class PurviewWrapperTests : IDisposable
 
         var expectedResponse = new AgentRunResponse(new ChatMessage(ChatRole.Assistant, "Response"));
         var mockAgent = new Mock<AIAgent>();
-        mockAgent.Setup(x => x.RunAsync(
-            It.IsAny<IEnumerable<ChatMessage>>(),
-            It.IsAny<AgentThread>(),
-            It.IsAny<AgentRunOptions>(),
-            It.IsAny<CancellationToken>()))
+        mockAgent.Protected()
+            .Setup<Task<AgentRunResponse>>("RunCoreAsync",
+                ItExpr.IsAny<IEnumerable<ChatMessage>>(),
+                ItExpr.IsAny<AgentThread>(),
+                ItExpr.IsAny<AgentRunOptions>(),
+                ItExpr.IsAny<CancellationToken>())
             .ReturnsAsync(expectedResponse);
 
         this._mockProcessor.Setup(x => x.ProcessMessagesAsync(
@@ -482,11 +489,12 @@ public sealed class PurviewWrapperTests : IDisposable
 
         var expectedResponse = new AgentRunResponse(new ChatMessage(ChatRole.Assistant, "Response"));
         var mockAgent = new Mock<AIAgent>();
-        mockAgent.Setup(x => x.RunAsync(
-            It.IsAny<IEnumerable<ChatMessage>>(),
-            It.IsAny<AgentThread>(),
-            It.IsAny<AgentRunOptions>(),
-            It.IsAny<CancellationToken>()))
+        mockAgent.Protected()
+            .Setup<Task<AgentRunResponse>>("RunCoreAsync",
+                ItExpr.IsAny<IEnumerable<ChatMessage>>(),
+                ItExpr.IsAny<AgentThread>(),
+                ItExpr.IsAny<AgentRunOptions>(),
+                ItExpr.IsAny<CancellationToken>())
             .ReturnsAsync(expectedResponse);
 
         string? capturedThreadId = null;
@@ -521,11 +529,12 @@ public sealed class PurviewWrapperTests : IDisposable
         var mockAgent = new Mock<AIAgent>();
         var innerResponse = new AgentRunResponse(new ChatMessage(ChatRole.Assistant, "Response"));
 
-        mockAgent.Setup(x => x.RunAsync(
-            It.IsAny<IEnumerable<ChatMessage>>(),
-            It.IsAny<AgentThread>(),
-            It.IsAny<AgentRunOptions>(),
-            It.IsAny<CancellationToken>()))
+        mockAgent.Protected()
+            .Setup<Task<AgentRunResponse>>("RunCoreAsync",
+                ItExpr.IsAny<IEnumerable<ChatMessage>>(),
+                ItExpr.IsAny<AgentThread>(),
+                ItExpr.IsAny<AgentRunOptions>(),
+                ItExpr.IsAny<CancellationToken>())
             .ReturnsAsync(innerResponse);
 
         var callCount = 0;

dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentExtensionsTests.cs

@@ -337,7 +337,7 @@ public class AgentExtensionsTests
         public CancellationToken LastCancellationToken { get; private set; }
         public int RunAsyncCallCount { get; private set; }
 
-        public override Task<AgentRunResponse> RunAsync(
+        protected override Task<AgentRunResponse> RunCoreAsync(
             IEnumerable<ChatMessage> messages,
             AgentThread? thread = null,
             AgentRunOptions? options = null,
@@ -355,7 +355,7 @@ public class AgentExtensionsTests
             return Task.FromResult(this._responseToReturn!);
         }
 
-        public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+        protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
             IEnumerable<ChatMessage> messages,
             AgentThread? thread = null,
             AgentRunOptions? options = null,

dotnet/tests/Microsoft.Agents.AI.UnitTests/AnonymousDelegatingAIAgentTests.cs

@@ -8,6 +8,7 @@ using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.AI;
 using Moq;
+using Moq.Protected;
 
 namespace Microsoft.Agents.AI.UnitTests;
 
@@ -35,18 +36,22 @@ public class AnonymousDelegatingAIAgentTests
             new AgentRunResponseUpdate(ChatRole.Assistant, "Response 2")
         ];
 
-        this._innerAgentMock.Setup(x => x.RunAsync(
-                It.IsAny<IEnumerable<ChatMessage>>(),
-                It.IsAny<AgentThread?>(),
-                It.IsAny<AgentRunOptions?>(),
-                It.IsAny<CancellationToken>()))
+        this._innerAgentMock
+            .Protected()
+            .Setup<Task<AgentRunResponse>>("RunCoreAsync",
+                ItExpr.IsAny<IEnumerable<ChatMessage>>(),
+                ItExpr.IsAny<AgentThread?>(),
+                ItExpr.IsAny<AgentRunOptions?>(),
+                ItExpr.IsAny<CancellationToken>())
             .ReturnsAsync(this._testResponse);
 
-        this._innerAgentMock.Setup(x => x.RunStreamingAsync(
-                It.IsAny<IEnumerable<ChatMessage>>(),
-                It.IsAny<AgentThread?>(),
-                It.IsAny<AgentRunOptions?>(),
-                It.IsAny<CancellationToken>()))
+        this._innerAgentMock
+            .Protected()
+            .Setup<IAsyncEnumerable<AgentRunResponseUpdate>>("RunCoreStreamingAsync",
+                ItExpr.IsAny<IEnumerable<ChatMessage>>(),
+                ItExpr.IsAny<AgentThread?>(),
+                ItExpr.IsAny<AgentRunOptions?>(),
+                ItExpr.IsAny<CancellationToken>())
             .Returns(ToAsyncEnumerableAsync(this._testStreamingResponses));
     }
 
@@ -184,11 +189,14 @@ public class AnonymousDelegatingAIAgentTests
         Assert.Same(this._testOptions, capturedOptions);
         Assert.Equal(expectedCancellationToken, capturedCancellationToken);
 
-        this._innerAgentMock.Verify(x => x.RunAsync(
-            this._testMessages,
-            this._testThread,
-            this._testOptions,
-            expectedCancellationToken), Times.Once);
+        this._innerAgentMock
+            .Protected()
+            .Verify<Task<AgentRunResponse>>("RunCoreAsync",
+                Times.Once(),
+                ItExpr.Is<IEnumerable<ChatMessage>>(m => m == this._testMessages),
+                ItExpr.Is<AgentThread?>(t => t == this._testThread),
+                ItExpr.Is<AgentRunOptions?>(o => o == this._testOptions),
+                ItExpr.Is<CancellationToken>(ct => ct == expectedCancellationToken));
     }
 
     /// <summary>
@@ -458,11 +466,13 @@ public class AnonymousDelegatingAIAgentTests
                 capturedValue = asyncLocal.Value;
             });
 
-        this._innerAgentMock.Setup(x => x.RunAsync(
-                It.IsAny<IEnumerable<ChatMessage>>(),
-                It.IsAny<AgentThread?>(),
-                It.IsAny<AgentRunOptions?>(),
-                It.IsAny<CancellationToken>()))
+        this._innerAgentMock
+            .Protected()
+            .Setup<Task<AgentRunResponse>>("RunCoreAsync",
+                ItExpr.IsAny<IEnumerable<ChatMessage>>(),
+                ItExpr.IsAny<AgentThread?>(),
+                ItExpr.IsAny<AgentRunOptions?>(),
+                ItExpr.IsAny<CancellationToken>())
             .Returns(() =>
             {
                 // Verify AsyncLocal value is available in inner agent call
@@ -926,11 +936,13 @@ public class AnonymousDelegatingAIAgentTests
         var capturedTokens = new List<CancellationToken>();
 
         // Setup mock to throw OperationCanceledException when cancelled token is used
-        this._innerAgentMock.Setup(x => x.RunAsync(
-                It.IsAny<IEnumerable<ChatMessage>>(),
-                It.IsAny<AgentThread?>(),
-                It.IsAny<AgentRunOptions?>(),
-                It.Is<CancellationToken>(ct => ct.IsCancellationRequested)))
+        this._innerAgentMock
+            .Protected()
+            .Setup<Task<AgentRunResponse>>("RunCoreAsync",
+                ItExpr.IsAny<IEnumerable<ChatMessage>>(),
+                ItExpr.IsAny<AgentThread?>(),
+                ItExpr.IsAny<AgentRunOptions?>(),
+                ItExpr.Is<CancellationToken>(ct => ct.IsCancellationRequested))
             .ThrowsAsync(new OperationCanceledException());
 
         var agent = new AIAgentBuilder(this._innerAgentMock.Object)
@@ -993,11 +1005,14 @@ public class AnonymousDelegatingAIAgentTests
         Assert.Equal(expectedOrder, executionOrder);
 
         // Verify inner agent was never called
-        this._innerAgentMock.Verify(x => x.RunAsync(
-            It.IsAny<IEnumerable<ChatMessage>>(),
-            It.IsAny<AgentThread?>(),
-            It.IsAny<AgentRunOptions?>(),
-            It.IsAny<CancellationToken>()), Times.Never);
+        this._innerAgentMock
+            .Protected()
+            .Verify<Task<AgentRunResponse>>("RunCoreAsync",
+                Times.Never(),
+                ItExpr.IsAny<IEnumerable<ChatMessage>>(),
+                ItExpr.IsAny<AgentThread?>(),
+                ItExpr.IsAny<AgentRunOptions?>(),
+                ItExpr.IsAny<CancellationToken>());
     }
 
     #endregion

dotnet/tests/Microsoft.Agents.AI.UnitTests/ChatClient/ChatClientAgentTests.cs

@@ -502,6 +502,12 @@ public partial class ChatClientAgentTests
                 It.IsAny<CancellationToken>())).ReturnsAsync(new ChatResponse([new(ChatRole.Assistant, "response")]));
 
         Mock<ChatMessageStore> mockChatMessageStore = new();
+        mockChatMessageStore.Setup(s => s.InvokingAsync(
+            It.IsAny<ChatMessageStore.InvokingContext>(),
+            It.IsAny<CancellationToken>())).ReturnsAsync([new ChatMessage(ChatRole.User, "Existing Chat History")]);
+        mockChatMessageStore.Setup(s => s.InvokedAsync(
+            It.IsAny<ChatMessageStore.InvokedContext>(),
+            It.IsAny<CancellationToken>())).Returns(new ValueTask());
 
         Mock<Func<ChatClientAgentOptions.ChatMessageStoreFactoryContext, ChatMessageStore>> mockFactory = new();
         mockFactory.Setup(f => f(It.IsAny<ChatClientAgentOptions.ChatMessageStoreFactoryContext>())).Returns(mockChatMessageStore.Object);
@@ -518,7 +524,58 @@ public partial class ChatClientAgentTests
 
         // Assert
         Assert.IsType<ChatMessageStore>(thread!.MessageStore, exactMatch: false);
-        mockChatMessageStore.Verify(s => s.AddMessagesAsync(It.Is<IEnumerable<ChatMessage>>(x => x.Count() == 2), It.IsAny<CancellationToken>()), Times.Once);
+        mockService.Verify(
+            x => x.GetResponseAsync(
+                It.Is<IEnumerable<ChatMessage>>(msgs => msgs.Count() == 2 && msgs.Any(m => m.Text == "Existing Chat History") && msgs.Any(m => m.Text == "test")),
+                It.IsAny<ChatOptions>(),
+                It.IsAny<CancellationToken>()),
+            Times.Once);
+        mockChatMessageStore.Verify(s => s.InvokingAsync(
+            It.Is<ChatMessageStore.InvokingContext>(x => x.RequestMessages.Count() == 1),
+            It.IsAny<CancellationToken>()),
+            Times.Once);
+        mockChatMessageStore.Verify(s => s.InvokedAsync(
+            It.Is<ChatMessageStore.InvokedContext>(x => x.RequestMessages.Count() == 1 && x.ChatMessageStoreMessages.Count() == 1 && x.ResponseMessages!.Count() == 1),
+            It.IsAny<CancellationToken>()),
+            Times.Once);
+        mockFactory.Verify(f => f(It.IsAny<ChatClientAgentOptions.ChatMessageStoreFactoryContext>()), Times.Once);
+    }
+
+    /// <summary>
+    /// Verify that RunAsync notifies the ChatMessageStore on failure.
+    /// </summary>
+    [Fact]
+    public async Task RunAsyncNotifiesChatMessageStoreOnFailureAsync()
+    {
+        // Arrange
+        Mock<IChatClient> mockService = new();
+        mockService.Setup(
+            s => s.GetResponseAsync(
+                It.IsAny<IEnumerable<ChatMessage>>(),
+                It.IsAny<ChatOptions>(),
+                It.IsAny<CancellationToken>())).Throws(new InvalidOperationException("Test Error"));
+
+        Mock<ChatMessageStore> mockChatMessageStore = new();
+
+        Mock<Func<ChatClientAgentOptions.ChatMessageStoreFactoryContext, ChatMessageStore>> mockFactory = new();
+        mockFactory.Setup(f => f(It.IsAny<ChatClientAgentOptions.ChatMessageStoreFactoryContext>())).Returns(mockChatMessageStore.Object);
+
+        ChatClientAgent agent = new(mockService.Object, options: new()
+        {
+            ChatOptions = new() { Instructions = "test instructions" },
+            ChatMessageStoreFactory = mockFactory.Object
+        });
+
+        // Act
+        ChatClientAgentThread? thread = agent.GetNewThread() as ChatClientAgentThread;
+        await Assert.ThrowsAsync<InvalidOperationException>(() => agent.RunAsync([new(ChatRole.User, "test")], thread));
+
+        // Assert
+        Assert.IsType<ChatMessageStore>(thread!.MessageStore, exactMatch: false);
+        mockChatMessageStore.Verify(s => s.InvokedAsync(
+            It.Is<ChatMessageStore.InvokedContext>(x => x.RequestMessages.Count() == 1 && x.ResponseMessages == null && x.InvokeException!.Message == "Test Error"),
+            It.IsAny<CancellationToken>()),
+            Times.Once);
         mockFactory.Verify(f => f(It.IsAny<ChatClientAgentOptions.ChatMessageStoreFactoryContext>()), Times.Once);
     }
 
@@ -599,18 +656,18 @@ public partial class ChatClientAgentTests
         await agent.RunAsync(requestMessages, thread);
 
         // Assert
-        // Should contain: base instructions, context message, user message, base function, context function
+        // Should contain: base instructions, user message, context message, base function, context function
         Assert.Equal(2, capturedMessages.Count);
         Assert.Equal("base instructions\ncontext provider instructions", capturedInstructions);
-        Assert.Equal("context provider message", capturedMessages[0].Text);
-        Assert.Equal(ChatRole.System, capturedMessages[0].Role);
-        Assert.Equal("user message", capturedMessages[1].Text);
-        Assert.Equal(ChatRole.User, capturedMessages[1].Role);
+        Assert.Equal("user message", capturedMessages[0].Text);
+        Assert.Equal(ChatRole.User, capturedMessages[0].Role);
+        Assert.Equal("context provider message", capturedMessages[1].Text);
+        Assert.Equal(ChatRole.System, capturedMessages[1].Role);
         Assert.Equal(2, capturedTools.Count);
         Assert.Contains(capturedTools, t => t.Name == "base function");
         Assert.Contains(capturedTools, t => t.Name == "context provider function");
 
-        // Verify that the thread was updated with the input, ai context and response messages
+        // Verify that the thread was updated with the ai context provider, input and response messages
         var messageStore = Assert.IsType<InMemoryChatMessageStore>(thread!.MessageStore);
         Assert.Equal(3, messageStore.Count);
         Assert.Equal("user message", messageStore[0].Text);
@@ -2056,18 +2113,18 @@ public partial class ChatClientAgentTests
         _ = await updates.ToAgentRunResponseAsync();
 
         // Assert
-        // Should contain: base instructions, context message, user message, base function, context function
+        // Should contain: base instructions, user message, context message, base function, context function
         Assert.Equal(2, capturedMessages.Count);
         Assert.Equal("base instructions\ncontext provider instructions", capturedInstructions);
-        Assert.Equal("context provider message", capturedMessages[0].Text);
-        Assert.Equal(ChatRole.System, capturedMessages[0].Role);
-        Assert.Equal("user message", capturedMessages[1].Text);
-        Assert.Equal(ChatRole.User, capturedMessages[1].Role);
+        Assert.Equal("user message", capturedMessages[0].Text);
+        Assert.Equal(ChatRole.User, capturedMessages[0].Role);
+        Assert.Equal("context provider message", capturedMessages[1].Text);
+        Assert.Equal(ChatRole.System, capturedMessages[1].Role);
         Assert.Equal(2, capturedTools.Count);
         Assert.Contains(capturedTools, t => t.Name == "base function");
         Assert.Contains(capturedTools, t => t.Name == "context provider function");
 
-        // Verify that the thread was updated with the input, ai context and response messages
+        // Verify that the thread was updated with the input, ai context provider, and response messages
         var messageStore = Assert.IsType<InMemoryChatMessageStore>(thread!.MessageStore);
         Assert.Equal(3, messageStore.Count);
         Assert.Equal("user message", messageStore[0].Text);

dotnet/tests/Microsoft.Agents.AI.UnitTests/ChatClient/ChatClientAgent_BackgroundResponsesTests.cs

@@ -339,7 +339,7 @@ public class ChatClientAgent_BackgroundResponsesTests
         // Create a mock message store that would normally provide messages
         var mockMessageStore = new Mock<ChatMessageStore>();
         mockMessageStore
-            .Setup(ms => ms.GetMessagesAsync(It.IsAny<CancellationToken>()))
+            .Setup(ms => ms.InvokingAsync(It.IsAny<ChatMessageStore.InvokingContext>(), It.IsAny<CancellationToken>()))
             .ReturnsAsync([new(ChatRole.User, "Message from message store")]);
 
         // Create a mock AI context provider that would normally provide context
@@ -383,7 +383,7 @@ public class ChatClientAgent_BackgroundResponsesTests
 
         // Verify that message store was never called due to continuation token
         mockMessageStore.Verify(
-            ms => ms.GetMessagesAsync(It.IsAny<CancellationToken>()),
+            ms => ms.InvokingAsync(It.IsAny<ChatMessageStore.InvokingContext>(), It.IsAny<CancellationToken>()),
             Times.Never);
 
         // Verify that AI context provider was never called due to continuation token
@@ -401,7 +401,7 @@ public class ChatClientAgent_BackgroundResponsesTests
         // Create a mock message store that would normally provide messages
         var mockMessageStore = new Mock<ChatMessageStore>();
         mockMessageStore
-            .Setup(ms => ms.GetMessagesAsync(It.IsAny<CancellationToken>()))
+            .Setup(ms => ms.InvokingAsync(It.IsAny<ChatMessageStore.InvokingContext>(), It.IsAny<CancellationToken>()))
             .ReturnsAsync([new(ChatRole.User, "Message from message store")]);
 
         // Create a mock AI context provider that would normally provide context
@@ -446,7 +446,7 @@ public class ChatClientAgent_BackgroundResponsesTests
 
         // Verify that message store was never called due to continuation token
         mockMessageStore.Verify(
-            ms => ms.GetMessagesAsync(It.IsAny<CancellationToken>()),
+            ms => ms.InvokingAsync(It.IsAny<ChatMessageStore.InvokingContext>(), It.IsAny<CancellationToken>()),
             Times.Never);
 
         // Verify that AI context provider was never called due to continuation token

dotnet/tests/Microsoft.Agents.AI.UnitTests/TestAIAgent.cs

@@ -30,10 +30,10 @@ internal sealed class TestAIAgent : AIAgent
     public override AgentThread GetNewThread() =>
         this.GetNewThreadFunc();
 
-    public override Task<AgentRunResponse> RunAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default) =>
+    protected override Task<AgentRunResponse> RunCoreAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default) =>
         this.RunAsyncFunc(messages, thread, options, cancellationToken);
 
-    public override IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default) =>
+    protected override IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default) =>
         this.RunStreamingAsyncFunc(messages, thread, options, cancellationToken);
 
     public override object? GetService(Type serviceType, object? serviceKey = null) =>

dotnet/tests/Microsoft.Agents.AI.Workflows.UnitTests/AgentWorkflowBuilderTests.cs

@@ -141,11 +141,11 @@ public class AgentWorkflowBuilderTests
         public override AgentThread DeserializeThread(JsonElement serializedThread, JsonSerializerOptions? jsonSerializerOptions = null)
             => new DoubleEchoAgentThread();
 
-        public override Task<AgentRunResponse> RunAsync(
+        protected override Task<AgentRunResponse> RunCoreAsync(
             IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default) =>
             throw new NotImplementedException();
 
-        public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+        protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
             IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, [EnumeratorCancellation] CancellationToken cancellationToken = default)
         {
             await Task.Yield();
@@ -409,7 +409,7 @@ public class AgentWorkflowBuilderTests
 
     private sealed class DoubleEchoAgentWithBarrier(string name, StrongBox<TaskCompletionSource<bool>> barrier, StrongBox<int> remaining) : DoubleEchoAgent(name)
     {
-        public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+        protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
             IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, [EnumeratorCancellation] CancellationToken cancellationToken = default)
         {
             if (Interlocked.Decrement(ref remaining.Value) == 0)
@@ -419,7 +419,7 @@ public class AgentWorkflowBuilderTests
 
             await barrier.Value!.Task.ConfigureAwait(false);
 
-            await foreach (var update in base.RunStreamingAsync(messages, thread, options, cancellationToken))
+            await foreach (var update in base.RunCoreStreamingAsync(messages, thread, options, cancellationToken))
             {
                 await Task.Yield();
                 yield return update;

dotnet/tests/Microsoft.Agents.AI.Workflows.UnitTests/InProcessExecutionTests.cs

@@ -149,7 +149,7 @@ public class InProcessExecutionTests
         public override AgentThread DeserializeThread(System.Text.Json.JsonElement serializedThread,
             System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) => new SimpleTestAgentThread();
 
-        public override Task<AgentRunResponse> RunAsync(
+        protected override Task<AgentRunResponse> RunCoreAsync(
             IEnumerable<ChatMessage> messages,
             AgentThread? thread = null,
             AgentRunOptions? options = null,
@@ -160,7 +160,7 @@ public class InProcessExecutionTests
             return Task.FromResult(new AgentRunResponse(responseMessage));
         }
 
-        public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+        protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(
             IEnumerable<ChatMessage> messages,
             AgentThread? thread = null,
             AgentRunOptions? options = null,

dotnet/tests/Microsoft.Agents.AI.Workflows.UnitTests/RepresentationTests.cs

@@ -30,10 +30,10 @@ public class RepresentationTests
         public override AgentThread DeserializeThread(JsonElement serializedThread, JsonSerializerOptions? jsonSerializerOptions = null)
             => throw new NotImplementedException();
 
-        public override Task<AgentRunResponse> RunAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default) =>
+        protected override Task<AgentRunResponse> RunCoreAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default) =>
             throw new NotImplementedException();
 
-        public override IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default) =>
+        protected override IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default) =>
             throw new NotImplementedException();
     }
 

dotnet/tests/Microsoft.Agents.AI.Workflows.UnitTests/Sample/06_GroupChat_Workflow.cs

@@ -66,17 +66,17 @@ internal sealed class HelloAgent(string id = nameof(HelloAgent)) : AIAgent
     public override AgentThread DeserializeThread(JsonElement serializedThread, JsonSerializerOptions? jsonSerializerOptions = null)
         => new HelloAgentThread();
 
-    public override async Task<AgentRunResponse> RunAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
+    protected override async Task<AgentRunResponse> RunCoreAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
     {
         IEnumerable<AgentRunResponseUpdate> update = [
-            await this.RunStreamingAsync(messages, thread, options, cancellationToken)
+            await this.RunCoreStreamingAsync(messages, thread, options, cancellationToken)
                       .SingleAsync(cancellationToken)
                       .ConfigureAwait(false)];
 
         return update.ToAgentRunResponse();
     }
 
-    public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, [EnumeratorCancellation] CancellationToken cancellationToken = default)
+    protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, [EnumeratorCancellation] CancellationToken cancellationToken = default)
     {
         yield return new(ChatRole.Assistant, "Hello World!")
         {

dotnet/tests/Microsoft.Agents.AI.Workflows.UnitTests/SpecializedExecutorSmokeTests.cs

@@ -62,14 +62,14 @@ public class SpecializedExecutorSmokeTests
 
         public List<ChatMessage> Messages { get; } = Validate(messages) ?? [];
 
-        public override Task<AgentRunResponse> RunAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default) =>
+        protected override Task<AgentRunResponse> RunCoreAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default) =>
             Task.FromResult(new AgentRunResponse(this.Messages)
             {
                 AgentId = this.Id,
                 ResponseId = Guid.NewGuid().ToString("N")
             });
 
-        public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, [EnumeratorCancellation] CancellationToken cancellationToken = default)
+        protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, [EnumeratorCancellation] CancellationToken cancellationToken = default)
         {
             string responseId = Guid.NewGuid().ToString("N");
             foreach (ChatMessage message in this.Messages)

dotnet/tests/Microsoft.Agents.AI.Workflows.UnitTests/TestEchoAgent.cs

@@ -60,7 +60,7 @@ internal class TestEchoAgent(string? id = null, string? name = null, string? pre
         return [];
     }
 
-    public override Task<AgentRunResponse> RunAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
+    protected override Task<AgentRunResponse> RunCoreAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
     {
         AgentRunResponse result =
             new(this.EchoMessages(messages, thread, options).ToList())
@@ -73,7 +73,7 @@ internal class TestEchoAgent(string? id = null, string? name = null, string? pre
         return Task.FromResult(result);
     }
 
-    public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, [EnumeratorCancellation] CancellationToken cancellationToken = default)
+    protected override async IAsyncEnumerable<AgentRunResponseUpdate> RunCoreStreamingAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, [EnumeratorCancellation] CancellationToken cancellationToken = default)
     {
         string responseId = Guid.NewGuid().ToString("N");
 

dotnet/tests/OpenAIChatCompletion.IntegrationTests/OpenAIChatCompletionFixture.cs

@@ -32,7 +32,12 @@ public class OpenAIChatCompletionFixture : IChatClientAgentFixture
     {
         var typedThread = (ChatClientAgentThread)thread;
 
-        return typedThread.MessageStore is null ? [] : (await typedThread.MessageStore.GetMessagesAsync()).ToList();
+        if (typedThread.MessageStore is null)
+        {
+            return [];
+        }
+
+        return (await typedThread.MessageStore.InvokingAsync(new([]))).ToList();
     }
 
     public Task<ChatClientAgent> CreateChatClientAgentAsync(

dotnet/tests/OpenAIResponse.IntegrationTests/OpenAIResponseFixture.cs

@@ -50,7 +50,12 @@ public class OpenAIResponseFixture(bool store) : IChatClientAgentFixture
             return [.. previousMessages, responseMessage];
         }
 
-        return typedThread.MessageStore is null ? [] : (await typedThread.MessageStore.GetMessagesAsync()).ToList();
+        if (typedThread.MessageStore is null)
+        {
+            return [];
+        }
+
+        return (await typedThread.MessageStore.InvokingAsync(new([]))).ToList();
     }
 
     private static ChatMessage ConvertToChatMessage(ResponseItem item)

python/.github/instructions/python.instructions.md

@@ -1,6 +1,11 @@
 ---
 applyTo: '**/agent-framework/python/**'
 ---
+- Use `uv run` as the main entrypoint for running Python commands with all packages available.
+- Use `uv run poe <task>` for development tasks like formatting (`fmt`), linting (`lint`), type checking (`pyright`, `mypy`), and testing (`test`).
+- Use `uv run --directory packages/<package> poe <task>` to run tasks for a specific package.
+- Read [DEV_SETUP.md](../../DEV_SETUP.md) for detailed development environment setup and available poe tasks.
+- Read [CODING_STANDARD.md](../../CODING_STANDARD.md) for the project's coding standards and best practices.
 - When verifying logic with unit tests, run only the related tests, not the entire test suite.
 - For new tests and samples, review existing ones to understand the coding style and reuse it.
 - When generating new functions, always specify the function return type and parameter types.

python/CHANGELOG.md

@@ -7,9 +7,43 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.0.0b251223] - 2025-12-23
+
+### Added
+
+- **agent-framework-bedrock**: Introducing support for Bedrock-hosted models (Anthropic, Cohere, etc.) ([#2610](https://github.com/microsoft/agent-framework/pull/2610))
+- **agent-framework-core**: Added `response.created` and `response.in_progress` event process to `OpenAIBaseResponseClient` ([#2975](https://github.com/microsoft/agent-framework/pull/2975))
+- **agent-framework-foundry-local**: Introducing Foundry Local Chat Clients ([#2915](https://github.com/microsoft/agent-framework/pull/2915))
+- **samples**: Added GitHub MCP sample with PAT ([#2967](https://github.com/microsoft/agent-framework/pull/2967))
+
 ### Changed
 
-- **agent-framework-azurefunctions**: Durable Agents: platforms should use consistent entity method names (#2234)
+- **agent-framework-core**: Preserve reasoning blocks with OpenRouter ([#2950](https://github.com/microsoft/agent-framework/pull/2950))
+
+## [1.0.0b251218] - 2025-12-18
+
+### Added
+
+- **agent-framework-core**: Azure AI Agent with Bing Grounding Citations sample ([#2892](https://github.com/microsoft/agent-framework/pull/2892))
+- **agent-framework-core**: Workflow option to visualize internal executors ([#2917](https://github.com/microsoft/agent-framework/pull/2917))
+- **agent-framework-core**: Workflow cancellation sample ([#2732](https://github.com/microsoft/agent-framework/pull/2732))
+- **agent-framework-core**: Azure Managed Redis support with credential provider ([#2887](https://github.com/microsoft/agent-framework/pull/2887))
+- **agent-framework-core**: Additional arguments for Azure AI agent configuration ([#2922](https://github.com/microsoft/agent-framework/pull/2922))
+
+### Changed
+
+- **agent-framework-ollama**: Updated Ollama package version ([#2920](https://github.com/microsoft/agent-framework/pull/2920))
+- **agent-framework-ollama**: Move Ollama samples to samples getting started directory ([#2921](https://github.com/microsoft/agent-framework/pull/2921))
+- **agent-framework-core**: Cleanup and refactoring of chat clients ([#2937](https://github.com/microsoft/agent-framework/pull/2937))
+- **agent-framework-core**: Align Run ID and Thread ID casing with AG-UI TypeScript SDK ([#2948](https://github.com/microsoft/agent-framework/pull/2948))
+
+### Fixed
+
+- **agent-framework-core**: Fix Pydantic error when using Literal types for tool parameters ([#2893](https://github.com/microsoft/agent-framework/pull/2893))
+- **agent-framework-core**: Correct MCP image type conversion in `_mcp.py` ([#2901](https://github.com/microsoft/agent-framework/pull/2901))
+- **agent-framework-core**: Fix BadRequestError when using Pydantic models in response formatting ([#1843](https://github.com/microsoft/agent-framework/pull/1843))
+- **agent-framework-core**: Propagate workflow kwargs to sub-workflows via WorkflowExecutor ([#2923](https://github.com/microsoft/agent-framework/pull/2923))
+- **agent-framework-core**: Fix WorkflowAgent event handling and kwargs forwarding ([#2946](https://github.com/microsoft/agent-framework/pull/2946))
 
 ## [1.0.0b251216] - 2025-12-16
 
@@ -392,7 +426,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 For more information, see the [announcement blog post](https://devblogs.microsoft.com/foundry/introducing-microsoft-agent-framework-the-open-source-engine-for-agentic-ai-apps/).
 
-[Unreleased]: https://github.com/microsoft/agent-framework/compare/python-1.0.0b251216...HEAD
+[Unreleased]: https://github.com/microsoft/agent-framework/compare/python-1.0.0b251223...HEAD
+[1.0.0b251223]: https://github.com/microsoft/agent-framework/compare/python-1.0.0b251218...python-1.0.0b251223
+[1.0.0b251218]: https://github.com/microsoft/agent-framework/compare/python-1.0.0b251216...python-1.0.0b251218
 [1.0.0b251216]: https://github.com/microsoft/agent-framework/compare/python-1.0.0b251211...python-1.0.0b251216
 [1.0.0b251211]: https://github.com/microsoft/agent-framework/compare/python-1.0.0b251209...python-1.0.0b251211
 [1.0.0b251209]: https://github.com/microsoft/agent-framework/compare/python-1.0.0b251204...python-1.0.0b251209

python/CODING_STANDARD.md

@@ -0,0 +1,402 @@
+# Coding Standards
+
+This document describes the coding standards and conventions for the Agent Framework project.
+
+## Code Style and Formatting
+
+We use [ruff](https://github.com/astral-sh/ruff) for both linting and formatting with the following configuration:
+
+- **Line length**: 120 characters
+- **Target Python version**: 3.10+
+- **Google-style docstrings**: All public functions, classes, and modules should have docstrings following Google conventions
+
+## Function Parameter Guidelines
+
+To make the code easier to use and maintain:
+
+- **Positional parameters**: Only use for up to 3 fully expected parameters
+- **Keyword parameters**: Use for all other parameters, especially when there are multiple required parameters without obvious ordering
+- **Avoid additional imports**: Do not require the user to import additional modules to use the function, so provide string based overrides when applicable, for instance:
+```python
+def create_agent(name: str, tool_mode: ChatToolMode) -> Agent:
+    # Implementation here
+```
+Should be:
+```python
+def create_agent(name: str, tool_mode: Literal['auto', 'required', 'none'] | ChatToolMode) -> Agent:
+    # Implementation here
+    if isinstance(tool_mode, str):
+        tool_mode = ChatToolMode(tool_mode)
+```
+- **Document kwargs**: Always document how `kwargs` are used, either by referencing external documentation or explaining their purpose
+- **Separate kwargs**: When combining kwargs for multiple purposes, use specific parameters like `client_kwargs: dict[str, Any]` instead of mixing everything in `**kwargs`
+
+## Method Naming Inside Connectors
+
+When naming methods inside connectors, we have a loose preference for using the following conventions:
+- Use `_prepare_<object>_for_<purpose>` as a prefix for methods that prepare data for sending to the external service.
+- Use `_parse_<object>_from_<source>` as a prefix for methods that process data received from the external service.
+
+This is not a strict rule, but a guideline to help maintain consistency across the codebase.
+
+## Implementation Decisions
+
+### Asynchronous Programming
+
+It's important to note that most of this library is written with asynchronous in mind. The
+developer should always assume everything is asynchronous. One can use the function signature
+with either `async def` or `def` to understand if something is asynchronous or not.
+
+### Attributes vs Inheritance
+
+Prefer attributes over inheritance when parameters are mostly the same:
+
+```python
+# ✅ Preferred - using attributes
+from agent_framework import ChatMessage
+
+user_msg = ChatMessage(role="user", content="Hello, world!")
+asst_msg = ChatMessage(role="assistant", content="Hello, world!")
+
+# ❌ Not preferred - unnecessary inheritance
+from agent_framework import UserMessage, AssistantMessage
+
+user_msg = UserMessage(content="Hello, world!")
+asst_msg = AssistantMessage(content="Hello, world!")
+```
+
+### Logging
+
+Use the centralized logging system:
+
+```python
+from agent_framework import get_logger
+
+# For main package
+logger = get_logger()
+
+# For subpackages
+logger = get_logger('agent_framework.azure')
+```
+
+**Do not use** direct logging module imports:
+```python
+# ❌ Avoid this
+import logging
+logger = logging.getLogger(__name__)
+```
+
+### Import Structure
+
+The package follows a flat import structure:
+
+- **Core**: Import directly from `agent_framework`
+  ```python
+  from agent_framework import ChatAgent, ai_function
+  ```
+
+- **Components**: Import from `agent_framework.<component>`
+  ```python
+  from agent_framework.observability import enable_instrumentation, configure_otel_providers
+  ```
+
+- **Connectors**: Import from `agent_framework.<vendor/platform>`
+  ```python
+  from agent_framework.openai import OpenAIChatClient
+  from agent_framework.azure import AzureOpenAIChatClient
+  ```
+
+## Package Structure
+
+The project uses a monorepo structure with separate packages for each connector/extension:
+
+```plaintext
+python/
+├── pyproject.toml              # Root package (agent-framework) depends on agent-framework-core[all]
+├── samples/                    # Sample code and examples
+├── packages/
+│   ├── core/                   # agent-framework-core - Core abstractions and implementations
+│   │   ├── pyproject.toml      # Defines [all] extra that includes all connector packages
+│   │   ├── tests/              # Tests for core package
+│   │   └── agent_framework/
+│   │       ├── __init__.py     # Public API exports
+│   │       ├── _agents.py      # Agent implementations
+│   │       ├── _clients.py     # Chat client protocols and base classes
+│   │       ├── _tools.py       # Tool definitions
+│   │       ├── _types.py       # Type definitions
+│   │       ├── _logging.py     # Logging utilities
+│   │       │
+│   │       │   # Provider folders - lazy load from connector packages
+│   │       ├── openai/         # OpenAI clients (built into core)
+│   │       ├── azure/          # Lazy loads from azure-ai, azure-ai-search, azurefunctions
+│   │       ├── anthropic/      # Lazy loads from agent-framework-anthropic
+│   │       ├── ollama/         # Lazy loads from agent-framework-ollama
+│   │       ├── a2a/            # Lazy loads from agent-framework-a2a
+│   │       ├── ag_ui/          # Lazy loads from agent-framework-ag-ui
+│   │       ├── chatkit/        # Lazy loads from agent-framework-chatkit
+│   │       ├── declarative/    # Lazy loads from agent-framework-declarative
+│   │       ├── devui/          # Lazy loads from agent-framework-devui
+│   │       ├── mem0/           # Lazy loads from agent-framework-mem0
+│   │       └── redis/          # Lazy loads from agent-framework-redis
+│   │
+│   ├── azure-ai/               # agent-framework-azure-ai
+│   │   ├── pyproject.toml
+│   │   ├── tests/
+│   │   └── agent_framework_azure_ai/
+│   │       ├── __init__.py     # Public exports
+│   │       ├── _chat_client.py # AzureAIClient implementation
+│   │       ├── _client.py      # AzureAIAgentClient implementation
+│   │       ├── _shared.py      # AzureAISettings and shared utilities
+│   │       └── py.typed        # PEP 561 marker
+│   ├── anthropic/              # agent-framework-anthropic
+│   ├── bedrock/                # agent-framework-bedrock
+│   ├── ollama/                 # agent-framework-ollama
+│   └── ...                     # Other connector packages
+```
+
+### Lazy Loading Pattern
+
+Provider folders in the core package use `__getattr__` to lazy load classes from their respective connector packages. This allows users to import from a consistent location while only loading dependencies when needed:
+
+```python
+# In agent_framework/azure/__init__.py
+_IMPORTS: dict[str, tuple[str, str]] = {
+    "AzureAIAgentClient": ("agent_framework_azure_ai", "agent-framework-azure-ai"),
+    # ...
+}
+
+def __getattr__(name: str) -> Any:
+    if name in _IMPORTS:
+        import_path, package_name = _IMPORTS[name]
+        try:
+            return getattr(importlib.import_module(import_path), name)
+        except ModuleNotFoundError as exc:
+            raise ModuleNotFoundError(
+                f"The package {package_name} is required to use `{name}`. "
+                f"Install it with: pip install {package_name}"
+            ) from exc
+```
+
+### Adding a New Connector Package
+
+**Important:** Do not create a new package unless there is an issue that has been reviewed and approved by the core team.
+
+#### Initial Release (Preview Phase)
+
+For the first release of a new connector package:
+
+1. Create a new directory under `packages/` (e.g., `packages/my-connector/`)
+2. Add the package to `tool.uv.sources` in the root `pyproject.toml`
+3. Include samples inside the package itself (e.g., `packages/my-connector/samples/`)
+4. **Do NOT** add the package to the `[all]` extra in `packages/core/pyproject.toml`
+5. **Do NOT** create lazy loading in core yet
+
+#### Promotion to Stable
+
+After the package has been released and gained a measure of confidence:
+
+1. Move samples from the package to the root `samples/` folder
+2. Add the package to the `[all]` extra in `packages/core/pyproject.toml`
+3. Create a provider folder in `agent_framework/` with lazy loading `__init__.py`
+
+### Installation Options
+
+Connectors are distributed as separate packages and are not imported by default in the core package. Users install the specific connectors they need:
+
+```bash
+# Install core only
+pip install agent-framework-core
+
+# Install core with all connectors
+pip install agent-framework-core[all]
+# or (equivalently):
+pip install agent-framework
+
+# Install specific connector
+pip install agent-framework-azure-ai
+```
+
+## Documentation
+
+Each file should have a single first line containing: # Copyright (c) Microsoft. All rights reserved.
+
+We follow the [Google Docstring](https://github.com/google/styleguide/blob/gh-pages/pyguide.md#383-functions-and-methods) style guide for functions and methods.
+They are currently not checked for private functions (functions starting with '_').
+
+They should contain:
+
+- Single line explaining what the function does, ending with a period.
+- If necessary to further explain the logic a newline follows the first line and then the explanation is given.
+- The following three sections are optional, and if used should be separated by a single empty line.
+- Arguments are then specified after a header called `Args:`, with each argument being specified in the following format:
+  - `arg_name`: Explanation of the argument.
+    - if a longer explanation is needed for a argument, it should be placed on the next line, indented by 4 spaces.
+    - Type and default values do not have to be specified, they will be pulled from the definition.
+- Returns are specified after a header called `Returns:` or `Yields:`, with the return type and explanation of the return value.
+- Keyword arguments are specified after a header called `Keyword Args:`, with each argument being specified in the same format as `Args:`.
+- A header for exceptions can be added, called `Raises:`, but should only be used for:
+  - Agent Framework specific exceptions (e.g., `ServiceInitializationError`)
+  - Base exceptions that might be unexpected in the context
+  - Obvious exceptions like `ValueError` or `TypeError` do not need to be documented
+  - Format: `ExceptionType`: Explanation of the exception.
+  - If a longer explanation is needed, it should be placed on the next line, indented by 4 spaces.
+- Code examples can be added using the `Examples:` header followed by `.. code-block:: python` directive.
+
+Putting them all together, gives you at minimum this:
+
+```python
+def equal(arg1: str, arg2: str) -> bool:
+    """Compares two strings and returns True if they are the same."""
+    ...
+```
+
+Or a complete version of this:
+
+```python
+def equal(arg1: str, arg2: str) -> bool:
+    """Compares two strings and returns True if they are the same.
+
+    Here is extra explanation of the logic involved.
+
+    Args:
+        arg1: The first string to compare.
+        arg2: The second string to compare.
+
+    Returns:
+        True if the strings are the same, False otherwise.
+    """
+```
+
+A more complete example with keyword arguments and code samples:
+
+```python
+def create_client(
+    model_id: str | None = None,
+    *,
+    timeout: float | None = None,
+    env_file_path: str | None = None,
+    **kwargs: Any,
+) -> Client:
+    """Create a new client with the specified configuration.
+
+    Args:
+        model_id: The model ID to use. If not provided,
+            it will be loaded from settings.
+
+    Keyword Args:
+        timeout: Optional timeout for requests.
+        env_file_path: If provided, settings are read from this file.
+        kwargs: Additional keyword arguments passed to the underlying client.
+
+    Returns:
+        A configured client instance.
+
+    Raises:
+        ValueError: If the model_id is invalid.
+
+    Examples:
+
+        .. code-block:: python
+
+            # Create a client with default settings:
+            client = create_client(model_id="gpt-4o")
+
+            # Or load from environment:
+            client = create_client(env_file_path=".env")
+    """
+    ...
+```
+
+Use Google-style docstrings for all public APIs:
+
+```python
+def create_agent(name: str, chat_client: ChatClientProtocol) -> Agent:
+    """Create a new agent with the specified configuration.
+
+    Args:
+        name: The name of the agent.
+        chat_client: The chat client to use for communication.
+
+    Returns:
+        True if the strings are the same, False otherwise.
+
+    Raises:
+        ValueError: If one of the strings is empty.
+    """
+    ...
+```
+
+If in doubt, use the link above to read much more considerations of what to do and when, or use common sense.
+
+## Performance considerations
+
+### Cache Expensive Computations
+
+Think about caching where appropriate. Cache the results of expensive operations that are called repeatedly with the same inputs:
+
+```python
+# ✅ Preferred - cache expensive computations
+class AIFunction:
+    def __init__(self, ...):
+        self._cached_parameters: dict[str, Any] | None = None
+
+    def parameters(self) -> dict[str, Any]:
+        """Return the JSON schema for the function's parameters.
+
+        The result is cached after the first call for performance.
+        """
+        if self._cached_parameters is None:
+            self._cached_parameters = self.input_model.model_json_schema()
+        return self._cached_parameters
+
+# ❌ Avoid - recalculating every time
+def parameters(self) -> dict[str, Any]:
+    return self.input_model.model_json_schema()
+```
+
+### Prefer Attribute Access Over isinstance()
+
+When checking types in hot paths, prefer checking a `type` attribute (fast string comparison) over `isinstance()` (slower due to method resolution order traversal):
+
+```python
+# ✅ Preferred - use match/case with type attribute (faster)
+match content.type:
+    case "function_call":
+        # handle function call
+    case "usage":
+        # handle usage
+    case _:
+        # handle other types
+
+# ❌ Avoid in hot paths - isinstance() is slower
+if isinstance(content, FunctionCallContent):
+    # handle function call
+elif isinstance(content, UsageContent):
+    # handle usage
+```
+
+For inline conditionals:
+
+```python
+# ✅ Preferred - type attribute comparison
+result = value if content.type == "function_call" else other
+
+# ❌ Avoid - isinstance() in hot paths
+result = value if isinstance(content, FunctionCallContent) else other
+```
+
+### Avoid Redundant Serialization
+
+When the same data needs to be used in multiple places, compute it once and reuse it:
+
+```python
+# ✅ Preferred - reuse computed representation
+otel_message = _to_otel_message(message)
+otel_messages.append(otel_message)
+logger.info(otel_message, extra={...})
+
+# ❌ Avoid - computing the same thing twice
+otel_messages.append(_to_otel_message(message)) # this already serializes
+message_data = message.to_dict(exclude_none=True)  # and this does so again!
+logger.info(message_data, extra={...})
+```

python/DEV_SETUP.md

@@ -4,6 +4,8 @@ This document describes how to setup your environment with Python and uv,
 if you're working on new features or a bug fix for Agent Framework, or simply
 want to run the tests included.
 
+For coding standards and conventions, see [CODING_STANDARD.md](CODING_STANDARD.md).
+
 ## System setup
 
 We are using a tool called [poethepoet](https://github.com/nat-n/poethepoet) for task management and [uv](https://github.com/astral-sh/uv) for dependency management. At the [end of this document](#available-poe-tasks), you will find the available Poe tasks.
@@ -117,51 +119,6 @@ from agent_framework.openai import OpenAIChatClient
 chat_client = OpenAIChatClient(env_file_path="openai.env")
 ```
 
-
-## Coding Standards
-
-### Code Style and Formatting
-
-We use [ruff](https://github.com/astral-sh/ruff) for both linting and formatting with the following configuration:
-
-- **Line length**: 120 characters
-- **Target Python version**: 3.10+
-- **Google-style docstrings**: All public functions, classes, and modules should have docstrings following Google conventions
-
-### Function Parameter Guidelines
-
-To make the code easier to use and maintain:
-
-- **Positional parameters**: Only use for up to 3 fully expected parameters
-- **Keyword parameters**: Use for all other parameters, especially when there are multiple required parameters without obvious ordering
-- **Avoid additional imports**: Do not require the user to import additional modules to use the function, so provide string based overrides when applicable, for instance:
-```python
-def create_agent(name: str, tool_mode: ChatToolMode) -> Agent:
-    # Implementation here
-```
-Should be:
-```python
-def create_agent(name: str, tool_mode: Literal['auto', 'required', 'none'] | ChatToolMode) -> Agent:
-    # Implementation here
-    if isinstance(tool_mode, str):
-        tool_mode = ChatToolMode(tool_mode)
-```
-- **Document kwargs**: Always document how `kwargs` are used, either by referencing external documentation or explaining their purpose
-- **Separate kwargs**: When combining kwargs for multiple purposes, use specific parameters like `client_kwargs: dict[str, Any]` instead of mixing everything in `**kwargs`
-
-Example:
-```python
-chat_completion = OpenAIChatClient(env_file_path="openai.env")
-```
-
-# Method naming inside connectors
-
-When naming methods inside connectors, we have a loose preference for using the following conventions:
-- Use `_prepare_<object>_for_<purpose>` as a prefix for methods that prepare data for sending to the external service.
-- Use `_parse_<object>_from_<source>` as a prefix for methods that process data received from the external service.
-
-This is not a strict rule, but a guideline to help maintain consistency across the codebase.
-
 ## Tests
 
 All the tests are located in the `tests` folder of each package. There are tests that are marked with a `@skip_if_..._integration_tests_disabled` decorator, these are integration tests that require an external service to be running, like OpenAI or Azure OpenAI.
@@ -179,264 +136,6 @@ uv run poe --directory packages/core test
 
 These commands also output the coverage report.
 
-## Implementation Decisions
-
-### Asynchronous programming
-
-It's important to note that most of this library is written with asynchronous in mind. The
-developer should always assume everything is asynchronous. One can use the function signature
-with either `async def` or `def` to understand if something is asynchronous or not.
-
-### Documentation
-
-Each file should have a single first line containing: # Copyright (c) Microsoft. All rights reserved.
-
-We follow the [Google Docstring](https://github.com/google/styleguide/blob/gh-pages/pyguide.md#383-functions-and-methods) style guide for functions and methods.
-They are currently not checked for private functions (functions starting with '_').
-
-They should contain:
-
-- Single line explaining what the function does, ending with a period.
-- If necessary to further explain the logic a newline follows the first line and then the explanation is given.
-- The following three sections are optional, and if used should be separated by a single empty line.
-- Arguments are then specified after a header called `Args:`, with each argument being specified in the following format:
-  - `arg_name`: Explanation of the argument.
-    - if a longer explanation is needed for a argument, it should be placed on the next line, indented by 4 spaces.
-    - Type and default values do not have to be specified, they will be pulled from the definition.
-- Returns are specified after a header called `Returns:` or `Yields:`, with the return type and explanation of the return value.
-- Finally, a header for exceptions can be added, called `Raises:`, with each exception being specified in the following format:
-  - `ExceptionType`: Explanation of the exception.
-  - if a longer explanation is needed for a exception, it should be placed on the next line, indented by 4 spaces.
-
-Putting them all together, gives you at minimum this:
-
-```python
-def equal(arg1: str, arg2: str) -> bool:
-    """Compares two strings and returns True if they are the same."""
-    ...
-```
-
-Or a complete version of this:
-
-```python
-def equal(arg1: str, arg2: str) -> bool:
-    """Compares two strings and returns True if they are the same.
-
-    Here is extra explanation of the logic involved.
-
-    Args:
-        arg1: The first string to compare.
-        arg2: The second string to compare.
-
-    Returns:
-        True if the strings are the same, False otherwise.
-    """
-```
-
-### Attributes vs Inheritance
-
-Prefer attributes over inheritance when parameters are mostly the same:
-
-```python
-# ✅ Preferred - using attributes
-from agent_framework import ChatMessage
-
-user_msg = ChatMessage(role="user", content="Hello, world!")
-asst_msg = ChatMessage(role="assistant", content="Hello, world!")
-
-# ❌ Not preferred - unnecessary inheritance
-from agent_framework import UserMessage, AssistantMessage
-
-user_msg = UserMessage(content="Hello, world!")
-asst_msg = AssistantMessage(content="Hello, world!")
-```
-
-### Logging
-
-Use the centralized logging system:
-
-```python
-from agent_framework import get_logger
-
-# For main package
-logger = get_logger()
-
-# For subpackages
-logger = get_logger('agent_framework.azure')
-```
-
-**Do not use** direct logging module imports:
-```python
-# ❌ Avoid this
-import logging
-logger = logging.getLogger(__name__)
-```
-
-### Import Structure
-
-The package follows a flat import structure:
-
-- **Core**: Import directly from `agent_framework`
-  ```python
-  from agent_framework import ChatAgent, ai_function
-  ```
-
-- **Components**: Import from `agent_framework.<component>`
-  ```python
-  from agent_framework.vector_data import VectorStoreModel
-  from agent_framework.guardrails import ContentFilter
-  ```
-
-- **Connectors**: Import from `agent_framework.<vendor/platform>`
-  ```python
-  from agent_framework.openai import OpenAIChatClient
-  from agent_framework.azure import AzureOpenAIChatClient
-  ```
-
-## Testing
-
-### Running Tests
-
-```bash
-# Run all tests with coverage
-uv run poe test
-
-# Run specific test file
-uv run pytest tests/test_agents.py
-
-# Run with verbose output
-uv run pytest -v
-```
-
-### Test Coverage
-
-- Target: Minimum 80% test coverage for all packages
-- Coverage reports are generated automatically during test runs
-- Tests should be in corresponding `test_*.py` files in the `tests/` directory
-
-## Documentation
-
-### Building Documentation
-
-```bash
-# Build documentation
-uv run poe docs-build
-
-# Serve documentation locally with auto-reload
-uv run poe docs-serve
-
-# Check documentation for warnings
-uv run poe docs-check
-```
-
-### Docstring Style
-
-Use Google-style docstrings for all public APIs:
-
-```python
-def create_agent(name: str, chat_client: ChatClientProtocol) -> Agent:
-    """Create a new agent with the specified configuration.
-
-    Args:
-        name: The name of the agent.
-        chat_client: The chat client to use for communication.
-
-    Returns:
-        True if the strings are the same, False otherwise.
-
-    Raises:
-        ValueError: If one of the strings is empty.
-    """
-    ...
-```
-
-If in doubt, use the link above to read much more considerations of what to do and when, or use common sense.
-
-## Coding standards
-
-```plaintext
-agent_framework/
-├── __init__.py              # Tier 0: Core components
-├── _agents.py              # Agent implementations
-├── _tools.py               # Tool definitions
-├── _models.py              # Type definitions
-├── _logging.py             # Logging utilities
-├── context_providers.py    # Tier 1: Context providers
-├── guardrails.py          # Tier 1: Guardrails and filters
-├── vector_data.py         # Tier 1: Vector stores
-├── workflows.py           # Tier 1: Multi-agent orchestration
-└── azure/                 # Tier 2: Azure connectors (lazy loaded)
-    └── __init__.py        # Imports from agent-framework-azure
-```
-
-### Pydantic and Serialization
-
-This section describes how one can enable serialization for their class using Pydantic.
-For more info you can refer to the [Pydantic Documentation](https://docs.pydantic.dev/latest/).
-
-#### Upgrading existing classes to use Pydantic
-
-Let's take the following example:
-
-```python
-class A:
-    def __init__(self, a: int, b: float, c: List[float], d: dict[str, tuple[float, str]] = {}):
-        self.a = a
-        self.b = b
-        self.c = c
-        self.d = d
-```
-
-You would convert this to a Pydantic class by sub-classing from the `AFBaseModel` class.
-
-```python
-from pydantic import Field
-from ._pydantic import AFBaseModel
-
-class A(AFBaseModel):
-    # The notation for the fields is similar to dataclasses.
-    a: int
-    b: float
-    c: list[float]
-    # Only, instead of using dataclasses.field, you would use pydantic.Field
-    d: dict[str, tuple[float, str]] = Field(default_factory=dict)
-```
-
-#### Classes with data that need to be serialized, and some of them are Generic types
-
-Let's take the following example:
-
-```python
-from typing import TypeVar
-
-T1 = TypeVar("T1")
-T2 = TypeVar("T2", bound=<some class>)
-
-class A:
-    def __init__(a: int, b: T1, c: T2):
-        self.a = a
-        self.b = b
-        self.c = c
-```
-
-You can use the `AFBaseModel` to convert these to pydantic serializable classes.
-
-```python
-from typing import Generic, TypeVar
-
-from ._pydantic import AFBaseModel
-
-T1 = TypeVar("T1")
-T2 = TypeVar("T2", bound=<some class>)
-
-class A(AFBaseModel, Generic[T1, T2]):
-    # T1 and T2 must be specified in the Generic argument otherwise, pydantic will
-    # NOT be able to serialize this class
-    a: int
-    b: T1
-    c: T2
-```
-
 ## Code quality checks
 
 To run the same checks that run during a commit and the GitHub Action `Python Code Quality`, you can use this command, from the [python](../python) folder:
@@ -497,7 +196,7 @@ and then you can run the following tasks:
 uv sync --all-extras --dev
 ```
 
-After this initial setup, you can use the following tasks to manage your development environment, it is adviced to use the following setup command since that also installs the pre-commit hooks.
+After this initial setup, you can use the following tasks to manage your development environment. It is advised to use the following setup command since that also installs the pre-commit hooks.
 
 #### `setup`
 Set up the development environment with a virtual environment, install dependencies and pre-commit hooks:
@@ -555,64 +254,6 @@ Run MyPy type checking:
 uv run poe mypy
 ```
 
-### Testing
-
-#### `test`
-Run unit tests with coverage:
-```bash
-uv run poe test
-```
-
-### Documentation
-
-#### `docs-install`
-Install including the documentation tools:
-```bash
-uv run poe docs-install
-```
-
-#### `docs-clean`
-Remove the docs build directory:
-```bash
-uv run poe docs-clean
-```
-
-#### `docs-build`
-Build the documentation:
-```bash
-uv run poe docs-build
-```
-
-#### `docs-full`
-Build the packages, clean and build the documentation:
-```bash
-uv run poe docs-full
-```
-
-#### `docs-rebuild`
-Clean and build the documentation:
-```bash
-uv run poe docs-rebuild
-```
-
-#### `docs-full-install`
-Install the docs dependencies, build the packages, clean and build the documentation:
-```bash
-uv run poe docs-full-install
-```
-
-#### `docs-debug`
-Build the documentation with debug information:
-```bash
-uv run poe docs-debug
-```
-
-#### `docs-rebuild-debug`
-Clean and build the documentation with debug information:
-```bash
-uv run poe docs-rebuild-debug
-```
-
 ### Code Validation
 
 #### `markdown-code-lint`
@@ -621,37 +262,66 @@ Lint markdown code blocks:
 uv run poe markdown-code-lint
 ```
 
-#### `samples-code-check`
-Run type checking on samples:
-```bash
-uv run poe samples-code-check
-```
-
 ### Comprehensive Checks
 
 #### `check`
-Run all quality checks (format, lint, pyright, mypy, test, markdown lint, samples check):
+Run all quality checks (format, lint, pyright, mypy, test, markdown lint):
 ```bash
 uv run poe check
 ```
 
-#### `pre-commit-check`
-Run pre-commit specific checks (all of the above, excluding `mypy`):
+### Testing
+
+#### `test`
+Run unit tests with coverage by invoking the `test` task in each package sequentially:
 ```bash
-uv run poe pre-commit-check
+uv run poe test
 ```
 
-### Building
+To run tests for a specific package only, use the `--directory` flag:
+```bash
+# Run tests for the core package
+uv run --directory packages/core poe test
+
+# Run tests for the azure-ai package
+uv run --directory packages/azure-ai poe test
+```
+
+#### `all-tests`
+Run all tests in a single pytest invocation across all packages in parallel (excluding lab and devui). This is faster than `test` as it uses pytest's parallel execution:
+```bash
+uv run poe all-tests
+```
+
+#### `all-tests-cov`
+Same as `all-tests` but with coverage reporting enabled:
+```bash
+uv run poe all-tests-cov
+```
+
+### Building and Publishing
 
 #### `build`
-Build the package:
+Build all packages:
 ```bash
 uv run poe build
 ```
 
+#### `clean-dist`
+Clean the dist directories:
+```bash
+uv run poe clean-dist
+```
+
+#### `publish`
+Publish packages to PyPI:
+```bash
+uv run poe publish
+```
+
 ## Pre-commit Hooks
 
-You can also run all checks using pre-commit directly:
+Pre-commit hooks run automatically on commit and execute a subset of the checks on changed files only. You can also run all checks using pre-commit directly:
 
 ```bash
 uv run pre-commit run -a

python/packages/a2a/pyproject.toml

@@ -4,7 +4,7 @@ description = "A2A integration for Microsoft Agent Framework."
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.0b251216"
+version = "1.0.0b251223"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"

python/packages/ag-ui/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agent-framework-ag-ui"
-version = "1.0.0b251216"
+version = "1.0.0b251223"
 description = "AG-UI protocol integration for Agent Framework"
 readme = "README.md"
 license-files = ["LICENSE"]

python/packages/anthropic/pyproject.toml

@@ -4,7 +4,7 @@ description = "Anthropic integration for Microsoft Agent Framework."
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.0b251216"
+version = "1.0.0b251223"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"

python/packages/azure-ai-search/pyproject.toml

@@ -4,7 +4,7 @@ description = "Azure AI Search integration for Microsoft Agent Framework."
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.0b251216"
+version = "1.0.0b251223"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"

python/packages/azure-ai/agent_framework_azure_ai/_client.py

@@ -2,7 +2,7 @@
 
 import sys
 from collections.abc import Mapping, MutableSequence
-from typing import Any, ClassVar, TypeVar
+from typing import Any, ClassVar, TypeVar, cast
 
 from agent_framework import (
     AGENT_FRAMEWORK_USER_AGENT,
@@ -379,6 +379,15 @@ class AzureAIClient(OpenAIBaseResponsesClient):
         """Take ChatOptions and create the specific options for Azure AI."""
         prepared_messages, instructions = self._prepare_messages_for_azure_ai(messages)
         run_options = await super()._prepare_options(prepared_messages, chat_options, **kwargs)
+
+        # WORKAROUND: Azure AI Projects 'create responses' API has schema divergence from OpenAI's
+        # Responses API. Azure requires 'type' at item level and 'annotations' in content items.
+        # See: https://github.com/Azure/azure-sdk-for-python/issues/44493
+        # See: https://github.com/microsoft/agent-framework/issues/2926
+        # TODO(agent-framework#2926): Remove this workaround when Azure SDK aligns with OpenAI schema.
+        if "input" in run_options and isinstance(run_options["input"], list):
+            run_options["input"] = self._transform_input_for_azure_ai(cast(list[dict[str, Any]], run_options["input"]))
+
         if not self._is_application_endpoint:
             # Application-scoped response APIs do not support "agent" property.
             agent_reference = await self._get_agent_reference_or_create(run_options, instructions)
@@ -393,6 +402,44 @@ class AzureAIClient(OpenAIBaseResponsesClient):
 
         return run_options
 
+    def _transform_input_for_azure_ai(self, input_items: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        """Transform input items to match Azure AI Projects expected schema.
+
+        WORKAROUND: Azure AI Projects 'create responses' API expects a different schema than OpenAI's
+        Responses API. Azure requires 'type' at the item level, and requires 'annotations'
+        only for output_text content items (assistant messages), not for input_text content items
+        (user messages). This helper adapts the OpenAI-style input to the Azure schema.
+
+        See: https://github.com/Azure/azure-sdk-for-python/issues/44493
+        TODO(agent-framework#2926): Remove when Azure SDK aligns with OpenAI schema.
+        """
+        transformed: list[dict[str, Any]] = []
+        for item in input_items:
+            new_item: dict[str, Any] = dict(item)
+
+            # Add 'type': 'message' at item level for role-based items
+            if "role" in new_item and "type" not in new_item:
+                new_item["type"] = "message"
+
+            # Add 'annotations' only to output_text content items (assistant messages)
+            # User messages (input_text) do NOT support annotations in Azure AI
+            if "content" in new_item and isinstance(new_item["content"], list):
+                new_content: list[dict[str, Any] | Any] = []
+                for content_item in new_item["content"]:
+                    if isinstance(content_item, dict):
+                        new_content_item: dict[str, Any] = dict(content_item)
+                        # Only add annotations to output_text (assistant content)
+                        if new_content_item.get("type") == "output_text" and "annotations" not in new_content_item:
+                            new_content_item["annotations"] = []
+                        new_content.append(new_content_item)
+                    else:
+                        new_content.append(content_item)
+                new_item["content"] = new_content
+
+            transformed.append(new_item)
+
+        return transformed
+
     @override
     def _get_current_conversation_id(self, chat_options: ChatOptions, **kwargs: Any) -> str | None:
         """Get the current conversation ID from chat options or kwargs."""