minor tweaks

* Fiz AzureAIClient tool call bug

* Address copilot feedback

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,8 @@
+blank_issues_enabled: true
+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 about Agent Framework.

.github/ISSUE_TEMPLATE/dotnet-issue.yml

@@ -0,0 +1,70 @@
+name: .NET Bug Report
+description: Report a bug in the Agent Framework .NET SDK
+title: ".NET: [Bug]: "
+labels: ["bug", ".NET"]
+type: bug
+body:
+  - type: textarea
+    id: description
+    attributes:
+      label: Description
+      description: Please provide a clear and detailed description of the bug.
+      placeholder: |
+        - What happened?
+        - What did you expect to happen?
+        - Steps to reproduce the issue
+    validations:
+      required: true
+
+  - type: textarea
+    id: code-sample
+    attributes:
+      label: Code Sample
+      description: If applicable, provide a minimal code sample that demonstrates the issue.
+      placeholder: |
+        ```csharp
+        // Your code here
+        ```
+      render: markdown
+    validations:
+      required: false
+
+  - type: textarea
+    id: error-messages
+    attributes:
+      label: Error Messages / Stack Traces
+      description: Include any error messages or stack traces you received.
+      placeholder: |
+        ```
+        Paste error messages or stack traces here
+        ```
+      render: markdown
+    validations:
+      required: false
+
+  - type: input
+    id: dotnet-packages
+    attributes:
+      label: Package Versions
+      description: List the Microsoft.Agents.* packages and versions you are using
+      placeholder: "e.g., Microsoft.Agents.AI.Abstractions: 1.0.0, Microsoft.Agents.AI.OpenAI: 1.0.0"
+    validations:
+      required: true
+
+  - type: input
+    id: dotnet-version
+    attributes:
+      label: .NET Version
+      description: What version of .NET are you using?
+      placeholder: "e.g., .NET 8.0"
+    validations:
+      required: false
+
+  - type: textarea
+    id: additional-context
+    attributes:
+      label: Additional Context
+      description: Add any other context or screenshots that might be helpful.
+      placeholder: "Any additional information..."
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/feature-request.yml

@@ -0,0 +1,51 @@
+name: Feature Request
+description: Request a new feature for Microsoft Agent Framework
+title: "[Feature]: "
+type: feature
+body:
+
+  - type: textarea
+    id: description
+    attributes:
+      label: Description
+      description: Please describe the feature you'd like and why it would be useful.
+      placeholder: |
+        Describe the feature you're requesting:
+        - What problem does it solve?
+        - What would the expected behavior be?
+        - Are there any alternatives you've considered?
+    validations:
+      required: true
+
+  - type: textarea
+    id: code-sample
+    attributes:
+      label: Code Sample
+      description: If applicable, provide a code sample showing how you'd like to use this feature.
+      placeholder: |
+        ```python
+        # Your code here
+        ```
+
+        or
+
+        ```csharp
+        // Your code here
+        ```
+      render: markdown
+    validations:
+      required: false
+
+  - type: dropdown
+    id: language
+    attributes:
+      label: Language/SDK
+      description: Which language/SDK does this feature apply to?
+      options:
+        - Both
+        - .NET
+        - Python
+        - Other / Not Applicable
+      default: 0
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/python-issue.yml

@@ -0,0 +1,70 @@
+name: Python Bug Report
+description: Report a bug in the Agent Framework Python SDK
+title: "Python: [Bug]: "
+labels: ["bug", "Python"]
+type: bug
+body:
+  - type: textarea
+    id: description
+    attributes:
+      label: Description
+      description: Please provide a clear and detailed description of the bug.
+      placeholder: |
+        - What happened?
+        - What did you expect to happen?
+        - Steps to reproduce the issue
+    validations:
+      required: true
+
+  - type: textarea
+    id: code-sample
+    attributes:
+      label: Code Sample
+      description: If applicable, provide a minimal code sample that demonstrates the issue.
+      placeholder: |
+        ```python
+        # Your code here
+        ```
+      render: markdown
+    validations:
+      required: false
+
+  - type: textarea
+    id: error-messages
+    attributes:
+      label: Error Messages / Stack Traces
+      description: Include any error messages or stack traces you received.
+      placeholder: |
+        ```
+        Paste error messages or stack traces here
+        ```
+      render: markdown
+    validations:
+      required: false
+
+  - type: input
+    id: python-packages
+    attributes:
+      label: Package Versions
+      description: List the agent-framework-* packages and versions you are using
+      placeholder: "e.g., agent-framework-core: 1.0.0, agent-framework-azure-ai: 1.0.0"
+    validations:
+      required: true
+
+  - type: input
+    id: python-version
+    attributes:
+      label: Python Version
+      description: What version of Python are you using?
+      placeholder: "e.g., Python 3.11"
+    validations:
+      required: false
+
+  - type: textarea
+    id: additional-context
+    attributes:
+      label: Additional Context
+      description: Add any other context or screenshots that might be helpful.
+      placeholder: "Any additional information..."
+    validations:
+      required: false

.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)

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

@@ -11,7 +11,7 @@
   </PropertyGroup>
   <ItemGroup>
     <!-- Aspire.* -->
-    <PackageVersion Include="Anthropic" Version="12.0.0" />
+    <PackageVersion Include="Anthropic" Version="12.0.1" />
     <PackageVersion Include="Anthropic.Foundry" Version="0.1.0" />
     <PackageVersion Include="Aspire.Azure.AI.OpenAI" Version="13.0.0-preview.1.25560.3" />
     <PackageVersion Include="Aspire.Hosting.AppHost" Version="$(AspireAppHostSdkVersion)" />
@@ -26,7 +26,7 @@
     <PackageVersion Include="Azure.Identity" Version="1.17.1" />
     <PackageVersion Include="Azure.Monitor.OpenTelemetry.Exporter" Version="1.4.0" />
     <!-- Google Gemini  -->
-    <PackageVersion Include="Google.GenAI" Version="0.6.0" />
+    <PackageVersion Include="Google.GenAI" Version="0.9.0" />
     <PackageVersion Include="Mscc.GenerativeAI.Microsoft" Version="2.9.3" />
     <!-- Microsoft.Azure.* -->
     <PackageVersion Include="Microsoft.Azure.Cosmos" Version="3.54.0" />
@@ -100,7 +100,7 @@
     <!-- MCP -->
     <PackageVersion Include="ModelContextProtocol" Version="0.4.0-preview.3" />
     <!-- Inference SDKs -->
-    <PackageVersion Include="AWSSDK.Extensions.Bedrock.MEAI" Version="4.0.5" />
+    <PackageVersion Include="AWSSDK.Extensions.Bedrock.MEAI" Version="4.0.5.1" />
     <PackageVersion Include="Microsoft.ML.OnnxRuntimeGenAI" Version="0.10.0" />
     <PackageVersion Include="OllamaSharp" Version="5.4.8" />
     <PackageVersion Include="OpenAI" Version="2.8.0" />
@@ -112,14 +112,14 @@
     <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.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" />
+    <PackageVersion Include="Microsoft.DurableTask.Client" Version="1.19.1" />
+    <PackageVersion Include="Microsoft.DurableTask.Client.AzureManaged" Version="1.19.0" />
+    <PackageVersion Include="Microsoft.DurableTask.Worker" Version="1.19.0" />
+    <PackageVersion Include="Microsoft.DurableTask.Worker.AzureManaged" Version="1.19.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.11.0" />
+    <PackageVersion Include="Microsoft.Azure.Functions.Worker.Extensions.DurableTask" Version="1.13.1" />
     <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" />

dotnet/agent-framework-dotnet.slnx

@@ -34,6 +34,13 @@
     <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" />
+    <Project Path="samples/AzureFunctions/09_Workflow/09_Workflow.csproj" />
+    <Project Path="samples/AzureFunctions/10_WorkflowConcurrent/10_WorkflowConcurrent.csproj" />
+    <Project Path="samples/AzureFunctions/11_WorkflowSharedState/11_WorkflowSharedState.csproj" />
+    <Project Path="samples/AzureFunctions/12_ConditionalEdges/12_ConditionalEdges.csproj" />
+  </Folder>
+  <Folder Name="/Samples/DurableWorkflows/">
+    <Project Path="samples/DurableWorkflows/01_ExecutorsAndEdges/01_ExecutorsAndEdges.csproj" />
   </Folder>
   <Folder Name="/Samples/GettingStarted/">
     <File Path="samples/GettingStarted/README.md" />

dotnet/nuget.config

@@ -3,10 +3,14 @@
   <packageSources>
     <clear />
     <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
+    <add key="LocalNugetSource" value="C:\LocalNugetSource" />
   </packageSources>
   <packageSourceMapping>
     <packageSource key="nuget.org">
       <package pattern="*" />
     </packageSource>
+    <packageSource key="LocalNugetSource">
+      <package pattern="*" />
+    </packageSource>
   </packageSourceMapping>
 </configuration>

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).251219.1</PackageVersion>
-    <PackageVersion Condition="'$(VersionSuffix)' == ''">$(VersionPrefix)-preview.251219.1</PackageVersion>
-    <GitTag>1.0.0-preview.251219.1</GitTag>
+    <PackageVersion Condition="'$(VersionSuffix)' != ''">$(VersionPrefix)-$(VersionSuffix).260108.1</PackageVersion>
+    <PackageVersion Condition="'$(VersionSuffix)' == ''">$(VersionPrefix)-preview.260108.1</PackageVersion>
+    <GitTag>1.0.0-preview.260108.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/.editorconfig

@@ -8,3 +8,6 @@ dotnet_diagnostic.DURABLE0003.severity = none
 dotnet_diagnostic.DURABLE0004.severity = none
 dotnet_diagnostic.DURABLE0005.severity = none
 dotnet_diagnostic.DURABLE0006.severity = none
+
+# CA1812: Internal classes are instantiated via dependency injection or reflection in samples
+dotnet_diagnostic.CA1812.severity = none

dotnet/samples/AzureFunctions/01_SingleAgent/01_SingleAgent.csproj

@@ -6,8 +6,8 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <!-- The Functions build tools don't like namespaces that start with a number -->
-    <AssemblyName>SingleAgent</AssemblyName>
-    <RootNamespace>SingleAgent</RootNamespace>
+    <AssemblyName>Workflow</AssemblyName>
+    <RootNamespace>Workflow</RootNamespace>
   </PropertyGroup>
 
   <ItemGroup>

dotnet/samples/AzureFunctions/01_SingleAgent/demo.http

@@ -5,4 +5,4 @@
 POST {{authority}}/api/agents/Joker/run
 Content-Type: text/plain
 
-Tell me a joke about a pirate.
+Hello world

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

@@ -96,16 +96,15 @@ public sealed class FunctionTriggers
 
         // Create a new agent thread
         AgentThread thread = agentProxy.GetNewThread();
-        AgentThreadMetadata metadata = thread.GetService<AgentThreadMetadata>()
-            ?? throw new InvalidOperationException("Failed to get AgentThreadMetadata from new thread.");
+        string agentSessionId = thread.GetService<AgentSessionId>().ToString();
 
-        this._logger.LogInformation("Creating new agent session: {ConversationId}", metadata.ConversationId);
+        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: {ConversationId}", metadata.ConversationId);
+        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)
@@ -114,7 +113,7 @@ public sealed class FunctionTriggers
         bool useSseFormat = acceptHeader?.Contains("text/plain", StringComparison.OrdinalIgnoreCase) != true;
 
         return await this.StreamToClientAsync(
-            conversationId: metadata.ConversationId!, cursor: null, useSseFormat, request.HttpContext, cancellationToken);
+            conversationId: agentSessionId, cursor: null, useSseFormat, request.HttpContext, cancellationToken);
     }
 
     /// <summary>

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

@@ -65,11 +65,10 @@ public sealed class RedisStreamResponseHandler : IAgentResponseHandler
                 "DurableAgentContext.Current is not set. This handler must be used within a durable agent context.");
         }
 
-        // Get conversation ID from the current thread context, which is only available in the context of
+        // Get session ID from the current thread context, which is only available in the context of
         // a durable agent execution.
-        string conversationId = context.CurrentThread.GetService<AgentThreadMetadata>()?.ConversationId
-            ?? throw new InvalidOperationException("Unable to determine conversation ID from the current thread.");
-        string streamKey = GetStreamKey(conversationId);
+        string agentSessionId = context.CurrentThread.GetService<AgentSessionId>().ToString();
+        string streamKey = GetStreamKey(agentSessionId);
 
         IDatabase db = this._redis.GetDatabase();
         int sequenceNumber = 0;

dotnet/samples/AzureFunctions/09_Workflow/09_Workflow.csproj

@@ -0,0 +1,44 @@
+<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>SingleAgent</AssemblyName>
+    <RootNamespace>SingleAgent</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" />
+    <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>
+
+  <!-- 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" />
+    <ProjectReference Include="..\..\..\src\Microsoft.Agents.AI.Workflows\Microsoft.Agents.AI.Workflows.csproj" />
+  </ItemGroup>
+</Project>

dotnet/samples/AzureFunctions/09_Workflow/OrderProcessingExecutors.cs

@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Agents.AI.Workflows;
+
+namespace SingleAgent;
+
+/// <summary>
+/// Parses an Order ID from a string input and returns an Order object populated.
+/// </summary>
+internal sealed class OrderLookup() : Executor<string, Order>("OrderLookup")
+{
+    public override async ValueTask<Order> HandleAsync(string message, IWorkflowContext context, CancellationToken cancellationToken = default)
+    {
+        // Populate Order information from OrderId.
+        return new Order(message, 100.0m);
+    }
+}
+
+/// <summary>
+/// Enriches an Order object with additional information.
+/// </summary>
+internal sealed class OrderEnrich() : Executor<Order, Order>("EnrichOrder")
+{
+    public override async ValueTask<Order> HandleAsync(Order message, IWorkflowContext context, CancellationToken cancellationToken = default)
+    {
+        if (message.Customer is null)
+        {
+            // populate customer information for the order from database.
+            message.Customer = new Customer(1, "Jerry");
+        }
+
+        return message;
+    }
+}
+
+internal sealed class PaymentProcessor() : Executor<Order, Order>("ProcessPayment")
+{
+    public override async ValueTask<Order> HandleAsync(Order message, IWorkflowContext context, CancellationToken cancellationToken = default)
+    {
+        message.PaymentReferenceNumber = Guid.NewGuid().ToString()[^4..];
+
+        return message;
+    }
+}
+
+internal sealed class OrderCancel() : Executor<Order, string>("OrderCancel")
+{
+    public override async ValueTask<string> HandleAsync(Order message, IWorkflowContext context, CancellationToken cancellationToken = default)
+    {
+        return $"Order {message.Id} cancelled at {DateTime.UtcNow:g} UTC.";
+    }
+}
+
+internal sealed class Order
+{
+    public Order(string id, decimal amount)
+    {
+        this.Id = id;
+        this.Amount = amount;
+    }
+    public string Id { get; }
+    public decimal Amount { get; }
+    public Customer? Customer { get; set; }
+    public string? PaymentReferenceNumber { get; set; }
+}
+
+public sealed record Customer(int Id, string Name);

dotnet/samples/AzureFunctions/09_Workflow/Program.cs

@@ -0,0 +1,40 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Agents.AI.Hosting.AzureFunctions;
+using Microsoft.Agents.AI.Workflows;
+using Microsoft.Azure.Functions.Worker.Builder;
+using Microsoft.Extensions.Hosting;
+using SingleAgent;
+
+Func<string, string> orderParserFunc = input =>
+{
+    // We accept both short ordereId(Ex:12345) and long order reference number(MSFT12345)
+    // OrderId is the last 5 digigs of order reference number.
+    const int OrderIdPartLength = 5;
+    if (input.Length > OrderIdPartLength)
+    {
+        return input[^OrderIdPartLength..];
+    }
+
+    return input;
+};
+var orderParserExecutor = orderParserFunc.BindAsExecutor("ParseOrderId");
+
+OrderLookup orderLookupExecutor = new();
+OrderEnrich orderEnricherExeecutor = new();
+PaymentProcessor paymentProcessorExecutor = new();
+
+Workflow fulfillOrder = new WorkflowBuilder(orderParserExecutor)
+    .WithName("FulfillOrder")
+    .WithDescription("Looks up an order by ID and run payment processing")
+    .AddEdge(orderParserExecutor, orderLookupExecutor)
+    .AddEdge(orderLookupExecutor, orderEnricherExeecutor)
+    .AddEdge(orderEnricherExeecutor, paymentProcessorExecutor)
+    .Build();
+
+var host = FunctionsApplication.CreateBuilder(args)
+    .ConfigureFunctionsWebApplication()
+    .ConfigureDurableOptions(options => options.Workflows.AddWorkflow(fulfillOrder, enableMcpToolTrigger: true))
+    .Build();
+
+host.Run();

dotnet/samples/AzureFunctions/09_Workflow/README.md

@@ -0,0 +1,89 @@
+# Single Agent Sample
+
+This sample demonstrates how to use the Durable Agent Framework (DAFx) to create a simple Azure Functions app that hosts a single AI agent and provides direct HTTP API access for interactive conversations.
+
+## Key Concepts Demonstrated
+
+- Using the Microsoft Agent Framework to define a simple AI agent with a name and instructions.
+- Registering agents with the Function app and running them using HTTP.
+- Conversation management (via session IDs) for isolated interactions.
+
+## 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.
+
+## Running the Sample
+
+With the environment setup and function app running, you can test the sample by sending an HTTP request to the agent endpoint.
+
+You can use the `demo.http` file to send a message to the agent, or a command line tool like `curl` as shown below:
+
+Bash (Linux/macOS/WSL):
+
+```bash
+curl -X POST http://localhost:7071/api/agents/Joker/run \
+    -H "Content-Type: text/plain" \
+    -d "Tell me a joke about a pirate."
+```
+
+PowerShell:
+
+```powershell
+Invoke-RestMethod -Method Post `
+    -Uri http://localhost:7071/api/agents/Joker/run `
+    -ContentType text/plain `
+    -Body "Tell me a joke about a pirate."
+```
+
+You can also send JSON requests:
+
+```bash
+curl -X POST http://localhost:7071/api/agents/Joker/run \
+    -H "Content-Type: application/json" \
+    -H "Accept: application/json" \
+    -d '{"message": "Tell me a joke about a pirate."}'
+```
+
+To continue a conversation, include the `thread_id` in the query string or JSON body:
+
+```bash
+curl -X POST "http://localhost:7071/api/agents/Joker/run?thread_id=your-thread-id" \
+    -H "Content-Type: application/json" \
+    -H "Accept: application/json" \
+    -d '{"message": "Tell me another one."}'
+```
+
+The response from the agent will be displayed in the terminal where you ran `func start`. The expected `text/plain` output will look something like:
+
+```text
+Why don't pirates ever learn the alphabet? Because they always get stuck at "C"!
+```
+
+The expected `application/json` output will look something like:
+
+```json
+{
+  "status": 200,
+  "thread_id": "ee6e47a0-f24b-40b1-ade8-16fcebb9eb40",
+  "response": {
+    "Messages": [
+      {
+        "AuthorName": "Joker",
+        "CreatedAt": "2025-11-11T12:00:00.0000000Z",
+        "Role": "assistant",
+        "Contents": [
+          {
+            "Type": "text",
+            "Text": "Why don't pirates ever learn the alphabet? Because they always get stuck at 'C'!"
+          }
+        ]
+      }
+    ],
+    "Usage": {
+      "InputTokenCount": 78,
+      "OutputTokenCount": 36,
+      "TotalTokenCount": 114
+    }
+  }
+}
+```

dotnet/samples/AzureFunctions/09_Workflow/demo.http

@@ -0,0 +1,14 @@
+# Default endpoint address for local testing
+@authority=http://localhost:7071
+
+### Look up a long order reference id
+POST {{authority}}/api/workflows/FulfillOrder/run
+Content-Type: text/plain
+
+QWERTY80853
+
+### Look up a short order id
+POST {{authority}}/api/workflows/CancelOrder/run
+Content-Type: text/plain
+
+12345

dotnet/samples/AzureFunctions/09_Workflow/host.json

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

dotnet/samples/AzureFunctions/10_WorkflowConcurrent/10_WorkflowConcurrent.csproj

@@ -0,0 +1,48 @@
+<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>SingleAgent</AssemblyName>
+    <RootNamespace>SingleAgent</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <FrameworkReference Include="Microsoft.AspNetCore.App" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="local.settings.json" />
+  </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" />
+    <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>
+
+  <!-- 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" />
+    <ProjectReference Include="..\..\..\src\Microsoft.Agents.AI.Workflows\Microsoft.Agents.AI.Workflows.csproj" />
+  </ItemGroup>
+</Project>

dotnet/samples/AzureFunctions/10_WorkflowConcurrent/PrepareQuery.cs

@@ -0,0 +1,30 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Agents.AI.Workflows;
+
+namespace SingleAgent;
+
+internal sealed class PrepareQuery() : Executor<string, string>("PrepareQuery")
+{
+    public override ValueTask<string> HandleAsync(string message, IWorkflowContext context, CancellationToken cancellationToken = default)
+    {
+        // do some initial parsing and validation of the message.
+        // Return a polished version ith additional metadta.
+        if (!message.StartsWith("Query for the agent:", StringComparison.OrdinalIgnoreCase))
+        {
+            message = "Query for the agent: " + message;
+        }
+
+        return ValueTask.FromResult(message);
+    }
+}
+
+internal sealed class ResultAggregator() : Executor<string[], string>("ResultAggregator")
+{
+    public override ValueTask<string> HandleAsync(string[] message, IWorkflowContext context, CancellationToken cancellationToken = default)
+    {
+        // Aggregate all responses from parallel executors.
+        string aggregatedResponse = string.Join("\n---\n", message);
+        return ValueTask.FromResult($"Aggregated {message.Length} responses:\n{aggregatedResponse}");
+    }
+}

dotnet/samples/AzureFunctions/10_WorkflowConcurrent/Program.cs

@@ -0,0 +1,48 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Azure;
+using Azure.AI.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Agents.AI.Hosting.AzureFunctions;
+using Microsoft.Agents.AI.Workflows;
+using Microsoft.Azure.Functions.Worker.Builder;
+using Microsoft.Extensions.AI;
+using Microsoft.Extensions.Hosting;
+using OpenAI.Chat;
+using SingleAgent;
+
+// 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.");
+
+// 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());
+
+AIAgent physicist = client.GetChatClient(deploymentName).CreateAIAgent("You are an expert in physics. You answer questions from a physics perspective.", "Physicist");
+AIAgent chemist = client.GetChatClient(deploymentName).CreateAIAgent("You are an expert in chemistry. You answer questions from a chemistry perspective.", "Chemist");
+
+var startExecutor = new PrepareQuery();
+var aggregationExecutor = new ResultAggregator();
+
+var workflow = new WorkflowBuilder(startExecutor)
+    .WithName("ExpertReview")
+    .AddFanOutEdge(startExecutor, [physicist, chemist])
+    .AddFanInEdge([physicist, chemist], aggregationExecutor)
+    .Build();
+
+var host = FunctionsApplication.CreateBuilder(args)
+    .ConfigureFunctionsWebApplication()
+    .ConfigureDurableOptions(options =>
+    {
+        // Configure workflows
+        options.Workflows.AddWorkflow(workflow);
+    })
+    .Build();
+
+host.Run();

dotnet/samples/AzureFunctions/10_WorkflowConcurrent/README.md

@@ -0,0 +1,89 @@
+# Single Agent Sample
+
+This sample demonstrates how to use the Durable Agent Framework (DAFx) to create a simple Azure Functions app that hosts a single AI agent and provides direct HTTP API access for interactive conversations.
+
+## Key Concepts Demonstrated
+
+- Using the Microsoft Agent Framework to define a simple AI agent with a name and instructions.
+- Registering agents with the Function app and running them using HTTP.
+- Conversation management (via session IDs) for isolated interactions.
+
+## 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.
+
+## Running the Sample
+
+With the environment setup and function app running, you can test the sample by sending an HTTP request to the agent endpoint.
+
+You can use the `demo.http` file to send a message to the agent, or a command line tool like `curl` as shown below:
+
+Bash (Linux/macOS/WSL):
+
+```bash
+curl -X POST http://localhost:7071/api/agents/Joker/run \
+    -H "Content-Type: text/plain" \
+    -d "Tell me a joke about a pirate."
+```
+
+PowerShell:
+
+```powershell
+Invoke-RestMethod -Method Post `
+    -Uri http://localhost:7071/api/agents/Joker/run `
+    -ContentType text/plain `
+    -Body "Tell me a joke about a pirate."
+```
+
+You can also send JSON requests:
+
+```bash
+curl -X POST http://localhost:7071/api/agents/Joker/run \
+    -H "Content-Type: application/json" \
+    -H "Accept: application/json" \
+    -d '{"message": "Tell me a joke about a pirate."}'
+```
+
+To continue a conversation, include the `thread_id` in the query string or JSON body:
+
+```bash
+curl -X POST "http://localhost:7071/api/agents/Joker/run?thread_id=your-thread-id" \
+    -H "Content-Type: application/json" \
+    -H "Accept: application/json" \
+    -d '{"message": "Tell me another one."}'
+```
+
+The response from the agent will be displayed in the terminal where you ran `func start`. The expected `text/plain` output will look something like:
+
+```text
+Why don't pirates ever learn the alphabet? Because they always get stuck at "C"!
+```
+
+The expected `application/json` output will look something like:
+
+```json
+{
+  "status": 200,
+  "thread_id": "ee6e47a0-f24b-40b1-ade8-16fcebb9eb40",
+  "response": {
+    "Messages": [
+      {
+        "AuthorName": "Joker",
+        "CreatedAt": "2025-11-11T12:00:00.0000000Z",
+        "Role": "assistant",
+        "Contents": [
+          {
+            "Type": "text",
+            "Text": "Why don't pirates ever learn the alphabet? Because they always get stuck at 'C'!"
+          }
+        ]
+      }
+    ],
+    "Usage": {
+      "InputTokenCount": 78,
+      "OutputTokenCount": 36,
+      "TotalTokenCount": 114
+    }
+  }
+}
+```

dotnet/samples/AzureFunctions/10_WorkflowConcurrent/demo.http

@@ -0,0 +1,8 @@
+# Default endpoint address for local testing
+@authority=http://localhost:7071
+
+### Start the workflow
+POST {{authority}}/api/workflows/ExpertReview/run
+Content-Type: text/plain
+
+What is temperature?

dotnet/samples/AzureFunctions/10_WorkflowConcurrent/host.json

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

dotnet/samples/AzureFunctions/11_WorkflowSharedState/11_WorkflowSharedState.csproj

@@ -0,0 +1,48 @@
+<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>SingleAgent</AssemblyName>
+    <RootNamespace>SingleAgent</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <FrameworkReference Include="Microsoft.AspNetCore.App" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="local.settings.json" />
+  </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" />
+    <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>
+
+  <!-- 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" />
+    <ProjectReference Include="..\..\..\src\Microsoft.Agents.AI.Workflows\Microsoft.Agents.AI.Workflows.csproj" />
+  </ItemGroup>
+</Project>

dotnet/samples/AzureFunctions/11_WorkflowSharedState/OrderIdParserExecutor.cs

@@ -0,0 +1,86 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample demonstrates how to use durable state management in Azure Functions workflows.
+// The OrderIdParserExecutor writes a value to shared state, and the EmailSenderExecutor reads it back.
+// The state is persisted durably using Durable Entities behind the scenes.
+
+using Microsoft.Agents.AI.Workflows;
+
+namespace SingleAgent;
+
+/// <summary>
+/// Constants for shared state scopes used across executors.
+/// </summary>
+internal static class SharedStateConstants
+{
+    public const string MessageScope = "MessageState";
+    public const string ProcessedMessageKey = "ProcessedMessage";
+}
+
+public sealed class Order
+{
+    public Order(string id, decimal amount)
+    {
+        this.Id = id;
+        this.Amount = amount;
+    }
+    public string Id { get; }
+    public decimal Amount { get; }
+    public string? PaymentReferenceNumber { get; set; }
+}
+
+/// <summary>
+/// First executor that processes a message and stores the result in shared state.
+/// </summary>
+internal sealed class OrderIdParserExecutor() : Executor<string, Order>("OrderIdParserExecutor")
+{
+    public override async ValueTask<Order> HandleAsync(string message, IWorkflowContext context, CancellationToken cancellationToken = default)
+    {
+        // Process the message
+        string processedMessage = $"Processed: {message}";
+
+        // Store the processed message in shared state for the next executor
+        await context.QueueStateUpdateAsync(
+            SharedStateConstants.ProcessedMessageKey,
+            processedMessage,
+            SharedStateConstants.MessageScope,
+            cancellationToken);
+
+        return GetOrder(message);
+    }
+
+    private static Order GetOrder(string id)
+    {
+        // Simulate fetching order details
+        return new Order(id, 100.0m);
+    }
+}
+
+/// <summary>
+/// Second executor that reads the shared state and appends to the message.
+/// </summary>
+internal sealed class EmailSenderExecutor() : Executor<Order, string>("EmailSenderExecutor")
+{
+    public override async ValueTask<string> HandleAsync(Order message, IWorkflowContext context, CancellationToken cancellationToken = default)
+    {
+        // Read the processed message from shared state (written by OrderIdParserExecutor)
+        string? storedMessage = await context.ReadStateAsync<string>(
+            SharedStateConstants.ProcessedMessageKey,
+            SharedStateConstants.MessageScope,
+            cancellationToken);
+
+        return storedMessage is not null
+            ? $"From state: [{storedMessage}] | Input: [{message.Id}]"
+            : $"No state found | Input: [{message.Id}]";
+    }
+}
+
+internal sealed class PaymentProcesserExecutor() : Executor<Order, Order>("PaymentProcesserExecutor")
+{
+    public override async ValueTask<Order> HandleAsync(Order message, IWorkflowContext context, CancellationToken cancellationToken = default)
+    {
+        // Call payment gateway.
+        message.PaymentReferenceNumber = Guid.NewGuid().ToString().Substring(0, 4);
+        return message;
+    }
+}

dotnet/samples/AzureFunctions/11_WorkflowSharedState/Program.cs

@@ -0,0 +1,23 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Agents.AI.Hosting.AzureFunctions;
+using Microsoft.Agents.AI.Workflows;
+using Microsoft.Azure.Functions.Worker.Builder;
+using Microsoft.Extensions.Hosting;
+using SingleAgent;
+
+// Set up an AI agent following the standard Microsoft Agent Framework pattern.
+
+OrderIdParserExecutor orderParser = new();
+PaymentProcesserExecutor paymentProcessor = new();
+EmailSenderExecutor emailSender = new();
+
+WorkflowBuilder builder = new(orderParser);
+builder.AddEdge(orderParser, paymentProcessor);
+builder.AddEdge(paymentProcessor, emailSender).WithOutputFrom(emailSender);
+var workflow = builder.WithName("ProcessOrder").Build();
+
+FunctionsApplication.CreateBuilder(args)
+    .ConfigureFunctionsWebApplication()
+    .ConfigureDurableOptions(options => options.Workflows.AddWorkflow(workflow))
+    .Build().Run();

dotnet/samples/AzureFunctions/11_WorkflowSharedState/README.md

@@ -0,0 +1,89 @@
+# Single Agent Sample
+
+This sample demonstrates how to use the Durable Agent Framework (DAFx) to create a simple Azure Functions app that hosts a single AI agent and provides direct HTTP API access for interactive conversations.
+
+## Key Concepts Demonstrated
+
+- Using the Microsoft Agent Framework to define a simple AI agent with a name and instructions.
+- Registering agents with the Function app and running them using HTTP.
+- Conversation management (via session IDs) for isolated interactions.
+
+## 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.
+
+## Running the Sample
+
+With the environment setup and function app running, you can test the sample by sending an HTTP request to the agent endpoint.
+
+You can use the `demo.http` file to send a message to the agent, or a command line tool like `curl` as shown below:
+
+Bash (Linux/macOS/WSL):
+
+```bash
+curl -X POST http://localhost:7071/api/agents/Joker/run \
+    -H "Content-Type: text/plain" \
+    -d "Tell me a joke about a pirate."
+```
+
+PowerShell:
+
+```powershell
+Invoke-RestMethod -Method Post `
+    -Uri http://localhost:7071/api/agents/Joker/run `
+    -ContentType text/plain `
+    -Body "Tell me a joke about a pirate."
+```
+
+You can also send JSON requests:
+
+```bash
+curl -X POST http://localhost:7071/api/agents/Joker/run \
+    -H "Content-Type: application/json" \
+    -H "Accept: application/json" \
+    -d '{"message": "Tell me a joke about a pirate."}'
+```
+
+To continue a conversation, include the `thread_id` in the query string or JSON body:
+
+```bash
+curl -X POST "http://localhost:7071/api/agents/Joker/run?thread_id=your-thread-id" \
+    -H "Content-Type: application/json" \
+    -H "Accept: application/json" \
+    -d '{"message": "Tell me another one."}'
+```
+
+The response from the agent will be displayed in the terminal where you ran `func start`. The expected `text/plain` output will look something like:
+
+```text
+Why don't pirates ever learn the alphabet? Because they always get stuck at "C"!
+```
+
+The expected `application/json` output will look something like:
+
+```json
+{
+  "status": 200,
+  "thread_id": "ee6e47a0-f24b-40b1-ade8-16fcebb9eb40",
+  "response": {
+    "Messages": [
+      {
+        "AuthorName": "Joker",
+        "CreatedAt": "2025-11-11T12:00:00.0000000Z",
+        "Role": "assistant",
+        "Contents": [
+          {
+            "Type": "text",
+            "Text": "Why don't pirates ever learn the alphabet? Because they always get stuck at 'C'!"
+          }
+        ]
+      }
+    ],
+    "Usage": {
+      "InputTokenCount": 78,
+      "OutputTokenCount": 36,
+      "TotalTokenCount": 114
+    }
+  }
+}
+```

dotnet/samples/AzureFunctions/11_WorkflowSharedState/demo.http

@@ -0,0 +1,14 @@
+# Default endpoint address for local testing
+@authority=http://localhost:7071
+
+### Start the workflow
+POST {{authority}}/api/workflows/ProcessOrder/run
+Content-Type: text/plain
+
+123
+
+### Start second workflow
+POST {{authority}}/api/workflows/ProcessOrder/run
+Content-Type: text/plain
+
+456

dotnet/samples/AzureFunctions/11_WorkflowSharedState/host.json

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

dotnet/samples/AzureFunctions/12_ConditionalEdges/12_ConditionalEdges.csproj

@@ -0,0 +1,51 @@
+<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>SingleAgent</AssemblyName>
+    <RootNamespace>SingleAgent</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <FrameworkReference Include="Microsoft.AspNetCore.App" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="local.settings.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      <CopyToPublishDirectory>Never</CopyToPublishDirectory>
+    </None>
+  </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" />
+    <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>
+
+  <!-- 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" />
+    <ProjectReference Include="..\..\..\src\Microsoft.Agents.AI.Workflows\Microsoft.Agents.AI.Workflows.csproj" />
+  </ItemGroup>
+</Project>

dotnet/samples/AzureFunctions/12_ConditionalEdges/OrderIdParser.cs

@@ -0,0 +1,98 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample demonstrates how to use durable state management in Azure Functions workflows.
+// The OrderIdParser writes a value to shared state, and the FraudValidation reads it back.
+// The state is persisted durably using Durable Entities behind the scenes.
+
+using Microsoft.Agents.AI.Workflows;
+
+namespace SingleAgent;
+
+/// <summary>
+/// Constants for shared state scopes used across executors.
+/// </summary>
+internal static class SharedStateConstants
+{
+    public const string MessageScope = "MessageState";
+    public const string ProcessedMessageKey = "ProcessedMessage";
+}
+
+internal sealed class Order
+{
+    public Order(string id, decimal amount)
+    {
+        this.Id = id;
+        this.Amount = amount;
+    }
+    public string Id { get; }
+    public decimal Amount { get; }
+    public Customer? Customer { get; set; }
+    public string? PaymentReferenceNumber { get; set; }
+}
+
+public sealed record Customer(int Id, string Name, bool IsBlocked);
+
+internal sealed class OrderIdParser() : Executor<string, Order>("OrderIdParser")
+{
+    public override async ValueTask<Order> HandleAsync(string message, IWorkflowContext context, CancellationToken cancellationToken = default)
+    {
+        return GetOrder(message);
+    }
+
+    private static Order GetOrder(string id)
+    {
+        // Simulate fetching order details
+        return new Order(id, 100.0m);
+    }
+}
+
+internal sealed class OrderEnrich() : Executor<Order, Order>("EnrichOrder")
+{
+    public override async ValueTask<Order> HandleAsync(Order message, IWorkflowContext context, CancellationToken cancellationToken = default)
+    {
+        message.Customer = GetCustomerForOrder(message.Id);
+        return message;
+    }
+
+    private static Customer GetCustomerForOrder(string orderId)
+    {
+        if (orderId.Contains('B'))
+        {
+            return new Customer(101, "George", true);
+        }
+
+        return new Customer(201, "Jerry", false);
+    }
+}
+
+internal sealed class PaymentProcesser() : Executor<Order, Order>("PaymentProcesser")
+{
+    public override async ValueTask<Order> HandleAsync(Order message, IWorkflowContext context, CancellationToken cancellationToken = default)
+    {
+        // Call payment gateway.
+        message.PaymentReferenceNumber = Guid.NewGuid().ToString().Substring(0, 4);
+        return message;
+    }
+}
+
+internal sealed class NotifyFraud() : Executor<Order, string>("NotifyFraud")
+{
+    public override async ValueTask<string> HandleAsync(Order message, IWorkflowContext context, CancellationToken cancellationToken = default)
+    {
+        // Notify fraud team.
+        return $"Order {message.Id} flagged as fraudulent for customer {message.Customer?.Name}.";
+    }
+}
+
+internal static class OrderRouteConditions
+{
+    /// <summary>
+    /// Returns a condition that evaluates to true when the customer is blocked.
+    /// </summary>
+    internal static Func<Order?, bool> WhenBlocked() => order => order?.Customer?.IsBlocked == true;
+
+    /// <summary>
+    /// Returns a condition that evaluates to true when the customer is not blocked.
+    /// </summary>
+    internal static Func<Order?, bool> WhenNotBlocked() => order => order?.Customer?.IsBlocked == false;
+}

dotnet/samples/AzureFunctions/12_ConditionalEdges/Program.cs

@@ -0,0 +1,26 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Agents.AI.Hosting.AzureFunctions;
+using Microsoft.Agents.AI.Workflows;
+using Microsoft.Azure.Functions.Worker.Builder;
+using Microsoft.Extensions.Hosting;
+using SingleAgent;
+
+OrderIdParser orderParser = new();
+OrderEnrich orderEnrich = new();
+PaymentProcesser paymentProcessor = new();
+NotifyFraud notifyFraud = new();
+
+WorkflowBuilder builder = new(orderParser);
+builder
+    .AddEdge(orderParser, orderEnrich)
+    .AddEdge(orderEnrich, notifyFraud, condition: OrderRouteConditions.WhenBlocked())
+    .AddEdge(orderEnrich, paymentProcessor, condition: OrderRouteConditions.WhenNotBlocked());
+
+var workflow = builder.WithName("AuditOrder").Build();
+
+FunctionsApplication.CreateBuilder(args)
+    .ConfigureFunctionsWebApplication()
+    .ConfigureDurableOptions(options => options.Workflows.AddWorkflow(workflow, enableMcpToolTrigger: true))
+    .Build()
+    .Run();

dotnet/samples/AzureFunctions/12_ConditionalEdges/README.md

@@ -0,0 +1,89 @@
+# Single Agent Sample
+
+This sample demonstrates how to use the Durable Agent Framework (DAFx) to create a simple Azure Functions app that hosts a single AI agent and provides direct HTTP API access for interactive conversations.
+
+## Key Concepts Demonstrated
+
+- Using the Microsoft Agent Framework to define a simple AI agent with a name and instructions.
+- Registering agents with the Function app and running them using HTTP.
+- Conversation management (via session IDs) for isolated interactions.
+
+## 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.
+
+## Running the Sample
+
+With the environment setup and function app running, you can test the sample by sending an HTTP request to the agent endpoint.
+
+You can use the `demo.http` file to send a message to the agent, or a command line tool like `curl` as shown below:
+
+Bash (Linux/macOS/WSL):
+
+```bash
+curl -X POST http://localhost:7071/api/agents/Joker/run \
+    -H "Content-Type: text/plain" \
+    -d "Tell me a joke about a pirate."
+```
+
+PowerShell:
+
+```powershell
+Invoke-RestMethod -Method Post `
+    -Uri http://localhost:7071/api/agents/Joker/run `
+    -ContentType text/plain `
+    -Body "Tell me a joke about a pirate."
+```
+
+You can also send JSON requests:
+
+```bash
+curl -X POST http://localhost:7071/api/agents/Joker/run \
+    -H "Content-Type: application/json" \
+    -H "Accept: application/json" \
+    -d '{"message": "Tell me a joke about a pirate."}'
+```
+
+To continue a conversation, include the `thread_id` in the query string or JSON body:
+
+```bash
+curl -X POST "http://localhost:7071/api/agents/Joker/run?thread_id=your-thread-id" \
+    -H "Content-Type: application/json" \
+    -H "Accept: application/json" \
+    -d '{"message": "Tell me another one."}'
+```
+
+The response from the agent will be displayed in the terminal where you ran `func start`. The expected `text/plain` output will look something like:
+
+```text
+Why don't pirates ever learn the alphabet? Because they always get stuck at "C"!
+```
+
+The expected `application/json` output will look something like:
+
+```json
+{
+  "status": 200,
+  "thread_id": "ee6e47a0-f24b-40b1-ade8-16fcebb9eb40",
+  "response": {
+    "Messages": [
+      {
+        "AuthorName": "Joker",
+        "CreatedAt": "2025-11-11T12:00:00.0000000Z",
+        "Role": "assistant",
+        "Contents": [
+          {
+            "Type": "text",
+            "Text": "Why don't pirates ever learn the alphabet? Because they always get stuck at 'C'!"
+          }
+        ]
+      }
+    ],
+    "Usage": {
+      "InputTokenCount": 78,
+      "OutputTokenCount": 36,
+      "TotalTokenCount": 114
+    }
+  }
+}
+```

dotnet/samples/AzureFunctions/12_ConditionalEdges/demo.http

@@ -0,0 +1,14 @@
+# Default endpoint address for local testing
+@authority=http://localhost:7071
+
+### Start the workflow
+POST {{authority}}/api/workflows/AuditOrder/run
+Content-Type: text/plain
+
+B123
+
+### Start second workflow
+POST {{authority}}/api/workflows/AuditOrder/run
+Content-Type: text/plain
+
+456

dotnet/samples/AzureFunctions/12_ConditionalEdges/host.json

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

dotnet/samples/DurableWorkflows/01_ExecutorsAndEdges/01_ExecutorsAndEdges.csproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.DurableTask.Client.AzureManaged" />
+    <PackageReference Include="Microsoft.DurableTask.Worker.AzureManaged" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" />
+  </ItemGroup>
+  
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\src\Microsoft.Agents.AI.Hosting.AzureFunctions\Microsoft.Agents.AI.Hosting.AzureFunctions.csproj" />
+    <ProjectReference Include="..\..\..\src\Microsoft.Agents.AI.Workflows\Microsoft.Agents.AI.Workflows.csproj" />
+  </ItemGroup>
+
+</Project>

dotnet/samples/DurableWorkflows/01_ExecutorsAndEdges/Program.cs

@@ -0,0 +1,63 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Agents.AI.Workflows;
+
+namespace WorkflowExecutorsAndEdgesSample;
+
+/// <summary>
+/// This sample introduces the concepts of executors and edges in a workflow.
+///
+/// Workflows are built from executors (processing units) connected by edges (data flow paths).
+/// In this example, we create a simple text processing pipeline that:
+/// 1. Takes input text and converts it to uppercase using an UppercaseExecutor
+/// 2. Takes the uppercase text and reverses it using a ReverseTextExecutor
+///
+/// The executors are connected sequentially, so data flows from one to the next in order.
+/// For input "Hello, World!", the workflow produces "!DLROW ,OLLEH".
+/// </summary>
+public static class Program
+{
+    private static async Task Main()
+    {
+        // Create the executors
+        Func<string, string> uppercaseFunc = s => s.ToUpperInvariant();
+        var uppercase = uppercaseFunc.BindAsExecutor("UppercaseExecutor");
+
+        ReverseTextExecutor reverse = new();
+
+        // Build the workflow by connecting executors sequentially
+        WorkflowBuilder builder = new(uppercase);
+        builder.AddEdge(uppercase, reverse).WithOutputFrom(reverse);
+        var workflow = builder.Build();
+
+        // Execute the workflow with input data
+        await using Run run = await InProcessExecution.RunAsync(workflow, "Hello, World!");
+        foreach (WorkflowEvent evt in run.NewEvents)
+        {
+            if (evt is ExecutorCompletedEvent executorComplete)
+            {
+                Console.WriteLine($"{executorComplete.ExecutorId}: {executorComplete.Data}");
+            }
+        }
+    }
+}
+
+/// <summary>
+/// Second executor: reverses the input text and completes the workflow.
+/// </summary>
+internal sealed class ReverseTextExecutor() : Executor<string, string>("ReverseTextExecutor")
+{
+    /// <summary>
+    /// Processes the input message by reversing the text.
+    /// </summary>
+    /// <param name="message">The input text to reverse</param>
+    /// <param name="context">Workflow context for accessing workflow services and adding events</param>
+    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests.
+    /// The default is <see cref="CancellationToken.None"/>.</param>
+    /// <returns>The input text reversed</returns>
+    public override ValueTask<string> HandleAsync(string message, IWorkflowContext context, CancellationToken cancellationToken = default)
+    {
+        // Because we do not suppress it, the returned result will be yielded as an output from this executor.
+        return ValueTask.FromResult(string.Concat(message.Reverse()));
+    }
+}

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/GettingStarted/Workflows/Visualization/Program.cs

@@ -1,6 +1,11 @@
 // Copyright (c) Microsoft. All rights reserved.
 
+using Azure;
+using Azure.AI.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
 using Microsoft.Agents.AI.Workflows;
+using OpenAI.Chat;
 
 namespace WorkflowVisualizationSample;
 
@@ -20,8 +25,29 @@ internal static class Program
     /// <param name="args">Command line arguments (not used).</param>
     private static void Main(string[] args)
     {
-        // Step 1: Build the workflow you want to visualize
-        Workflow workflow = WorkflowMapReduceSample.Program.BuildWorkflow();
+        // 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.");
+
+        // 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());
+
+        AIAgent physicist = client.GetChatClient(deploymentName).CreateAIAgent("You are an expert in physics. You answer questions from a physics perspective.", "Physicist");
+        AIAgent chemist = client.GetChatClient(deploymentName).CreateAIAgent("You are an expert in chemistry. You answer questions from a chemistry perspective.", "Chemist");
+
+        var startExecutor = new PrepareQuery();
+        var aggregationExecutor = new ResultAggregator();
+
+        var workflow = new WorkflowBuilder(startExecutor)
+            .WithName("ExpertReview")
+            .AddFanOutEdge(startExecutor, [physicist, chemist])
+            .AddFanInEdge([physicist, chemist], aggregationExecutor)
+            .Build();
 
         // Step 2: Generate and display workflow visualization
         Console.WriteLine("Generating workflow visualization...");
@@ -31,11 +57,30 @@ internal static class Program
         var mermaid = workflow.ToMermaidString();
         Console.WriteLine(mermaid);
         Console.WriteLine("=======");
+    }
+}
 
-        // DOT
-        Console.WriteLine("DiGraph string: *** Tip: To export DOT as an image, install Graphviz and pipe the DOT output to 'dot -Tsvg', 'dot -Tpng', etc. *** \n=======");
-        var dotString = workflow.ToDotString();
-        Console.WriteLine(dotString);
-        Console.WriteLine("=======");
+internal sealed class PrepareQuery() : Executor<string, string>("PrepareQuery")
+{
+    public override ValueTask<string> HandleAsync(string message, IWorkflowContext context, CancellationToken cancellationToken = default)
+    {
+        // do some initial parsing and validation of the message.
+        // Return a polished version ith additional metadta.
+        if (!message.StartsWith("Query for the agent:", StringComparison.OrdinalIgnoreCase))
+        {
+            message = "Query for the agent: " + message;
+        }
+
+        return ValueTask.FromResult(message);
+    }
+}
+
+internal sealed class ResultAggregator() : Executor<string[], string>("ResultAggregator")
+{
+    public override ValueTask<string> HandleAsync(string[] message, IWorkflowContext context, CancellationToken cancellationToken = default)
+    {
+        // Aggregate all responses from parallel executors.
+        string aggregatedResponse = string.Join("\n---\n", message);
+        return ValueTask.FromResult($"Aggregated {message.Length} responses:\n{aggregatedResponse}");
     }
 }

dotnet/samples/GettingStarted/Workflows/Visualization/Visualization.csproj

@@ -9,6 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
     <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.Workflows\Microsoft.Agents.AI.Workflows.csproj" />
     <ProjectReference Include="..\Concurrent\MapReduce\MapReduce.csproj" />
   </ItemGroup>

dotnet/samples/HostedAgents/AgentWithHostedMCP/AgentWithHostedMCP.csproj

@@ -39,8 +39,8 @@
     <PackageReference Include="Azure.AI.AgentServer.AgentFramework" Version="1.0.0-beta.5" />
     <PackageReference Include="Azure.AI.OpenAI" Version="2.7.0-beta.2" />
     <PackageReference Include="Azure.Identity" Version="1.17.1" />
-    <PackageReference Include="Microsoft.Agents.AI.OpenAI" Version="1.0.0-preview.251125.1" />
-    <PackageReference Include="Microsoft.Extensions.AI.OpenAI" Version="10.1.0-preview.1.25608.1" />
+    <PackageReference Include="Microsoft.Agents.AI.OpenAI" Version="1.0.0-preview.251219.1" />
+    <PackageReference Include="Microsoft.Extensions.AI.OpenAI" Version="10.1.1-preview.1.25612.2" />
   </ItemGroup>
 
   <!-- Add analyzers with compatible versions -->

dotnet/samples/HostedAgents/AgentWithHostedMCP/Program.cs

@@ -9,7 +9,7 @@ using Azure.AI.OpenAI;
 using Azure.Identity;
 using Microsoft.Agents.AI;
 using Microsoft.Extensions.AI;
-using OpenAI;
+using OpenAI.Responses;
 
 var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
 var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
@@ -25,7 +25,7 @@ AITool mcpTool = new HostedMcpServerTool(serverName: "microsoft_learn", serverAd
 AIAgent agent = new AzureOpenAIClient(
     new Uri(endpoint),
     new DefaultAzureCredential())
-    .GetOpenAIResponseClient(deploymentName)
+    .GetResponsesClient(deploymentName)
     .CreateAIAgent(
         instructions: "You answer questions by searching the Microsoft Learn content only.",
         name: "MicrosoftLearnAgent",

dotnet/samples/HostedAgents/AgentWithTextSearchRag/AgentWithTextSearchRag.csproj

@@ -38,8 +38,8 @@
     <PackageReference Include="Azure.AI.AgentServer.AgentFramework" Version="1.0.0-beta.5" />
     <PackageReference Include="Azure.AI.OpenAI" Version="2.7.0-beta.2" />
     <PackageReference Include="Azure.Identity" Version="1.17.1" />
-    <PackageReference Include="Microsoft.Agents.AI.OpenAI" Version="1.0.0-preview.251125.1" />
-    <PackageReference Include="Microsoft.Extensions.AI.OpenAI" Version="10.1.0-preview.1.25608.1" />
+    <PackageReference Include="Microsoft.Agents.AI.OpenAI" Version="1.0.0-preview.251219.1" />
+    <PackageReference Include="Microsoft.Extensions.AI.OpenAI" Version="10.1.1-preview.1.25612.2" />
   </ItemGroup>
 
   <!-- Add analyzers with compatible versions -->

dotnet/samples/HostedAgents/AgentWithTextSearchRag/Program.cs

@@ -8,9 +8,8 @@ using Azure.AI.AgentServer.AgentFramework.Extensions;
 using Azure.AI.OpenAI;
 using Azure.Identity;
 using Microsoft.Agents.AI;
-using Microsoft.Agents.AI.Data;
 using Microsoft.Extensions.AI;
-using OpenAI;
+using OpenAI.Chat;
 
 var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
 var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
@@ -28,7 +27,10 @@ AIAgent agent = new AzureOpenAIClient(
     .GetChatClient(deploymentName)
     .CreateAIAgent(new ChatClientAgentOptions
     {
-        Instructions = "You are a helpful support specialist for Contoso Outdoors. Answer questions using the provided context and cite the source document when available.",
+        ChatOptions = new ChatOptions
+        {
+            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(MockSearchAsync, ctx.SerializedState, ctx.JsonSerializerOptions, textSearchOptions)
     });
 

dotnet/samples/HostedAgents/AgentsInWorkflows/AgentsInWorkflows.csproj

@@ -38,7 +38,7 @@
     <PackageReference Include="Azure.AI.AgentServer.AgentFramework" Version="1.0.0-beta.5" />
     <PackageReference Include="Azure.AI.OpenAI" Version="2.7.0-beta.2" />
     <PackageReference Include="Azure.Identity" Version="1.17.1" />
-    <PackageReference Include="Microsoft.Agents.AI.Workflows" Version="1.0.0-preview.251125.1" />
+    <PackageReference Include="Microsoft.Agents.AI.Workflows" Version="1.0.0-preview.251219.1" />
     <PackageReference Include="Microsoft.Extensions.AI.OpenAI" Version="10.1.0-preview.1.25608.1" />
   </ItemGroup>
 

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

@@ -24,7 +24,7 @@ namespace Microsoft.Agents.AI.A2A;
 /// Support for tasks will be added later as part of the long-running
 /// executions work.
 /// </remarks>
-internal sealed class A2AAgent : AIAgent
+public sealed class A2AAgent : AIAgent
 {
     private readonly A2AClient _a2aClient;
     private readonly string? _id;
@@ -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);
 
@@ -84,9 +84,13 @@ internal sealed class A2AAgent : AIAgent
         }
         else
         {
-            var a2aMessage = CreateA2AMessage(typedThread, messages);
+            MessageSendParams sendParams = new()
+            {
+                Message = CreateA2AMessage(typedThread, messages),
+                Metadata = options?.AdditionalProperties?.ToA2AMetadata()
+            };
 
-            a2aResponse = await this._a2aClient.SendMessageAsync(new MessageSendParams { Message = a2aMessage }, cancellationToken).ConfigureAwait(false);
+            a2aResponse = await this._a2aClient.SendMessageAsync(sendParams, cancellationToken).ConfigureAwait(false);
         }
 
         this._logger.LogAgentChatClientInvokedAgent(nameof(RunAsync), this.Id, this.Name);
@@ -131,7 +135,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);
 
@@ -154,9 +158,13 @@ internal sealed class A2AAgent : AIAgent
             // a2aSseEvents = this._a2aClient.SubscribeToTaskAsync(token.TaskId, cancellationToken).ConfigureAwait(false);  
         }
 
-        var a2aMessage = CreateA2AMessage(typedThread, messages);
+        MessageSendParams sendParams = new()
+        {
+            Message = CreateA2AMessage(typedThread, messages),
+            Metadata = options?.AdditionalProperties?.ToA2AMetadata()
+        };
 
-        a2aSseEvents = this._a2aClient.SendMessageStreamingAsync(new MessageSendParams { Message = a2aMessage }, cancellationToken).ConfigureAwait(false);
+        a2aSseEvents = this._a2aClient.SendMessageStreamingAsync(sendParams, cancellationToken).ConfigureAwait(false);
 
         this._logger.LogAgentChatClientInvokedAgent(nameof(RunStreamingAsync), this.Id, this.Name);
 
@@ -198,10 +206,10 @@ internal sealed class A2AAgent : AIAgent
     protected override string? IdCore => this._id;
 
     /// <inheritdoc/>
-    public override string? Name => this._name ?? base.Name;
+    public override string? Name => this._name;
 
     /// <inheritdoc/>
-    public override string? Description => this._description ?? base.Description;
+    public override string? Description => this._description;
 
     private A2AAgentThread GetA2AThread(AgentThread? thread, AgentRunOptions? options)
     {

dotnet/src/Microsoft.Agents.AI.A2A/Extensions/A2AMetadataExtensions.cs

@@ -14,6 +14,9 @@ internal static class A2AMetadataExtensions
     /// <summary>
     /// Converts a dictionary of metadata to an <see cref="AdditionalPropertiesDictionary"/>.
     /// </summary>
+    /// <remarks>
+    /// This method can be replaced by the one from A2A SDK once it is public.
+    /// </remarks>
     /// <param name="metadata">The metadata dictionary to convert.</param>
     /// <returns>The converted <see cref="AdditionalPropertiesDictionary"/>, or null if the input is null or empty.</returns>
     internal static AdditionalPropertiesDictionary? ToAdditionalProperties(this Dictionary<string, JsonElement>? metadata)

dotnet/src/Microsoft.Agents.AI.A2A/Extensions/AdditionalPropertiesDictionaryExtensions.cs

@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using System.Text.Json;
+using Microsoft.Agents.AI;
+
+namespace Microsoft.Extensions.AI;
+
+/// <summary>
+/// Extension methods for AdditionalPropertiesDictionary.
+/// </summary>
+internal static class AdditionalPropertiesDictionaryExtensions
+{
+    /// <summary>
+    /// Converts an <see cref="AdditionalPropertiesDictionary"/> to a dictionary of <see cref="JsonElement"/> values suitable for A2A metadata.
+    /// </summary>
+    /// <remarks>
+    /// This method can be replaced by the one from A2A SDK once it is available.
+    /// </remarks>
+    /// <param name="additionalProperties">The additional properties dictionary to convert, or <c>null</c>.</param>
+    /// <returns>A dictionary of JSON elements representing the metadata, or <c>null</c> if the input is null or empty.</returns>
+    internal static Dictionary<string, JsonElement>? ToA2AMetadata(this AdditionalPropertiesDictionary? additionalProperties)
+    {
+        if (additionalProperties is not { Count: > 0 })
+        {
+            return null;
+        }
+
+        var metadata = new Dictionary<string, JsonElement>();
+
+        foreach (var kvp in additionalProperties)
+        {
+            if (kvp.Value is JsonElement)
+            {
+                metadata[kvp.Key] = (JsonElement)kvp.Value!;
+                continue;
+            }
+
+            metadata[kvp.Key] = JsonSerializer.SerializeToElement(kvp.Value, A2AJsonUtilities.DefaultOptions.GetTypeInfo(typeof(object)));
+        }
+
+        return metadata;
+    }
+}

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/AgentRunResponse.cs

@@ -291,6 +291,15 @@ public class AgentRunResponse
         return updates;
     }
 
+    /// <summary>
+    /// Deserializes the response text into the given type.
+    /// </summary>
+    /// <typeparam name="T">The output type to deserialize into.</typeparam>
+    /// <returns>The result as the requested type.</returns>
+    /// <exception cref="InvalidOperationException">The result is not parsable into the requested type.</exception>
+    public T Deserialize<T>() =>
+        this.Deserialize<T>(AgentAbstractionsJsonUtilities.DefaultOptions);
+
     /// <summary>
     /// Deserializes the response text into the given type using the specified serializer options.
     /// </summary>
@@ -311,6 +320,15 @@ public class AgentRunResponse
         };
     }
 
+    /// <summary>
+    /// Tries to deserialize response text into the given type.
+    /// </summary>
+    /// <typeparam name="T">The output type to deserialize into.</typeparam>
+    /// <param name="structuredOutput">The parsed structured output.</param>
+    /// <returns><see langword="true" /> if parsing was successful; otherwise, <see langword="false" />.</returns>
+    public bool TryDeserialize<T>([NotNullWhen(true)] out T? structuredOutput) =>
+        this.TryDeserialize(AgentAbstractionsJsonUtilities.DefaultOptions, out structuredOutput);
+
     /// <summary>
     /// Tries to deserialize response text into the given type using the specified serializer options.
     /// </summary>

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/AgentEntity.cs

@@ -216,8 +216,7 @@ internal class AgentEntity(IServiceProvider services, CancellationToken cancella
 
     private AIAgent GetAgent(AgentSessionId sessionId)
     {
-        IReadOnlyDictionary<string, Func<IServiceProvider, AIAgent>> agents =
-            this._services.GetRequiredService<IReadOnlyDictionary<string, Func<IServiceProvider, AIAgent>>>();
+        IReadOnlyDictionary<string, Func<IServiceProvider, AIAgent>> agents = this._options.GetAgentFactories();
         if (!agents.TryGetValue(sessionId.Name, out Func<IServiceProvider, AIAgent>? agentFactory))
         {
             throw new InvalidOperationException($"Agent '{sessionId.Name}' not found");

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/DurableAgentsOptions.cs

@@ -10,8 +10,12 @@ public sealed class DurableAgentsOptions
     // Agent names are case-insensitive
     private readonly Dictionary<string, Func<IServiceProvider, AIAgent>> _agentFactories = new(StringComparer.OrdinalIgnoreCase);
     private readonly Dictionary<string, TimeSpan?> _agentTimeToLive = new(StringComparer.OrdinalIgnoreCase);
+    private readonly HashSet<string> _workflowOnlyAgents = new(StringComparer.OrdinalIgnoreCase);
 
-    internal DurableAgentsOptions()
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DurableAgentsOptions"/> class.
+    /// </summary>
+    public DurableAgentsOptions()
     {
     }
 
@@ -101,6 +105,22 @@ public sealed class DurableAgentsOptions
     /// Thrown when <paramref name="agent.Name"/> is null or whitespace or when an agent with the same name has already been registered.
     /// </exception>
     public DurableAgentsOptions AddAIAgent(AIAgent agent, TimeSpan? timeToLive = null)
+    {
+        return this.AddAIAgent(agent, workflowOnly: false, timeToLive);
+    }
+
+    /// <summary>
+    /// Adds an AI agent to the options with workflow-only configuration.
+    /// </summary>
+    /// <param name="agent">The agent to add.</param>
+    /// <param name="workflowOnly">If true, the agent is only accessible within workflows and won't have HTTP triggers.</param>
+    /// <param name="timeToLive">Optional time-to-live for this agent's entities. If not specified, uses <see cref="DefaultTimeToLive"/>.</param>
+    /// <returns>The options instance.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="agent"/> is null.</exception>
+    /// <exception cref="ArgumentException">
+    /// Thrown when <paramref name="agent.Name"/> is null or whitespace or when an agent with the same name has already been registered.
+    /// </exception>
+    public DurableAgentsOptions AddAIAgent(AIAgent agent, bool workflowOnly, TimeSpan? timeToLive = null)
     {
         ArgumentNullException.ThrowIfNull(agent);
 
@@ -120,6 +140,11 @@ public sealed class DurableAgentsOptions
             this._agentTimeToLive[agent.Name] = timeToLive;
         }
 
+        if (workflowOnly)
+        {
+            this._workflowOnlyAgents.Add(agent.Name);
+        }
+
         return this;
     }
 
@@ -141,4 +166,24 @@ public sealed class DurableAgentsOptions
     {
         return this._agentTimeToLive.TryGetValue(agentName, out TimeSpan? ttl) ? ttl : this.DefaultTimeToLive;
     }
+
+    /// <summary>
+    /// Determines whether an agent is configured as workflow-only (no HTTP triggers).
+    /// </summary>
+    /// <param name="agentName">The name of the agent.</param>
+    /// <returns><see langword="true"/> if the agent is workflow-only; otherwise, <see langword="false"/>.</returns>
+    internal bool IsWorkflowOnly(string agentName)
+    {
+        return this._workflowOnlyAgents.Contains(agentName);
+    }
+
+    /// <summary>
+    /// Determines whether an agent with the specified name is already registered.
+    /// </summary>
+    /// <param name="agentName">The name of the agent.</param>
+    /// <returns><see langword="true"/> if an agent with the name is registered; otherwise, <see langword="false"/>.</returns>
+    internal bool ContainsAgent(string agentName)
+    {
+        return this._agentFactories.ContainsKey(agentName);
+    }
 }

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

@@ -0,0 +1,269 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Diagnostics.CodeAnalysis;
+using System.Text.Json;
+using Microsoft.Agents.AI.Workflows;
+using Microsoft.DurableTask.Client;
+using Microsoft.DurableTask.Client.Entities;
+using Microsoft.DurableTask.Entities;
+
+namespace Microsoft.Agents.AI.DurableTask;
+
+/// <summary>
+/// An implementation of <see cref="IWorkflowContext"/> for workflow executors running as durable activities.
+/// Provides durable state management using Durable Entities. State is scoped to the orchestration instance
+/// and shared between executors running on potentially different compute instances.
+/// </summary>
+/// <remarks>
+/// State operations use GetEntityAsync for reads (fetches current entity state) and SignalEntityAsync
+/// for writes. Since activities run sequentially in the orchestration and entity signals are processed
+/// in order, state consistency is maintained across executors.
+/// </remarks>
+[RequiresUnreferencedCode("State serialization uses reflection-based JSON serialization.")]
+[RequiresDynamicCode("State serialization uses reflection-based JSON serialization.")]
+public sealed class DurableExecutorContext : IWorkflowContext
+{
+    private readonly string _instanceId;
+    private readonly DurableTaskClient _client;
+    private readonly Dictionary<string, string?> _pendingUpdates = [];
+    private readonly HashSet<string> _clearedScopes = [];
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DurableExecutorContext"/> class.
+    /// </summary>
+    /// <param name="instanceId">The orchestration instance ID used to scope the state entity.</param>
+    /// <param name="client">The durable task client for entity operations.</param>
+    public DurableExecutorContext(string instanceId, DurableTaskClient client)
+    {
+        this._instanceId = instanceId;
+        this._client = client;
+    }
+
+    /// <inheritdoc/>
+    public ValueTask AddEventAsync(WorkflowEvent workflowEvent, CancellationToken cancellationToken = default)
+    {
+        // In activity context, events are not propagated to the workflow
+        return default;
+    }
+
+    /// <inheritdoc/>
+    public ValueTask SendMessageAsync(object message, string? targetId = null, CancellationToken cancellationToken = default)
+    {
+        // In activity context, messages cannot be routed to other executors
+        return default;
+    }
+
+    /// <inheritdoc/>
+    public ValueTask YieldOutputAsync(object output, CancellationToken cancellationToken = default)
+    {
+        // In activity context, outputs are not yielded to the workflow
+        return default;
+    }
+
+    /// <inheritdoc/>
+    public ValueTask RequestHaltAsync()
+    {
+        // Halt requests are not supported in activity context
+        return default;
+    }
+
+    /// <inheritdoc/>
+    public async ValueTask<T?> ReadStateAsync<T>(string key, string? scopeName = null, CancellationToken cancellationToken = default)
+    {
+        string scopeKey = GetScopeKey(scopeName, key);
+
+        // 1. Check pending updates first (read-your-writes within this activity)
+        if (this._pendingUpdates.TryGetValue(scopeKey, out string? pendingValue))
+        {
+            return pendingValue is null ? default : JsonSerializer.Deserialize<T>(pendingValue);
+        }
+
+        // 2. Check if the scope was cleared in this activity
+        string normalizedScope = scopeName ?? "__default__";
+        if (this._clearedScopes.Contains(normalizedScope))
+        {
+            return default;
+        }
+
+        // 3. Read from the durable entity
+        EntityInstanceId entityId = this.GetStateEntityId();
+
+        EntityMetadata? metadata = await this._client.Entities
+            .GetEntityAsync(entityId, includeState: true, cancellation: cancellationToken)
+            .ConfigureAwait(false);
+
+        if (metadata?.IncludesState != true)
+        {
+            return default;
+        }
+
+        WorkflowStateData? stateData = metadata.State.ReadAs<WorkflowStateData>();
+        if (stateData?.Values is null)
+        {
+            return default;
+        }
+
+        if (stateData.Values.TryGetValue(scopeKey, out string? serializedValue) && serializedValue is not null)
+        {
+            return JsonSerializer.Deserialize<T>(serializedValue);
+        }
+
+        return default;
+    }
+
+    /// <inheritdoc/>
+    public async ValueTask<T> ReadOrInitStateAsync<T>(string key, Func<T> initialStateFactory, string? scopeName = null, CancellationToken cancellationToken = default)
+    {
+        T? value = await this.ReadStateAsync<T>(key, scopeName, cancellationToken).ConfigureAwait(false);
+
+        if (value is not null)
+        {
+            return value;
+        }
+
+        // Initialize with factory value and write to entity
+        T initialValue = initialStateFactory();
+        await this.QueueStateUpdateAsync(key, initialValue, scopeName, cancellationToken).ConfigureAwait(false);
+        return initialValue;
+    }
+
+    /// <inheritdoc/>
+    public async ValueTask<HashSet<string>> ReadStateKeysAsync(string? scopeName = null, CancellationToken cancellationToken = default)
+    {
+        string normalizedScope = scopeName ?? "__default__";
+        string scopePrefix = GetScopePrefix(scopeName);
+        HashSet<string> keys = [];
+
+        // If scope was cleared, only return keys from pending updates
+        if (this._clearedScopes.Contains(normalizedScope))
+        {
+            return this.GetPendingKeysForScope(scopeName);
+        }
+
+        // Read keys from the durable entity
+        EntityInstanceId entityId = this.GetStateEntityId();
+
+        EntityMetadata? metadata = await this._client.Entities
+            .GetEntityAsync(entityId, includeState: true, cancellation: cancellationToken)
+            .ConfigureAwait(false);
+
+        if (metadata?.IncludesState == true)
+        {
+            WorkflowStateData? stateData = metadata.State.ReadAs<WorkflowStateData>();
+            if (stateData?.Values is not null)
+            {
+                foreach (string scopeKey in stateData.Values.Keys)
+                {
+                    if (scopeKey.StartsWith(scopePrefix, StringComparison.Ordinal))
+                    {
+                        string foundKey = scopeKey[scopePrefix.Length..];
+                        keys.Add(foundKey);
+                    }
+                }
+            }
+        }
+
+        // Merge with pending updates
+        foreach (KeyValuePair<string, string?> pending in this._pendingUpdates)
+        {
+            if (pending.Key.StartsWith(scopePrefix, StringComparison.Ordinal))
+            {
+                string foundKey = pending.Key[scopePrefix.Length..];
+                if (pending.Value is not null)
+                {
+                    keys.Add(foundKey);
+                }
+                else
+                {
+                    keys.Remove(foundKey);
+                }
+            }
+        }
+
+        return keys;
+    }
+
+    /// <inheritdoc/>
+    public async ValueTask QueueStateUpdateAsync<T>(string key, T? value, string? scopeName = null, CancellationToken cancellationToken = default)
+    {
+        string scopeKey = GetScopeKey(scopeName, key);
+        string? serializedValue = value is null ? null : JsonSerializer.Serialize(value);
+
+        // Store locally for read-your-writes within this activity
+        this._pendingUpdates[scopeKey] = serializedValue;
+
+        // Write to the durable entity via signal
+        // Since activities run sequentially and signals are processed in order,
+        // the next activity will see this update when it reads from the entity
+        EntityInstanceId entityId = this.GetStateEntityId();
+        WorkflowStateWriteRequest request = new() { Key = key, ScopeName = scopeName, Value = serializedValue };
+
+        await this._client.Entities
+            .SignalEntityAsync(entityId, nameof(WorkflowSharedStateEntity.WriteState), request, cancellation: cancellationToken)
+            .ConfigureAwait(false);
+    }
+
+    /// <inheritdoc/>
+    public async ValueTask QueueClearScopeAsync(string? scopeName = null, CancellationToken cancellationToken = default)
+    {
+        string normalizedScope = scopeName ?? "__default__";
+        this._clearedScopes.Add(normalizedScope);
+
+        // Remove pending updates in this scope
+        string scopePrefix = GetScopePrefix(scopeName);
+        List<string> keysToRemove = this._pendingUpdates.Keys
+            .Where(k => k.StartsWith(scopePrefix, StringComparison.Ordinal))
+            .ToList();
+
+        foreach (string key in keysToRemove)
+        {
+            this._pendingUpdates.Remove(key);
+        }
+
+        // Clear in the durable entity via signal
+        EntityInstanceId entityId = this.GetStateEntityId();
+
+        await this._client.Entities
+            .SignalEntityAsync(entityId, nameof(WorkflowSharedStateEntity.ClearScope), scopeName, cancellation: cancellationToken)
+            .ConfigureAwait(false);
+    }
+
+    /// <inheritdoc/>
+    public IReadOnlyDictionary<string, string>? TraceContext => null;
+
+    /// <inheritdoc/>
+    public bool ConcurrentRunsEnabled => false;
+
+    private EntityInstanceId GetStateEntityId()
+    {
+        // Entity is keyed by orchestration instance ID for isolation between runs
+        return new EntityInstanceId(WorkflowSharedStateEntity.EntityName, this._instanceId);
+    }
+
+    private HashSet<string> GetPendingKeysForScope(string? scopeName)
+    {
+        string scopePrefix = GetScopePrefix(scopeName);
+        HashSet<string> keys = [];
+
+        foreach (KeyValuePair<string, string?> pending in this._pendingUpdates)
+        {
+            if (pending.Key.StartsWith(scopePrefix, StringComparison.Ordinal) && pending.Value is not null)
+            {
+                string key = pending.Key[scopePrefix.Length..];
+                keys.Add(key);
+            }
+        }
+
+        return keys;
+    }
+
+    private static string GetScopeKey(string? scopeName, string key)
+    {
+        return $"{GetScopePrefix(scopeName)}{key}";
+    }
+
+    private static string GetScopePrefix(string? scopeName)
+    {
+        return scopeName is null ? "__default__:" : $"{scopeName}:";
+    }
+}

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

@@ -0,0 +1,27 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+namespace Microsoft.Agents.AI.DurableTask;
+
+/// <summary>
+/// Provides configuration options for durable agents and workflows.
+/// </summary>
+public sealed class DurableOptions
+{
+    /// <summary>
+    /// Gets the configuration options for durable agents.
+    /// </summary>
+    public DurableAgentsOptions Agents { get; } = new();
+
+    /// <summary>
+    /// Gets the configuration options for durable workflows.
+    /// </summary>
+    public DurableWorkflowOptions Workflows { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DurableOptions"/> class.
+    /// </summary>
+    internal DurableOptions()
+    {
+        this.Workflows = new DurableWorkflowOptions(this);
+    }
+}

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

@@ -0,0 +1,100 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Agents.AI.Workflows;
+using Microsoft.Agents.AI.Workflows.Checkpointing;
+
+namespace Microsoft.Agents.AI.DurableTask;
+
+/// <summary>
+/// Provides configuration options for managing durable workflows within an application.
+/// </summary>
+public sealed class DurableWorkflowOptions
+{
+    private readonly Dictionary<string, Workflow> _workflows = new(StringComparer.OrdinalIgnoreCase);
+    private readonly DurableOptions? _parentOptions;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DurableWorkflowOptions"/> class.
+    /// </summary>
+    /// <param name="parentOptions">Optional parent options container for accessing related configuration.</param>
+    internal DurableWorkflowOptions(DurableOptions? parentOptions = null)
+    {
+        this._parentOptions = parentOptions;
+        this.Executors = new ExecutorRegistry();
+    }
+
+    /// <summary>
+    /// Gets the collection of workflows available in the current context, keyed by their unique names.
+    /// </summary>
+    public IReadOnlyDictionary<string, Workflow> Workflows => this._workflows;
+
+    /// <summary>
+    /// Gets the executor registry for direct executor lookup.
+    /// </summary>
+    internal ExecutorRegistry Executors { get; }
+
+    /// <summary>
+    /// Adds a workflow to the collection for processing or execution.
+    /// </summary>
+    /// <param name="workflow">The workflow instance to add. Cannot be null.</param>
+    /// <remarks>
+    /// When a workflow is added, any AI agent executors in the workflow will be automatically
+    /// registered with the <see cref="DurableAgentsOptions"/> if it was provided during construction.
+    /// </remarks>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="workflow"/> is null.</exception>
+    /// <exception cref="ArgumentException">Thrown when the workflow does not have a valid name.</exception>
+    public void AddWorkflow(Workflow workflow)
+    {
+        ArgumentNullException.ThrowIfNull(workflow);
+
+        if (string.IsNullOrEmpty(workflow.Name))
+        {
+            throw new ArgumentException("Workflow must have a valid Name property.", nameof(workflow));
+        }
+
+        this._workflows[workflow.Name] = workflow;
+
+        RegisterExecutors(workflow, this.Executors);
+
+        DurableAgentsOptions? agentOptions = this._parentOptions?.Agents;
+        if (agentOptions is not null)
+        {
+            RegisterAgenticExecutors(workflow, agentOptions);
+        }
+    }
+
+    /// <summary>
+    /// Adds a collection of workflows to the current instance.
+    /// </summary>
+    /// <param name="workflows">The collection of <see cref="Workflow"/> objects to add. Cannot be <see langword="null"/>.</param>
+    public void AddWorkflows(IEnumerable<Workflow> workflows)
+    {
+        ArgumentNullException.ThrowIfNull(workflows);
+
+        foreach (var workflow in workflows)
+        {
+            this.AddWorkflow(workflow);
+        }
+    }
+
+    private static void RegisterExecutors(Workflow workflow, ExecutorRegistry registry)
+    {
+        foreach (KeyValuePair<string, ExecutorBinding> executor in workflow.ReflectExecutors())
+        {
+            int underscoreIndex = executor.Key.IndexOf('_');
+            string executorName = underscoreIndex > 0 ? executor.Key[..underscoreIndex] : executor.Key;
+            registry.Register(executorName, executor.Key, workflow);
+        }
+    }
+
+    private static void RegisterAgenticExecutors(Workflow workflow, DurableAgentsOptions agentOptions)
+    {
+        foreach (KeyValuePair<string, ExecutorBinding> executor in workflow.ReflectExecutors())
+        {
+            if (executor.Value.RawValue is AIAgent agent && agent.Name is not null && !agentOptions.ContainsAgent(agent.Name))
+            {
+                agentOptions.AddAIAgent(agent, workflowOnly: true);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,429 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Diagnostics.CodeAnalysis;
+using System.Text.Json;
+using Microsoft.Agents.AI.Workflows;
+using Microsoft.DurableTask;
+using Microsoft.DurableTask.Entities;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.Agents.AI.DurableTask;
+
+/// <summary>
+/// Core workflow runner that executes workflow orchestrations using Durable Tasks.
+/// This class contains the core workflow execution logic independent of the hosting environment.
+/// </summary>
+public class DurableWorkflowRunner
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DurableWorkflowRunner"/> class.
+    /// </summary>
+    /// <param name="logger">The logger instance.</param>
+    /// <param name="durableOptions">The durable options containing workflow configurations.</param>
+    public DurableWorkflowRunner(ILogger<DurableWorkflowRunner> logger, DurableOptions durableOptions)
+    {
+        ArgumentNullException.ThrowIfNull(logger);
+        ArgumentNullException.ThrowIfNull(durableOptions);
+
+        this.Logger = logger;
+        this.Options = durableOptions.Workflows;
+    }
+
+    /// <summary>
+    /// Gets the workflow options.
+    /// </summary>
+    protected DurableWorkflowOptions Options { get; }
+
+    /// <summary>
+    /// Gets the logger instance.
+    /// </summary>
+    protected ILogger Logger { get; }
+
+    /// <summary>
+    /// Runs a workflow orchestration.
+    /// </summary>
+    /// <param name="context">The task orchestration context.</param>
+    /// <param name="input">The workflow run input containing workflow name and input.</param>
+    /// <param name="logger">The replay-safe logger for orchestration logging.</param>
+    /// <returns>The result of the workflow execution.</returns>
+    /// <exception cref="InvalidOperationException">Thrown when the specified workflow is not found.</exception>
+    public async Task<string> RunWorkflowOrchestrationAsync(
+        TaskOrchestrationContext context,
+        string input,
+        ILogger logger)
+    {
+        ArgumentNullException.ThrowIfNull(context);
+        ArgumentNullException.ThrowIfNull(input);
+
+        string orchestrationName = context.Name;
+        string workflowName = WorkflowNamingHelper.ToWorkflowName(orchestrationName);
+        if (!this.Options.Workflows.TryGetValue(workflowName, out Workflow? workflow))
+        {
+            throw new InvalidOperationException($"Workflow '{workflowName}' not found.");
+        }
+
+        logger.LogRunningWorkflow(workflow.Name);
+
+        string result = await this.ExecuteWorkflowLevelsAsync(context, workflow, input, logger).ConfigureAwait(true);
+
+        await CleanupWorkflowStateAsync(context).ConfigureAwait(true);
+
+        return result;
+    }
+
+    /// <summary>
+    /// Cleans up the workflow state entity by signaling it to delete itself.
+    /// </summary>
+    private static async Task CleanupWorkflowStateAsync(TaskOrchestrationContext context)
+    {
+        EntityInstanceId stateEntityId = new(WorkflowSharedStateEntity.EntityName, context.InstanceId);
+
+        // Call the entity's Delete method to clean up state
+        // Using CallEntityAsync ensures the deletion completes before the orchestration finishes
+        await context.Entities.CallEntityAsync(stateEntityId, nameof(WorkflowSharedStateEntity.Delete)).ConfigureAwait(true);
+    }
+
+    /// <summary>
+    /// Parses the executor name from an activity function name.
+    /// </summary>
+    /// <param name="activityFunctionName">The activity function name.</param>
+    /// <returns>The extracted executor name.</returns>
+    protected static string ParseExecutorName(string activityFunctionName)
+    {
+        if (!activityFunctionName.StartsWith(WorkflowNamingHelper.OrchestrationFunctionPrefix, StringComparison.Ordinal))
+        {
+            throw new InvalidOperationException(
+                $"Activity function name '{activityFunctionName}' does not start with '{WorkflowNamingHelper.OrchestrationFunctionPrefix}' prefix.");
+        }
+
+        string executorName = activityFunctionName[WorkflowNamingHelper.OrchestrationFunctionPrefix.Length..];
+
+        if (string.IsNullOrEmpty(executorName))
+        {
+            throw new InvalidOperationException(
+                $"Activity function name '{activityFunctionName}' is not in the expected format '{WorkflowNamingHelper.OrchestrationFunctionPrefix}{{executorName}}'.");
+        }
+
+        return executorName;
+    }
+
+    /// <summary>
+    /// Serializes a list of strings to JSON.
+    /// </summary>
+    [UnconditionalSuppressMessage("AOT", "IL3050", Justification = "Serializing known types.")]
+    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Serializing known types.")]
+    protected static string SerializeToJson(List<string> values)
+    {
+        return JsonSerializer.Serialize(values);
+    }
+
+    /// <summary>
+    /// Serializes a result object to JSON or string.
+    /// </summary>
+    [UnconditionalSuppressMessage("AOT", "IL3050", Justification = "Serializing workflow types registered at startup.")]
+    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Serializing workflow types registered at startup.")]
+    protected static string SerializeResult(object? result)
+    {
+        if (result is null)
+        {
+            return string.Empty;
+        }
+
+        if (result is string str)
+        {
+            return str;
+        }
+
+        Type resultType = result.GetType();
+        if (resultType.IsPrimitive || resultType == typeof(decimal))
+        {
+            return result.ToString() ?? string.Empty;
+        }
+
+        return JsonSerializer.Serialize(result, resultType);
+    }
+
+    /// <summary>
+    /// Deserializes input from JSON to the target type.
+    /// </summary>
+    [UnconditionalSuppressMessage("AOT", "IL3050", Justification = "Deserializing workflow types registered at startup.")]
+    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Deserializing workflow types registered at startup.")]
+    protected static object DeserializeInput(string input, Type targetType)
+    {
+        if (targetType == typeof(string))
+        {
+            return input;
+        }
+
+        string json = input;
+        if (input.StartsWith('"') && input.EndsWith('"'))
+        {
+            try
+            {
+                string? innerJson = JsonSerializer.Deserialize<string>(input);
+                if (innerJson is not null)
+                {
+                    json = innerJson;
+                }
+            }
+            catch (JsonException)
+            {
+                // Not double-serialized, use original
+            }
+        }
+
+        return JsonSerializer.Deserialize(json, targetType)
+            ?? throw new InvalidOperationException($"Failed to deserialize input to type '{targetType.Name}'.");
+    }
+
+    private async Task<string> ExecuteWorkflowLevelsAsync(
+        TaskOrchestrationContext context,
+        Workflow workflow,
+        string initialInput,
+        ILogger logger)
+    {
+        WorkflowExecutionPlan plan = WorkflowHelper.GetExecutionPlan(workflow);
+        Dictionary<string, string> results = [];
+
+        foreach (WorkflowExecutionLevel level in plan.Levels)
+        {
+            // Filter executors based on edge conditions from their predecessors
+            List<WorkflowExecutorInfo> eligibleExecutors = GetEligibleExecutors(level.Executors, results, plan, logger);
+
+            if (eligibleExecutors.Count == 0)
+            {
+                // No eligible executors at this level, continue to next level
+                continue;
+            }
+
+            if (eligibleExecutors.Count == 1)
+            {
+                WorkflowExecutorInfo executorInfo = eligibleExecutors[0];
+                string input = GetExecutorInput(executorInfo.ExecutorId, initialInput, results, plan);
+                results[executorInfo.ExecutorId] = await this.ExecuteExecutorAsync(context, executorInfo, input, logger).ConfigureAwait(true);
+            }
+            else
+            {
+                List<Task<(string Id, string Result)>> tasks = [];
+                foreach (WorkflowExecutorInfo executorInfo in eligibleExecutors)
+                {
+                    string input = GetExecutorInput(executorInfo.ExecutorId, initialInput, results, plan);
+                    tasks.Add(this.ExecuteExecutorWithIdAsync(context, executorInfo, input, logger));
+                }
+
+                foreach ((string id, string result) in await Task.WhenAll(tasks).ConfigureAwait(true))
+                {
+                    results[id] = result;
+                }
+            }
+        }
+
+        return GetFinalResult(plan, results);
+    }
+
+    /// <summary>
+    /// Filters executors based on their incoming edge conditions.
+    /// An executor is eligible if all its incoming edges have conditions that evaluate to true,
+    /// or if the edges have no conditions.
+    /// </summary>
+    [UnconditionalSuppressMessage("AOT", "IL3050", Justification = "Deserializing workflow types registered at startup.")]
+    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Deserializing workflow types registered at startup.")]
+    private static List<WorkflowExecutorInfo> GetEligibleExecutors(
+        List<WorkflowExecutorInfo> executors,
+        Dictionary<string, string> results,
+        WorkflowExecutionPlan plan,
+        ILogger logger)
+    {
+        List<WorkflowExecutorInfo> eligible = [];
+
+        foreach (WorkflowExecutorInfo executorInfo in executors)
+        {
+            List<string> predecessors = plan.Predecessors[executorInfo.ExecutorId];
+
+            // Root executor (no predecessors) is always eligible
+            if (predecessors.Count == 0)
+            {
+                eligible.Add(executorInfo);
+                continue;
+            }
+
+            // Check if any predecessor's edge condition allows this executor to run
+            bool isEligible = false;
+            foreach (string predecessorId in predecessors)
+            {
+                // Get the condition for this edge (predecessor -> current executor)
+                if (!plan.EdgeConditions.TryGetValue((predecessorId, executorInfo.ExecutorId), out Func<object?, bool>? condition))
+                {
+                    // No condition registered for this edge, assume it's eligible
+                    isEligible = true;
+                    break;
+                }
+
+                if (condition is null)
+                {
+                    // Edge has no condition, always eligible
+                    isEligible = true;
+                    break;
+                }
+
+                // Evaluate the condition using the predecessor's result
+                if (results.TryGetValue(predecessorId, out string? predecessorResult))
+                {
+                    try
+                    {
+                        // Get the predecessor's output type for proper deserialization
+                        Type? predecessorOutputType = plan.ExecutorOutputTypes.GetValueOrDefault(predecessorId);
+
+                        // Deserialize the predecessor result to the expected type for condition evaluation
+                        object? resultObject = DeserializeForCondition(predecessorResult, predecessorOutputType);
+                        if (condition(resultObject))
+                        {
+                            isEligible = true;
+                            break;
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        logger.LogWarning(ex, "Failed to evaluate condition for edge from '{PredecessorId}' to '{ExecutorId}'", predecessorId, executorInfo.ExecutorId);
+                    }
+                }
+            }
+
+            if (isEligible)
+            {
+                eligible.Add(executorInfo);
+            }
+            else
+            {
+                logger.LogExecutorSkipped(executorInfo.ExecutorId);
+            }
+        }
+
+        return eligible;
+    }
+
+    /// <summary>
+    /// Deserializes a JSON string result into an object for condition evaluation.
+    /// </summary>
+    [UnconditionalSuppressMessage("AOT", "IL3050", Justification = "Deserializing workflow types registered at startup.")]
+    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Deserializing workflow types registered at startup.")]
+    private static object? DeserializeForCondition(string json, Type? targetType)
+    {
+        if (string.IsNullOrEmpty(json))
+        {
+            return null;
+        }
+
+        try
+        {
+            if (targetType is null)
+            {
+                return JsonSerializer.Deserialize<object>(json);
+            }
+
+            return JsonSerializer.Deserialize(json, targetType);
+        }
+        catch (JsonException)
+        {
+            // If it's not valid JSON, return the string as-is
+            return json;
+        }
+    }
+
+    private async Task<(string Id, string Result)> ExecuteExecutorWithIdAsync(
+        TaskOrchestrationContext context,
+        WorkflowExecutorInfo executorInfo,
+        string input,
+        ILogger logger)
+    {
+        string result = await this.ExecuteExecutorAsync(context, executorInfo, input, logger).ConfigureAwait(true);
+        return (executorInfo.ExecutorId, result);
+    }
+
+    private async Task<string> ExecuteExecutorAsync(
+        TaskOrchestrationContext context,
+        WorkflowExecutorInfo executorInfo,
+        string input,
+        ILogger logger)
+    {
+        if (!executorInfo.IsAgenticExecutor)
+        {
+            string executorName = WorkflowNamingHelper.GetExecutorName(executorInfo.ExecutorId);
+            string triggerName = WorkflowNamingHelper.ToOrchestrationFunctionName(executorName);
+            return await context.CallActivityAsync<string>(triggerName, input).ConfigureAwait(true);
+        }
+
+        return await ExecuteAgentAsync(context, executorInfo, input, logger).ConfigureAwait(true);
+    }
+
+    private static async Task<string> ExecuteAgentAsync(
+        TaskOrchestrationContext context,
+        WorkflowExecutorInfo executorInfo,
+        string input,
+        ILogger logger)
+    {
+        string agentName = WorkflowNamingHelper.GetExecutorName(executorInfo.ExecutorId);
+        DurableAIAgent agent = context.GetAgent(agentName);
+
+        if (agent is null)
+        {
+            logger.LogWarning("Agent '{AgentName}' not found", agentName);
+            return $"Agent '{agentName}' not found";
+        }
+
+        AgentThread thread = agent.GetNewThread();
+        AgentRunResponse response = await agent.RunAsync(input, thread).ConfigureAwait(true);
+        return response.Text;
+    }
+
+    private static string GetExecutorInput(
+        string executorId,
+        string initialInput,
+        Dictionary<string, string> results,
+        WorkflowExecutionPlan plan)
+    {
+        List<string> predecessors = plan.Predecessors[executorId];
+
+        if (predecessors.Count == 0)
+        {
+            return initialInput;
+        }
+
+        if (predecessors.Count == 1)
+        {
+            return results.TryGetValue(predecessors[0], out string? result) ? result : initialInput;
+        }
+
+        List<string> aggregated = [];
+        foreach (string predecessorId in predecessors)
+        {
+            if (results.TryGetValue(predecessorId, out string? result))
+            {
+                aggregated.Add(result);
+            }
+        }
+
+        return SerializeToJson(aggregated);
+    }
+
+    private static string GetFinalResult(WorkflowExecutionPlan plan, Dictionary<string, string> results)
+    {
+        WorkflowExecutionLevel lastLevel = plan.Levels[^1];
+
+        if (lastLevel.Executors.Count == 1)
+        {
+            return results[lastLevel.Executors[0].ExecutorId];
+        }
+
+        List<string> finalResults = [];
+        foreach (WorkflowExecutorInfo executor in lastLevel.Executors)
+        {
+            if (results.TryGetValue(executor.ExecutorId, out string? result))
+            {
+                finalResults.Add(result);
+            }
+        }
+
+        return string.Join("\n---\n", finalResults);
+    }
+}

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.DurableTask/ExecutorRegistry.cs

@@ -0,0 +1,74 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Agents.AI.Workflows;
+
+namespace Microsoft.Agents.AI.DurableTask;
+
+/// <summary>
+/// Provides a registry for storing and retrieving executor bindings independently from workflows.
+/// </summary>
+internal sealed class ExecutorRegistry
+{
+    private readonly Dictionary<string, ExecutorRegistration> _executors = new(StringComparer.OrdinalIgnoreCase);
+
+    /// <summary>
+    /// Gets the number of registered executors.
+    /// </summary>
+    public int Count => this._executors.Count;
+
+    /// <summary>
+    /// Attempts to get an executor registration by name.
+    /// </summary>
+    /// <param name="executorName">The executor name to look up.</param>
+    /// <param name="registration">When this method returns, contains the registration if found; otherwise, null.</param>
+    /// <returns><see langword="true"/> if the executor was found; otherwise, <see langword="false"/>.</returns>
+    public bool TryGetExecutor(string executorName, out ExecutorRegistration? registration)
+    {
+        return this._executors.TryGetValue(executorName, out registration);
+    }
+
+    /// <summary>
+    /// Registers an executor binding from a workflow.
+    /// </summary>
+    /// <param name="executorName">The executor name (without GUID suffix).</param>
+    /// <param name="executorId">The full executor ID (may include GUID suffix).</param>
+    /// <param name="workflow">The workflow containing the executor.</param>
+    internal void Register(string executorName, string executorId, Workflow workflow)
+    {
+        ArgumentException.ThrowIfNullOrEmpty(executorName);
+        ArgumentException.ThrowIfNullOrEmpty(executorId);
+        ArgumentNullException.ThrowIfNull(workflow);
+
+        Dictionary<string, ExecutorBinding> bindings = workflow.ReflectExecutors();
+        if (!bindings.TryGetValue(executorId, out ExecutorBinding? binding))
+        {
+            throw new InvalidOperationException($"Executor '{executorId}' not found in workflow.");
+        }
+
+        this._executors.TryAdd(executorName, new ExecutorRegistration(executorId, binding));
+    }
+}
+
+/// <summary>
+/// Represents a registered executor with its associated workflow.
+/// </summary>
+/// <param name="ExecutorId">The full executor ID (may include GUID suffix).</param>
+/// <param name="Binding">The executor binding from the workflow.</param>
+internal sealed record ExecutorRegistration(string ExecutorId, ExecutorBinding Binding)
+{
+    /// <summary>
+    /// Creates an instance of the executor.
+    /// </summary>
+    /// <param name="runId">A unique identifier for the run context.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The created executor instance.</returns>
+    public async ValueTask<Executor> CreateExecutorInstanceAsync(string runId, CancellationToken cancellationToken = default)
+    {
+        if (this.Binding.FactoryAsync is null)
+        {
+            throw new InvalidOperationException($"Cannot create executor '{this.ExecutorId}': Binding is a placeholder.");
+        }
+
+        return await this.Binding.FactoryAsync(runId).ConfigureAwait(false);
+    }
+}

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

@@ -100,4 +100,40 @@ internal static partial class Logs
     public static partial void LogTTLExpirationTimeCleared(
         this ILogger logger,
         AgentSessionId sessionId);
+
+    [LoggerMessage(
+        EventId = 12,
+        Level = LogLevel.Debug,
+        Message = "Attempting to run workflow: {WorkflowName}")]
+    public static partial void LogAttemptingToRunWorkflow(this ILogger logger, string workflowName);
+
+    [LoggerMessage(
+        EventId = 13,
+        Level = LogLevel.Debug,
+        Message = "Running workflow: {WorkflowName}")]
+    public static partial void LogRunningWorkflow(this ILogger logger, string? workflowName);
+
+    [LoggerMessage(
+        EventId = 14,
+        Level = LogLevel.Debug,
+        Message = "Attempting to execute activity in workflow '{WorkflowName}' for executor '{ExecutorName}'")]
+    public static partial void LogAttemptingToExecuteActivity(this ILogger logger, string workflowName, string executorName);
+
+    [LoggerMessage(
+        EventId = 15,
+        Level = LogLevel.Debug,
+        Message = "Executing activity for executor '{ExecutorId}' of type '{ExecutorType}'")]
+    public static partial void LogExecutingActivity(this ILogger logger, string executorId, string executorType);
+
+    [LoggerMessage(
+        EventId = 16,
+        Level = LogLevel.Debug,
+        Message = "Activity executed for executor '{ExecutorId}' with result: {Result}")]
+    public static partial void LogActivityExecuted(this ILogger logger, string executorId, string result);
+
+    [LoggerMessage(
+        EventId = 17,
+        Level = LogLevel.Debug,
+        Message = "Executor '{ExecutorId}' skipped due to edge condition evaluation")]
+    public static partial void LogExecutorSkipped(this ILogger logger, string executorId);
 }

dotnet/src/Microsoft.Agents.AI.DurableTask/Microsoft.Agents.AI.DurableTask.csproj

@@ -21,9 +21,11 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.DurableTask.Client" />
     <PackageReference Include="Microsoft.DurableTask.Worker" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" />
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\Microsoft.Agents.AI.Workflows\Microsoft.Agents.AI.Workflows.csproj" />
     <ProjectReference Include="..\Microsoft.Agents.AI\Microsoft.Agents.AI.csproj" />
   </ItemGroup>
 

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

@@ -8,6 +8,7 @@ using Microsoft.DurableTask;
 using Microsoft.DurableTask.Client;
 using Microsoft.DurableTask.Worker;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
 
 namespace Microsoft.Agents.AI.DurableTask;
 
@@ -80,23 +81,45 @@ public static class ServiceCollectionExtensions
         DurableAgentsOptions options = new();
         configure(options);
 
-        IReadOnlyDictionary<string, Func<IServiceProvider, AIAgent>> agents = options.GetAgentFactories();
+        IReadOnlyDictionary<string, Func<IServiceProvider, AIAgent>> newAgents = options.GetAgentFactories();
 
-        // The agent dictionary contains the real agent factories, which is used by the agent entities.
-        services.AddSingleton(agents);
+        // Check if we already have DurableAgentsOptions registered and merge with it
+        ServiceDescriptor? existingOptionsDescriptor = services.FirstOrDefault(
+            d => d.ServiceType == typeof(DurableAgentsOptions));
 
-        // Register the options so AgentEntity can access TTL configuration
-        services.AddSingleton(options);
+        if (existingOptionsDescriptor?.ImplementationInstance is DurableAgentsOptions existingOptions)
+        {
+            // Merge new agents into the existing options
+            foreach (KeyValuePair<string, Func<IServiceProvider, AIAgent>> agent in newAgents)
+            {
+                if (!existingOptions.ContainsAgent(agent.Key))
+                {
+                    existingOptions.AddAIAgentFactory(agent.Key, agent.Value, options.GetTimeToLive(agent.Key));
+                }
+            }
+
+            options = existingOptions;
+        }
+        else
+        {
+            // Register the options so AgentEntity can access configuration
+            services.AddSingleton(options);
+        }
 
         // The keyed services are used to resolve durable agent *proxy* instances for external clients.
-        foreach (var factory in agents)
+        foreach (var factory in newAgents)
         {
             services.AddKeyedSingleton(factory.Key, (sp, _) => factory.Value(sp).AsDurableAgentProxy(sp));
         }
 
+        // Register the agent factories dictionary for backward compatibility.
+        // This allows consumers to retrieve agents via services.GetService<IReadOnlyDictionary<string, Func<IServiceProvider, AIAgent>>>().
+        services.TryAddSingleton(
+            sp => sp.GetRequiredService<DurableAgentsOptions>().GetAgentFactories());
+
         // A custom data converter is needed because the default chat client uses camel case for JSON properties,
         // which is not the default behavior for the Durable Task SDK.
-        services.AddSingleton<DataConverter, DefaultDataConverter>();
+        services.TryAddSingleton<DataConverter, DefaultDataConverter>();
 
         return options;
     }

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

@@ -0,0 +1,274 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Agents.AI.Workflows;
+using Microsoft.Agents.AI.Workflows.Checkpointing;
+
+namespace Microsoft.Agents.AI.DurableTask;
+
+/// <summary>
+/// Represents an executor in the workflow with its metadata.
+/// </summary>
+/// <param name="ExecutorId">The unique identifier of the executor.</param>
+/// <param name="IsAgenticExecutor">Indicates whether this executor is an agentic executor.</param>
+public sealed record WorkflowExecutorInfo(string ExecutorId, bool IsAgenticExecutor);
+
+/// <summary>
+/// Represents a level of executors that can be executed in parallel (Fan-Out).
+/// All executors in the same level have their dependencies satisfied by previous levels.
+/// </summary>
+/// <param name="Level">The level number (0-based, starting from the root executor).</param>
+/// <param name="Executors">The executors that can run in parallel at this level.</param>
+/// <param name="IsFanIn">Indicates if this level is a Fan-In point (has executors with multiple predecessors).</param>
+public sealed record WorkflowExecutionLevel(int Level, List<WorkflowExecutorInfo> Executors, bool IsFanIn);
+
+/// <summary>
+/// Represents the complete execution plan for a workflow, including parallel execution levels.
+/// </summary>
+public sealed class WorkflowExecutionPlan
+{
+    /// <summary>
+    /// The execution levels in order. Each level contains executors that can run in parallel.
+    /// </summary>
+    public List<WorkflowExecutionLevel> Levels { get; } = [];
+
+    /// <summary>
+    /// Maps each executor ID to its predecessors (for Fan-In result aggregation).
+    /// </summary>
+    public Dictionary<string, List<string>> Predecessors { get; } = [];
+
+    /// <summary>
+    /// Maps each executor ID to its successors (for Fan-Out result distribution).
+    /// </summary>
+    public Dictionary<string, List<string>> Successors { get; } = [];
+
+    /// <summary>
+    /// Maps edge connections (sourceId, targetId) to their condition functions.
+    /// The condition function takes the predecessor's result and returns true if the edge should be followed.
+    /// </summary>
+    public Dictionary<(string SourceId, string TargetId), Func<object?, bool>?> EdgeConditions { get; } = [];
+
+    /// <summary>
+    /// Maps executor IDs to their output types (for proper deserialization during condition evaluation).
+    /// </summary>
+    public Dictionary<string, Type?> ExecutorOutputTypes { get; } = [];
+
+    /// <summary>
+    /// Gets whether this workflow has any parallel execution opportunities.
+    /// </summary>
+    public bool HasParallelism => this.Levels.Any(l => l.Executors.Count > 1);
+
+    /// <summary>
+    /// Gets whether this workflow has any Fan-In points.
+    /// </summary>
+    public bool HasFanIn => this.Levels.Any(l => l.IsFanIn);
+}
+
+/// <summary>
+/// Provides helper methods for analyzing and executing workflows.
+/// </summary>
+public static class WorkflowHelper
+{
+    /// <summary>
+    /// Accepts a workflow instance and returns a list of executors with metadata in the order they should be executed.
+    /// </summary>
+    /// <param name="workflow">The workflow instance to analyze.</param>
+    /// <returns>A list of executor information in topological order (execution order).</returns>
+    public static List<WorkflowExecutorInfo> GetExecutorsFromWorkflowInOrder(Workflow workflow)
+    {
+        WorkflowExecutionPlan plan = GetExecutionPlan(workflow);
+
+        // Flatten the levels into a single list for backward compatibility
+        List<WorkflowExecutorInfo> result = [];
+        foreach (WorkflowExecutionLevel level in plan.Levels)
+        {
+            result.AddRange(level.Executors);
+        }
+
+        return result;
+    }
+
+    /// <summary>
+    /// Analyzes the workflow and returns an execution plan that supports Fan-Out/Fan-In patterns.
+    /// Executors at the same level can be executed in parallel (Fan-Out).
+    /// Fan-In points are identified where multiple executors converge.
+    /// </summary>
+    /// <param name="workflow">The workflow instance to analyze.</param>
+    /// <returns>An execution plan with parallel execution levels.</returns>
+    public static WorkflowExecutionPlan GetExecutionPlan(Workflow workflow)
+    {
+        ArgumentNullException.ThrowIfNull(workflow);
+
+        Dictionary<string, ExecutorBinding> executors = workflow.ReflectExecutors();
+        Dictionary<string, HashSet<EdgeInfo>> edges = workflow.ReflectEdges();
+        Dictionary<(string SourceId, string TargetId), Func<object?, bool>?> edgeConditions = workflow.GetEdgeConditions();
+
+        WorkflowExecutionPlan plan = new();
+
+        // Build adjacency lists (successors and predecessors)
+        Dictionary<string, List<string>> successors = [];
+        Dictionary<string, List<string>> predecessors = [];
+        Dictionary<string, int> inDegree = [];
+
+        // Initialize all executors and extract their output types
+        foreach (KeyValuePair<string, ExecutorBinding> executor in executors)
+        {
+            successors[executor.Key] = [];
+            predecessors[executor.Key] = [];
+            inDegree[executor.Key] = 0;
+
+            // Extract output type from executor type (e.g., Executor<TInput, TOutput> -> TOutput)
+            plan.ExecutorOutputTypes[executor.Key] = GetExecutorOutputType(executor.Value.ExecutorType);
+        }
+
+        // Build the graph from edges
+        foreach (KeyValuePair<string, HashSet<EdgeInfo>> edgeGroup in edges)
+        {
+            string sourceId = edgeGroup.Key;
+
+            foreach (EdgeInfo edge in edgeGroup.Value)
+            {
+                foreach (string sinkId in edge.Connection.SinkIds)
+                {
+                    if (executors.ContainsKey(sinkId))
+                    {
+                        successors[sourceId].Add(sinkId);
+                        predecessors[sinkId].Add(sourceId);
+                        inDegree[sinkId]++;
+                    }
+                }
+            }
+        }
+
+        // Store edge conditions in the plan
+        foreach (KeyValuePair<(string SourceId, string TargetId), Func<object?, bool>?> condition in edgeConditions)
+        {
+            plan.EdgeConditions[condition.Key] = condition.Value;
+        }
+
+        // Store the graph structure in the plan
+        foreach (string executorId in executors.Keys)
+        {
+            plan.Predecessors[executorId] = [.. predecessors[executorId]];
+            plan.Successors[executorId] = [.. successors[executorId]];
+        }
+
+        // Build execution levels using modified Kahn's algorithm
+        // Instead of processing one at a time, we process all nodes with in-degree 0 at once (same level)
+        HashSet<string> processed = [];
+        Dictionary<string, int> currentInDegree = new(inDegree);
+        int levelNumber = 0;
+
+        while (processed.Count < executors.Count)
+        {
+            // Find all executors that can be executed at this level (in-degree == 0 and not yet processed)
+            List<string> currentLevelIds = [];
+
+            foreach (KeyValuePair<string, int> kvp in currentInDegree)
+            {
+                if (kvp.Value == 0 && !processed.Contains(kvp.Key))
+                {
+                    currentLevelIds.Add(kvp.Key);
+                }
+            }
+
+            // If no executors found but not all processed, there might be a cycle
+            if (currentLevelIds.Count == 0)
+            {
+                // Add remaining unprocessed executors
+                foreach (string executorId in executors.Keys)
+                {
+                    if (!processed.Contains(executorId))
+                    {
+                        currentLevelIds.Add(executorId);
+                    }
+                }
+
+                if (currentLevelIds.Count == 0)
+                {
+                    break;
+                }
+            }
+
+            // Check if this level is a Fan-In point (any executor has multiple predecessors)
+            bool isFanIn = currentLevelIds.Any(id => predecessors[id].Count > 1);
+
+            // Convert to WorkflowExecutorInfo
+            List<WorkflowExecutorInfo> levelExecutors = [];
+            foreach (string executorId in currentLevelIds)
+            {
+                processed.Add(executorId);
+
+                if (executors.TryGetValue(executorId, out ExecutorBinding? executorBinding))
+                {
+                    bool isAgentic = IsAgentExecutorType(executorBinding.ExecutorType);
+                    levelExecutors.Add(new WorkflowExecutorInfo(executorId, isAgentic));
+                }
+
+                // Decrement in-degree of all successors
+                foreach (string successor in successors[executorId])
+                {
+                    currentInDegree[successor]--;
+                }
+            }
+
+            plan.Levels.Add(new WorkflowExecutionLevel(levelNumber, levelExecutors, isFanIn));
+            levelNumber++;
+        }
+
+        return plan;
+    }
+
+    /// <summary>
+    /// Determines whether the specified executor type is an agentic executor.
+    /// </summary>
+    /// <param name="executorType">The executor type to check.</param>
+    /// <returns><c>true</c> if the executor is an agentic executor; otherwise, <c>false</c>.</returns>
+    internal static bool IsAgentExecutorType(Type executorType)
+    {
+        // hack for now. In the future, the MAF type could expose something which can help with this.
+        // Check if the type name or assembly indicates it's an agent executor
+        // This includes AgentRunStreamingExecutor, AgentExecutor, ChatClientAgent wrappers, etc.
+        string typeName = executorType.FullName ?? executorType.Name;
+        string assemblyName = executorType.Assembly.GetName().Name ?? string.Empty;
+
+        return typeName.Contains("AIAgentHostExecutor", StringComparison.OrdinalIgnoreCase) &&
+                assemblyName.Contains("Microsoft.Agents.AI", StringComparison.OrdinalIgnoreCase);
+    }
+
+    /// <summary>
+    /// Extracts the output type from an executor type.
+    /// For Executor&lt;TInput, TOutput&gt;, returns TOutput.
+    /// For Executor&lt;TInput&gt;, returns null (void output).
+    /// </summary>
+    /// <param name="executorType">The executor type to analyze.</param>
+    /// <returns>The output type, or null if the executor has no typed output.</returns>
+    private static Type? GetExecutorOutputType(Type executorType)
+    {
+        // Walk up the inheritance chain to find Executor<TInput, TOutput> or Executor<TInput>
+        Type? currentType = executorType;
+        while (currentType is not null)
+        {
+            if (currentType.IsGenericType)
+            {
+                Type genericDefinition = currentType.GetGenericTypeDefinition();
+                Type[] genericArgs = currentType.GetGenericArguments();
+
+                // Check for Executor<TInput, TOutput> (2 type parameters)
+                if (genericArgs.Length == 2 && genericDefinition.Name.StartsWith("Executor", StringComparison.Ordinal))
+                {
+                    return genericArgs[1]; // TOutput
+                }
+
+                // Check for Executor<TInput> (1 type parameter) - void return
+                if (genericArgs.Length == 1 && genericDefinition.Name.StartsWith("Executor", StringComparison.Ordinal))
+                {
+                    return null;
+                }
+            }
+
+            currentType = currentType.BaseType;
+        }
+
+        return null;
+    }
+}

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

@@ -0,0 +1,127 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+namespace Microsoft.Agents.AI.DurableTask;
+
+/// <summary>
+/// Provides helper methods for workflow naming conventions used in durable orchestrations.
+/// </summary>
+public static class WorkflowNamingHelper
+{
+    /// <summary>
+    /// The prefix used for durable workflow orchestration function names.
+    /// </summary>
+    public const string OrchestrationFunctionPrefix = "dafx-";
+
+    /// <summary>
+    /// Converts a workflow name to its corresponding orchestration function name.
+    /// </summary>
+    /// <param name="workflowName">The workflow name.</param>
+    /// <returns>The orchestration function name.</returns>
+    /// <exception cref="ArgumentException">Thrown when the workflow name is null or empty.</exception>
+    public static string ToOrchestrationFunctionName(string workflowName)
+    {
+        ArgumentException.ThrowIfNullOrEmpty(workflowName);
+        return $"{OrchestrationFunctionPrefix}{workflowName}";
+    }
+
+    /// <summary>
+    /// Converts an orchestration function name back to its workflow name.
+    /// </summary>
+    /// <param name="orchestrationFunctionName">The orchestration function name.</param>
+    /// <returns>The workflow name.</returns>
+    /// <exception cref="ArgumentException">Thrown when the orchestration function name is null, empty, or doesn't have the expected prefix.</exception>
+    public static string ToWorkflowName(string orchestrationFunctionName)
+    {
+        ArgumentException.ThrowIfNullOrEmpty(orchestrationFunctionName);
+
+        if (!orchestrationFunctionName.StartsWith(OrchestrationFunctionPrefix, StringComparison.Ordinal))
+        {
+            throw new ArgumentException(
+                $"Orchestration function name '{orchestrationFunctionName}' does not start with the expected '{OrchestrationFunctionPrefix}' prefix.",
+                nameof(orchestrationFunctionName));
+        }
+
+        string workflowName = orchestrationFunctionName[OrchestrationFunctionPrefix.Length..];
+
+        if (string.IsNullOrEmpty(workflowName))
+        {
+            throw new ArgumentException(
+                $"Orchestration function name '{orchestrationFunctionName}' does not contain a workflow name after the prefix.",
+                nameof(orchestrationFunctionName));
+        }
+
+        return workflowName;
+    }
+
+    /// <summary>
+    /// Tries to convert an orchestration function name back to its workflow name.
+    /// </summary>
+    /// <param name="orchestrationFunctionName">The orchestration function name.</param>
+    /// <param name="workflowName">When this method returns, contains the workflow name if the conversion succeeded, or null if it failed.</param>
+    /// <returns><c>true</c> if the conversion succeeded; otherwise, <c>false</c>.</returns>
+    public static bool TryGetWorkflowName(string? orchestrationFunctionName, out string? workflowName)
+    {
+        workflowName = null;
+
+        if (string.IsNullOrEmpty(orchestrationFunctionName))
+        {
+            return false;
+        }
+
+        if (!orchestrationFunctionName.StartsWith(OrchestrationFunctionPrefix, StringComparison.Ordinal))
+        {
+            return false;
+        }
+
+        workflowName = orchestrationFunctionName[OrchestrationFunctionPrefix.Length..];
+        return !string.IsNullOrEmpty(workflowName);
+    }
+
+    /// <summary>
+    /// The suffix separator used when the workflow builder appends a GUID to executor IDs.
+    /// </summary>
+    /// <remarks>
+    /// For agentic executors, the workflow builder appends a GUID suffix to ensure uniqueness.
+    /// For example: "Physicist_8884e71021334ce49517fa2b17b1695b".
+    /// </remarks>
+    private const char ExecutorIdSuffixSeparator = '_';
+
+    /// <summary>
+    /// Extracts the executor name from an executor ID.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// For non-agentic executors, the executor ID is the same as the executor name (e.g., "OrderParser").
+    /// </para>
+    /// <para>
+    /// For agentic executors, the workflow builder appends a GUID suffix separated by an underscore
+    /// (e.g., "Physicist_8884e71021334ce49517fa2b17b1695b"). This method extracts just the name portion.
+    /// </para>
+    /// </remarks>
+    /// <param name="executorId">The executor ID, which may contain a GUID suffix.</param>
+    /// <returns>The executor name without any GUID suffix.</returns>
+    /// <exception cref="ArgumentException">Thrown when the executor ID is null or empty.</exception>
+    public static string GetExecutorName(string executorId)
+    {
+        ArgumentException.ThrowIfNullOrEmpty(executorId);
+
+        int separatorIndex = executorId.IndexOf(ExecutorIdSuffixSeparator);
+        return separatorIndex > 0 ? executorId[..separatorIndex] : executorId;
+    }
+
+    /// <summary>
+    /// Determines whether the executor ID contains a GUID suffix.
+    /// </summary>
+    /// <param name="executorId">The executor ID to check.</param>
+    /// <returns><c>true</c> if the executor ID contains a suffix; otherwise, <c>false</c>.</returns>
+    public static bool HasExecutorIdSuffix(string? executorId)
+    {
+        if (string.IsNullOrEmpty(executorId))
+        {
+            return false;
+        }
+
+        int separatorIndex = executorId.IndexOf(ExecutorIdSuffixSeparator);
+        return separatorIndex > 0 && separatorIndex < executorId.Length - 1;
+    }
+}

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

@@ -0,0 +1,171 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.DurableTask.Entities;
+
+namespace Microsoft.Agents.AI.DurableTask;
+
+/// <summary>
+/// Durable entity that manages workflow state across activities within an orchestration run.
+/// Each orchestration instance gets its own entity instance (keyed by orchestration instance ID),
+/// ensuring state isolation between workflow runs. The entity is automatically cleaned up
+/// when the orchestration completes.
+/// </summary>
+public sealed class WorkflowSharedStateEntity : TaskEntity<WorkflowStateData>
+{
+    /// <summary>
+    /// The entity name used for registration and lookup.
+    /// </summary>
+    public const string EntityName = "workflow-shared-state";
+
+    /// <summary>
+    /// Reads a state value by key and scope.
+    /// </summary>
+    /// <param name="request">The read request containing key and optional scope.</param>
+    /// <returns>The serialized state value, or null if not found.</returns>
+    public string? ReadState(WorkflowStateReadRequest request)
+    {
+        string scopeKey = GetScopeKey(request.ScopeName, request.Key);
+        return this.State.Values.TryGetValue(scopeKey, out string? value) ? value : null;
+    }
+
+    /// <summary>
+    /// Reads the entire state dictionary.
+    /// </summary>
+    /// <returns>A copy of the current state.</returns>
+    public Dictionary<string, string> ReadAllState()
+    {
+        return new Dictionary<string, string>(this.State.Values);
+    }
+
+    /// <summary>
+    /// Writes or updates a state value by key and scope.
+    /// </summary>
+    /// <param name="request">The write request containing key, scope, and value.</param>
+    public void WriteState(WorkflowStateWriteRequest request)
+    {
+        string scopeKey = GetScopeKey(request.ScopeName, request.Key);
+
+        if (request.Value is null)
+        {
+            this.State.Values.Remove(scopeKey);
+        }
+        else
+        {
+            this.State.Values[scopeKey] = request.Value;
+        }
+    }
+
+    /// <summary>
+    /// Gets all keys within a specific scope.
+    /// </summary>
+    /// <param name="scopeName">The scope name, or null for the default scope.</param>
+    /// <returns>A collection of keys within the scope.</returns>
+    public HashSet<string> GetStateKeys(string? scopeName)
+    {
+        string scopePrefix = GetScopePrefix(scopeName);
+        HashSet<string> keys = [];
+
+        foreach (string scopeKey in this.State.Values.Keys)
+        {
+            if (scopeKey.StartsWith(scopePrefix, StringComparison.Ordinal))
+            {
+                string key = scopeKey[scopePrefix.Length..];
+                keys.Add(key);
+            }
+        }
+
+        return keys;
+    }
+
+    /// <summary>
+    /// Clears all state entries within a specific scope.
+    /// </summary>
+    /// <param name="scopeName">The scope name, or null for the default scope.</param>
+    public void ClearScope(string? scopeName)
+    {
+        string scopePrefix = GetScopePrefix(scopeName);
+        List<string> keysToRemove = [];
+
+        foreach (string scopeKey in this.State.Values.Keys)
+        {
+            if (scopeKey.StartsWith(scopePrefix, StringComparison.Ordinal))
+            {
+                keysToRemove.Add(scopeKey);
+            }
+        }
+
+        foreach (string key in keysToRemove)
+        {
+            this.State.Values.Remove(key);
+        }
+    }
+
+    /// <summary>
+    /// Deletes the entity, cleaning up all state.
+    /// Called by the orchestration when it completes.
+    /// </summary>
+    public void Delete()
+    {
+        // Setting State to null tells the Durable Task framework to delete the entity.
+        // The entity will be garbage collected after idle timeout.
+        this.State = null!;
+    }
+
+    private static string GetScopeKey(string? scopeName, string key)
+    {
+        return $"{GetScopePrefix(scopeName)}{key}";
+    }
+
+    private static string GetScopePrefix(string? scopeName)
+    {
+        return scopeName is null ? "__default__:" : $"{scopeName}:";
+    }
+}
+
+/// <summary>
+/// Represents the internal state data for a workflow state entity.
+/// </summary>
+public sealed class WorkflowStateData
+{
+    /// <summary>
+    /// Gets the state dictionary mapping scope-prefixed keys to serialized values.
+    /// </summary>
+    public Dictionary<string, string> Values { get; init; } = [];
+}
+
+/// <summary>
+/// Request model for reading workflow state.
+/// </summary>
+public sealed class WorkflowStateReadRequest
+{
+    /// <summary>
+    /// Gets or sets the state key.
+    /// </summary>
+    public string Key { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the optional scope name.
+    /// </summary>
+    public string? ScopeName { get; set; }
+}
+
+/// <summary>
+/// Request model for writing workflow state.
+/// </summary>
+public sealed class WorkflowStateWriteRequest
+{
+    /// <summary>
+    /// Gets or sets the state key.
+    /// </summary>
+    public string Key { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the optional scope name.
+    /// </summary>
+    public string? ScopeName { get; set; }
+
+    /// <summary>
+    /// Gets or sets the serialized value, or null to delete the key.
+    /// </summary>
+    public string? Value { get; set; }
+}

dotnet/src/Microsoft.Agents.AI.Hosting.A2A/AIAgentExtensions.cs

@@ -43,10 +43,14 @@ public static class AIAgentExtensions
         {
             var contextId = messageSendParams.Message.ContextId ?? Guid.NewGuid().ToString("N");
             var thread = await hostAgent.GetOrCreateThreadAsync(contextId, cancellationToken).ConfigureAwait(false);
+            var options = messageSendParams.Metadata is not { Count: > 0 }
+                ? null
+                : new AgentRunOptions { AdditionalProperties = messageSendParams.Metadata.ToAdditionalProperties() };
 
             var response = await hostAgent.RunAsync(
                 messageSendParams.ToChatMessages(),
                 thread: thread,
+                options: options,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
 
             await hostAgent.SaveThreadAsync(contextId, thread, cancellationToken).ConfigureAwait(false);
@@ -56,7 +60,8 @@ public static class AIAgentExtensions
                 MessageId = response.ResponseId ?? Guid.NewGuid().ToString("N"),
                 ContextId = contextId,
                 Role = MessageRole.Agent,
-                Parts = parts
+                Parts = parts,
+                Metadata = response.AdditionalProperties?.ToA2AMetadata()
             };
         }
     }

dotnet/src/Microsoft.Agents.AI.Hosting.A2A/Converters/A2AMetadataExtensions.cs

@@ -0,0 +1,36 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using System.Text.Json;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.Hosting.A2A.Converters;
+
+/// <summary>
+/// Extension methods for A2A metadata dictionary.
+/// </summary>
+internal static class A2AMetadataExtensions
+{
+    /// <summary>
+    /// Converts a dictionary of metadata to an <see cref="AdditionalPropertiesDictionary"/>.
+    /// </summary>
+    /// <remarks>
+    /// This method can be replaced by the one from A2A SDK once it is public.
+    /// </remarks>
+    /// <param name="metadata">The metadata dictionary to convert.</param>
+    /// <returns>The converted <see cref="AdditionalPropertiesDictionary"/>, or null if the input is null or empty.</returns>
+    internal static AdditionalPropertiesDictionary? ToAdditionalProperties(this Dictionary<string, JsonElement>? metadata)
+    {
+        if (metadata is not { Count: > 0 })
+        {
+            return null;
+        }
+
+        var additionalProperties = new AdditionalPropertiesDictionary();
+        foreach (var kvp in metadata)
+        {
+            additionalProperties[kvp.Key] = kvp.Value;
+        }
+        return additionalProperties;
+    }
+}

dotnet/src/Microsoft.Agents.AI.Hosting.A2A/Converters/AdditionalPropertiesDictionaryExtensions.cs

@@ -0,0 +1,45 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using System.Text.Json;
+using A2A;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.Hosting.A2A.Converters;
+
+/// <summary>
+/// Extension methods for AdditionalPropertiesDictionary.
+/// </summary>
+internal static class AdditionalPropertiesDictionaryExtensions
+{
+    /// <summary>
+    /// Converts an <see cref="AdditionalPropertiesDictionary"/> to a dictionary of <see cref="JsonElement"/> values suitable for A2A metadata.
+    /// </summary>
+    /// <remarks>
+    /// This method can be replaced by the one from A2A SDK once it is available.
+    /// </remarks>
+    /// <param name="additionalProperties">The additional properties dictionary to convert, or <c>null</c>.</param>
+    /// <returns>A dictionary of JSON elements representing the metadata, or <c>null</c> if the input is null or empty.</returns>
+    internal static Dictionary<string, JsonElement>? ToA2AMetadata(this AdditionalPropertiesDictionary? additionalProperties)
+    {
+        if (additionalProperties is not { Count: > 0 })
+        {
+            return null;
+        }
+
+        var metadata = new Dictionary<string, JsonElement>();
+
+        foreach (var kvp in additionalProperties)
+        {
+            if (kvp.Value is JsonElement)
+            {
+                metadata[kvp.Key] = (JsonElement)kvp.Value!;
+                continue;
+            }
+
+            metadata[kvp.Key] = JsonSerializer.SerializeToElement(kvp.Value, A2AJsonUtilities.DefaultOptions.GetTypeInfo(typeof(object)));
+        }
+
+        return metadata;
+    }
+}

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

@@ -25,6 +25,44 @@ internal sealed class BuiltInFunctionExecutor : IFunctionExecutor
         IFunctionInputBindingFeature? functionInputBindingFeature = context.Features.Get<IFunctionInputBindingFeature>() ??
             throw new InvalidOperationException("Function input binding feature is not available on the current context.");
 
+        if (context.FunctionDefinition.EntryPoint == BuiltInFunctions.InvokeWorkflowActivityFunctionEntryPoint)
+        {
+            // Bind all inputs to get the input string and DurableTaskClient
+            FunctionInputBindingResult? bindingResults = await functionInputBindingFeature.BindFunctionInputAsync(context);
+            if (bindingResults is not { Values: { } activityBindings })
+            {
+                throw new InvalidOperationException($"Function input binding failed for the invocation {context.InvocationId}");
+            }
+
+            DurableTaskClient? activityDurableTaskClient = null;
+            string? activityInput = null;
+            foreach (object? binding in activityBindings)
+            {
+                if (binding is string stringInput)
+                {
+                    activityInput = stringInput;
+                }
+
+                if (binding is DurableTaskClient client)
+                {
+                    activityDurableTaskClient = client;
+                }
+            }
+
+            if (activityInput is null)
+            {
+                throw new InvalidOperationException($"Activity input binding is missing for the invocation {context.InvocationId}.");
+            }
+
+            if (activityDurableTaskClient is null)
+            {
+                throw new InvalidOperationException($"DurableTaskClient binding is missing for the invocation {context.InvocationId}.");
+            }
+
+            context.GetInvocationResult().Value = await BuiltInFunctions.InvokeWorkflowActivityAsync(activityInput, activityDurableTaskClient, context);
+            return;
+        }
+
         FunctionInputBindingResult? inputBindingResults = await functionInputBindingFeature.BindFunctionInputAsync(context);
         if (inputBindingResults is not { Values: { } values })
         {
@@ -102,6 +140,32 @@ internal sealed class BuiltInFunctionExecutor : IFunctionExecutor
             return;
         }
 
+        if (context.FunctionDefinition.EntryPoint == BuiltInFunctions.RunWorkflowOrechstrtationHttpFunctionEntryPoint)
+        {
+            if (httpRequestData == null)
+            {
+                throw new InvalidOperationException($"HTTP request data binding is missing for the invocation {context.InvocationId}.");
+            }
+
+            context.GetInvocationResult().Value = await BuiltInFunctions.RunWorkflowOrechstrtationHttpTriggerAsync(
+                   httpRequestData,
+                   durableTaskClient,
+                   context);
+            return;
+        }
+
+        // Handle workflow MCP tool trigger
+        if (context.FunctionDefinition.EntryPoint == BuiltInFunctions.RunWorkflowMcpToolFunctionEntryPoint)
+        {
+            if (mcpToolInvocationContext is null)
+            {
+                throw new InvalidOperationException($"MCP tool invocation context binding is missing for the invocation {context.InvocationId}.");
+            }
+
+            context.GetInvocationResult().Value = await BuiltInFunctions.RunWorkflowMcpToolAsync(mcpToolInvocationContext, durableTaskClient, context);
+            return;
+        }
+
         throw new InvalidOperationException($"Unsupported function entry point '{context.FunctionDefinition.EntryPoint}' for invocation {context.InvocationId}.");
     }
 }

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

@@ -20,7 +20,30 @@ internal static class BuiltInFunctions
 
     internal static readonly string RunAgentHttpFunctionEntryPoint = $"{typeof(BuiltInFunctions).FullName!}.{nameof(RunAgentHttpAsync)}";
     internal static readonly string RunAgentEntityFunctionEntryPoint = $"{typeof(BuiltInFunctions).FullName!}.{nameof(InvokeAgentAsync)}";
+    internal static readonly string RunWorkflowOrechstrtationHttpFunctionEntryPoint = $"{typeof(BuiltInFunctions).FullName!}.{nameof(RunWorkflowOrechstrtationHttpTriggerAsync)}";
+    internal static readonly string InvokeWorkflowActivityFunctionEntryPoint = $"{typeof(BuiltInFunctions).FullName!}.{nameof(InvokeWorkflowActivityAsync)}";
     internal static readonly string RunAgentMcpToolFunctionEntryPoint = $"{typeof(BuiltInFunctions).FullName!}.{nameof(RunMcpToolAsync)}";
+    internal static readonly string RunWorkflowMcpToolFunctionEntryPoint = $"{typeof(BuiltInFunctions).FullName!}.{nameof(RunWorkflowMcpToolAsync)}";
+
+#pragma warning disable IL3000 // Avoid accessing Assembly file path when publishing as a single file - Azure Functions does not use single-file publishing
+    internal static readonly string ScriptFile = Path.GetFileName(typeof(BuiltInFunctions).Assembly.Location);
+#pragma warning restore IL3000
+
+    // Exposed as an activity trigger for workflow executors
+    public static Task<string> InvokeWorkflowActivityAsync(
+        [ActivityTrigger] string input,
+        [DurableClient] DurableTaskClient durableTaskClient,
+        FunctionContext functionContext)
+    {
+        ArgumentNullException.ThrowIfNull(input);
+        ArgumentNullException.ThrowIfNull(durableTaskClient);
+        ArgumentNullException.ThrowIfNull(functionContext);
+
+        string activityFunctionName = functionContext.FunctionDefinition.Name;
+
+        FunctionsWorkflowRunner runner = functionContext.InstanceServices.GetRequiredService<FunctionsWorkflowRunner>();
+        return runner.ExecuteActivityAsync(activityFunctionName, input, durableTaskClient, functionContext);
+    }
 
     // Exposed as an entity trigger via AgentFunctionsProvider
     public static Task<string> InvokeAgentAsync(
@@ -43,6 +66,24 @@ internal static class BuiltInFunctions
         return GrpcEntityRunner.LoadAndRunAsync(encodedEntityRequest, entity, combinedServiceProvider);
     }
 
+    /// <summary>
+    /// Invokes a workflow orchestration in response to an HTTP request.
+    /// </summary>
+    public static async Task<HttpResponseData> RunWorkflowOrechstrtationHttpTriggerAsync(
+        [HttpTrigger] HttpRequestData req,
+        [DurableClient] DurableTaskClient client,
+        FunctionContext context)
+    {
+        var workflowName = context.FunctionDefinition.Name.Replace(HttpPrefix, string.Empty);
+        var orchestrationFunctionName = WorkflowNamingHelper.ToOrchestrationFunctionName(workflowName);
+        var inputMessage = await req.ReadAsStringAsync();
+        string instanceId = await client.ScheduleNewOrchestrationInstanceAsync(orchestrationFunctionName, inputMessage);
+
+        HttpResponseData response = req.CreateResponse(HttpStatusCode.Accepted);
+        await response.WriteStringAsync($"InvokeWorkflowOrechstrtationAsync is invoked for {workflowName}. Orchestration instanceId: {instanceId}");
+        return response;
+    }
+
     public static async Task<HttpResponseData> RunAgentHttpAsync(
         [HttpTrigger] HttpRequestData req,
         [DurableClient] DurableTaskClient client,
@@ -178,6 +219,39 @@ internal static class BuiltInFunctions
         return agentResponse.Text;
     }
 
+    /// <summary>
+    /// Runs a workflow via MCP tool trigger.
+    /// </summary>
+    public static async Task<string?> RunWorkflowMcpToolAsync(
+        [McpToolTrigger("BuiltInWorkflowMcpTool")] ToolInvocationContext context,
+        [DurableClient] DurableTaskClient client,
+        FunctionContext functionContext)
+    {
+        if (context.Arguments is null)
+        {
+            throw new ArgumentException("MCP Tool invocation is missing required arguments.");
+        }
+
+        if (!context.Arguments.TryGetValue("input", out object? inputObj) || inputObj is not string input)
+        {
+            throw new ArgumentException("MCP Tool invocation is missing required 'input' argument of type string.");
+        }
+
+        // Extract workflow name from the MCP tool name (format: mcptool-workflow-{workflowName})
+        string workflowName = context.Name;
+        string orchestrationFunctionName = WorkflowNamingHelper.ToOrchestrationFunctionName(workflowName);
+
+        string instanceId = await client.ScheduleNewOrchestrationInstanceAsync(orchestrationFunctionName, input);
+
+        // Wait for the orchestration to complete and return the result
+        OrchestrationMetadata? metadata = await client.WaitForInstanceCompletionAsync(
+            instanceId,
+            getInputsAndOutputs: true,
+            cancellation: functionContext.CancellationToken);
+
+        return metadata?.ReadOutputAs<string>();
+    }
+
     /// <summary>
     /// Creates an error response with the specified status code and error message.
     /// </summary>

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

@@ -0,0 +1,80 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Agents.AI.DurableTask;
+using Microsoft.Azure.Functions.Worker.Builder;
+using Microsoft.Azure.Functions.Worker.Core.FunctionMetadata;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Hosting;
+
+namespace Microsoft.Agents.AI.Hosting.AzureFunctions;
+
+/// <summary>
+/// Shared configuration logic for durable agents and workflows.
+/// This class consolidates common service registrations used by both
+/// <see cref="FunctionsApplicationBuilderExtensions.ConfigureDurableAgents"/> and
+/// <see cref="DurableOptionsExtensions.ConfigureDurableOptions"/>.
+/// </summary>
+internal static class CoreAgentConfigurationExtensions
+{
+    /// <summary>
+    /// Registers the core agent services required for durable agents.
+    /// </summary>
+    /// <param name="builder">The functions application builder.</param>
+    /// <returns>The functions application builder for method chaining.</returns>
+    internal static FunctionsApplicationBuilder RegisterCoreAgentServices(this FunctionsApplicationBuilder builder)
+    {
+        builder.Services.TryAddSingleton<IFunctionsAgentOptionsProvider>(_ =>
+            new DefaultFunctionsAgentOptionsProvider(DurableAgentsOptionsExtensions.GetAgentOptionsSnapshot()));
+
+        builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton<IFunctionMetadataTransformer, DurableAgentFunctionMetadataTransformer>());
+
+        return builder;
+    }
+
+    /// <summary>
+    /// Registers the workflow-specific services required for durable workflows.
+    /// This should only be called when workflows are configured in the application.
+    /// </summary>
+    /// <param name="builder">The functions application builder.</param>
+    /// <returns>The functions application builder for method chaining.</returns>
+    internal static FunctionsApplicationBuilder RegisterWorkflowServices(this FunctionsApplicationBuilder builder)
+    {
+        // Register FunctionsWorkflowRunner as a singleton
+        builder.Services.TryAddSingleton<FunctionsWorkflowRunner>();
+
+        // Also register it as DurableWorkflowRunner so orchestrations can resolve it by base type
+        builder.Services.TryAddSingleton<DurableWorkflowRunner>(sp => sp.GetRequiredService<FunctionsWorkflowRunner>());
+
+        builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton<IFunctionMetadataTransformer, DurableWorkflowFunctionMetadataTransformer>());
+
+        return builder;
+    }
+
+    /// <summary>
+    /// Configures the middleware and executor for handling built-in function execution.
+    /// This is shared by both agents and workflows, handling Agent HTTP, MCP tool,
+    /// workflow orchestration, and Entity invocations.
+    /// </summary>
+    /// <param name="builder">The functions application builder.</param>
+    /// <returns>The functions application builder for method chaining.</returns>
+    internal static FunctionsApplicationBuilder ConfigureBuiltInFunctionMiddleware(this FunctionsApplicationBuilder builder)
+    {
+        builder.Services.TryAddSingleton<BuiltInFunctionExecutor>();
+
+        builder.UseWhen<BuiltInFunctionExecutionMiddleware>(static context =>
+            IsBuiltInFunction(context.FunctionDefinition.EntryPoint));
+
+        return builder;
+    }
+
+    private static bool IsBuiltInFunction(string? entryPoint)
+    {
+        return string.Equals(entryPoint, BuiltInFunctions.RunAgentHttpFunctionEntryPoint, StringComparison.Ordinal)
+            || string.Equals(entryPoint, BuiltInFunctions.RunAgentMcpToolFunctionEntryPoint, StringComparison.Ordinal)
+            || string.Equals(entryPoint, BuiltInFunctions.RunWorkflowMcpToolFunctionEntryPoint, StringComparison.Ordinal)
+            || string.Equals(entryPoint, BuiltInFunctions.RunWorkflowOrechstrtationHttpFunctionEntryPoint, StringComparison.Ordinal)
+            || string.Equals(entryPoint, BuiltInFunctions.InvokeWorkflowActivityFunctionEntryPoint, StringComparison.Ordinal)
+            || string.Equals(entryPoint, BuiltInFunctions.RunAgentEntityFunctionEntryPoint, StringComparison.Ordinal);
+    }
+}

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

@@ -13,7 +13,7 @@ namespace Microsoft.Agents.AI.Hosting.AzureFunctions;
 internal sealed class DurableAgentFunctionMetadataTransformer : IFunctionMetadataTransformer
 {
     private readonly ILogger<DurableAgentFunctionMetadataTransformer> _logger;
-    private readonly IReadOnlyDictionary<string, Func<IServiceProvider, AIAgent>> _agents;
+    private readonly DurableAgentsOptions _agentOptions;
     private readonly IServiceProvider _serviceProvider;
     private readonly IFunctionsAgentOptionsProvider _functionsAgentOptionsProvider;
 
@@ -22,12 +22,12 @@ internal sealed class DurableAgentFunctionMetadataTransformer : IFunctionMetadat
 #pragma warning restore IL3000
 
     public DurableAgentFunctionMetadataTransformer(
-        IReadOnlyDictionary<string, Func<IServiceProvider, AIAgent>> agents,
+        DurableAgentsOptions agentOptions,
         ILogger<DurableAgentFunctionMetadataTransformer> logger,
         IServiceProvider serviceProvider,
         IFunctionsAgentOptionsProvider functionsAgentOptionsProvider)
     {
-        this._agents = agents ?? throw new ArgumentNullException(nameof(agents));
+        this._agentOptions = agentOptions ?? throw new ArgumentNullException(nameof(agentOptions));
         this._logger = logger ?? throw new ArgumentNullException(nameof(logger));
         this._serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
         this._functionsAgentOptionsProvider = functionsAgentOptionsProvider ?? throw new ArgumentNullException(nameof(functionsAgentOptionsProvider));
@@ -39,7 +39,7 @@ internal sealed class DurableAgentFunctionMetadataTransformer : IFunctionMetadat
     {
         this._logger.LogTransformingFunctionMetadata(original.Count);
 
-        foreach (KeyValuePair<string, Func<IServiceProvider, AIAgent>> kvp in this._agents)
+        foreach (KeyValuePair<string, Func<IServiceProvider, AIAgent>> kvp in this._agentOptions.GetAgentFactories())
         {
             string agentName = kvp.Key;