chore: import upstream snapshot with attribution

2026-07-13 13:39:25 +08:00
commit db620d33df
5151 changed files with 925932 additions and 0 deletions
@@ -0,0 +1,42 @@
+<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.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" />
+  </ItemGroup>
+</Project>
@@ -0,0 +1,215 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Agents.AI.Workflows;
+
+namespace SequentialWorkflow;
+
+/// <summary>
+/// Looks up an order by its ID and return an Order object.
+/// </summary>
+internal sealed class OrderLookup() : Executor<string, Order>("OrderLookup")
+{
+    public override async ValueTask<Order> HandleAsync(
+        string message,
+        IWorkflowContext context,
+        CancellationToken cancellationToken = default)
+    {
+        Console.WriteLine();
+        Console.ForegroundColor = ConsoleColor.Magenta;
+        Console.WriteLine("┌─────────────────────────────────────────────────────────────────┐");
+        Console.WriteLine($"│ [Activity] OrderLookup: Starting lookup for order '{message}'");
+        Console.ResetColor();
+
+        // Simulate database lookup with delay
+        await Task.Delay(TimeSpan.FromMicroseconds(100), cancellationToken);
+
+        Order order = new(
+            Id: message,
+            OrderDate: DateTime.UtcNow.AddDays(-1),
+            IsCancelled: false,
+            Customer: new Customer(Name: "Jerry", Email: "jerry@example.com"));
+
+        Console.ForegroundColor = ConsoleColor.Magenta;
+        Console.WriteLine($"│ [Activity] OrderLookup: Found order '{message}' for customer '{order.Customer.Name}'");
+        Console.WriteLine("└─────────────────────────────────────────────────────────────────┘");
+        Console.ResetColor();
+
+        return order;
+    }
+}
+
+/// <summary>
+/// Cancels an order.
+/// </summary>
+internal sealed class OrderCancel() : Executor<Order, Order>("OrderCancel")
+{
+    public override async ValueTask<Order> HandleAsync(
+        Order message,
+        IWorkflowContext context,
+        CancellationToken cancellationToken = default)
+    {
+        Console.WriteLine();
+        Console.ForegroundColor = ConsoleColor.Yellow;
+        Console.WriteLine("┌─────────────────────────────────────────────────────────────────┐");
+        Console.WriteLine($"│ [Activity] OrderCancel: Starting cancellation for order '{message.Id}'");
+        Console.ResetColor();
+
+        // Simulate a slow cancellation process (e.g., calling external payment system)
+        for (int i = 1; i <= 3; i++)
+        {
+            await Task.Delay(TimeSpan.FromMilliseconds(100), cancellationToken);
+            Console.ForegroundColor = ConsoleColor.DarkYellow;
+            Console.WriteLine("│ [Activity] OrderCancel: Processing...");
+            Console.ResetColor();
+        }
+
+        Order cancelledOrder = message with { IsCancelled = true };
+
+        Console.ForegroundColor = ConsoleColor.Yellow;
+        Console.WriteLine($"│ [Activity] OrderCancel: ✓ Order '{cancelledOrder.Id}' has been cancelled");
+        Console.WriteLine("└─────────────────────────────────────────────────────────────────┘");
+        Console.ResetColor();
+
+        return cancelledOrder;
+    }
+}
+
+/// <summary>
+/// Sends a cancellation confirmation email to the customer.
+/// </summary>
+internal sealed class SendEmail() : Executor<Order, string>("SendEmail")
+{
+    public override ValueTask<string> HandleAsync(
+        Order message,
+        IWorkflowContext context,
+        CancellationToken cancellationToken = default)
+    {
+        Console.WriteLine();
+        Console.ForegroundColor = ConsoleColor.Cyan;
+        Console.WriteLine("┌─────────────────────────────────────────────────────────────────┐");
+        Console.WriteLine($"│ [Activity] SendEmail: Sending email to '{message.Customer.Email}'...");
+        Console.ResetColor();
+
+        string result = $"Cancellation email sent for order {message.Id} to {message.Customer.Email}.";
+
+        Console.ForegroundColor = ConsoleColor.Cyan;
+        Console.WriteLine("│ [Activity] SendEmail: ✓ Email sent successfully!");
+        Console.WriteLine("└─────────────────────────────────────────────────────────────────┘");
+        Console.ResetColor();
+
+        return ValueTask.FromResult(result);
+    }
+}
+
+internal sealed record Order(string Id, DateTime OrderDate, bool IsCancelled, Customer Customer);
+
+internal sealed record Customer(string Name, string Email);
+
+/// <summary>
+/// Represents a batch cancellation request with multiple order IDs and a reason.
+/// This demonstrates using a complex typed object as workflow input.
+/// </summary>
+#pragma warning disable CA1812 // Instantiated via JSON deserialization at runtime
+internal sealed record BatchCancelRequest(string[] OrderIds, string Reason, bool NotifyCustomers);
+#pragma warning restore CA1812
+
+/// <summary>
+/// Represents the result of processing a batch cancellation.
+/// </summary>
+internal sealed record BatchCancelResult(int TotalOrders, int CancelledCount, string Reason);
+
+/// <summary>
+/// Generates a status report for an order.
+/// </summary>
+internal sealed class StatusReport() : Executor<Order, string>("StatusReport")
+{
+    public override ValueTask<string> HandleAsync(
+        Order message,
+        IWorkflowContext context,
+        CancellationToken cancellationToken = default)
+    {
+        Console.WriteLine();
+        Console.ForegroundColor = ConsoleColor.Green;
+        Console.WriteLine("┌─────────────────────────────────────────────────────────────────┐");
+        Console.WriteLine($"│ [Activity] StatusReport: Generating report for order '{message.Id}'");
+        Console.ResetColor();
+
+        string status = message.IsCancelled ? "Cancelled" : "Active";
+        string result = $"Order {message.Id} for {message.Customer.Name}: Status={status}, Date={message.OrderDate:yyyy-MM-dd}";
+
+        Console.ForegroundColor = ConsoleColor.Green;
+        Console.WriteLine($"│ [Activity] StatusReport: ✓ {result}");
+        Console.WriteLine("└─────────────────────────────────────────────────────────────────┘");
+        Console.ResetColor();
+
+        return ValueTask.FromResult(result);
+    }
+}
+
+/// <summary>
+/// Processes a batch cancellation request. Accepts a complex <see cref="BatchCancelRequest"/> object
+/// as input, demonstrating how workflows can receive structured JSON input.
+/// </summary>
+internal sealed class BatchCancelProcessor() : Executor<BatchCancelRequest, BatchCancelResult>("BatchCancelProcessor")
+{
+    public override async ValueTask<BatchCancelResult> HandleAsync(
+        BatchCancelRequest message,
+        IWorkflowContext context,
+        CancellationToken cancellationToken = default)
+    {
+        Console.WriteLine();
+        Console.ForegroundColor = ConsoleColor.Yellow;
+        Console.WriteLine("┌─────────────────────────────────────────────────────────────────┐");
+        Console.WriteLine($"│ [Activity] BatchCancelProcessor: Processing {message.OrderIds.Length} orders");
+        Console.WriteLine($"│ [Activity] BatchCancelProcessor: Reason: {message.Reason}");
+        Console.WriteLine($"│ [Activity] BatchCancelProcessor: Notify customers: {message.NotifyCustomers}");
+        Console.ResetColor();
+
+        // Simulate processing each order
+        int cancelledCount = 0;
+        foreach (string orderId in message.OrderIds)
+        {
+            await Task.Delay(TimeSpan.FromMilliseconds(100), cancellationToken);
+            cancelledCount++;
+            Console.ForegroundColor = ConsoleColor.DarkYellow;
+            Console.WriteLine($"│ [Activity] BatchCancelProcessor: ✓ Cancelled order '{orderId}'");
+            Console.ResetColor();
+        }
+
+        BatchCancelResult result = new(message.OrderIds.Length, cancelledCount, message.Reason);
+
+        Console.ForegroundColor = ConsoleColor.Yellow;
+        Console.WriteLine($"│ [Activity] BatchCancelProcessor: ✓ Batch complete: {cancelledCount}/{message.OrderIds.Length} cancelled");
+        Console.WriteLine("└─────────────────────────────────────────────────────────────────┘");
+        Console.ResetColor();
+
+        return result;
+    }
+}
+
+/// <summary>
+/// Generates a summary of the batch cancellation.
+/// </summary>
+internal sealed class BatchCancelSummary() : Executor<BatchCancelResult, string>("BatchCancelSummary")
+{
+    public override ValueTask<string> HandleAsync(
+        BatchCancelResult message,
+        IWorkflowContext context,
+        CancellationToken cancellationToken = default)
+    {
+        Console.WriteLine();
+        Console.ForegroundColor = ConsoleColor.Cyan;
+        Console.WriteLine("┌─────────────────────────────────────────────────────────────────┐");
+        Console.WriteLine("│ [Activity] BatchCancelSummary: Generating summary");
+        Console.ResetColor();
+
+        string result = $"Batch cancellation complete: {message.CancelledCount}/{message.TotalOrders} orders cancelled. Reason: {message.Reason}";
+
+        Console.ForegroundColor = ConsoleColor.Cyan;
+        Console.WriteLine($"│ [Activity] BatchCancelSummary: ✓ {result}");
+        Console.WriteLine("└─────────────────────────────────────────────────────────────────┘");
+        Console.ResetColor();
+
+        return ValueTask.FromResult(result);
+    }
+}
@@ -0,0 +1,52 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample demonstrates three workflows that share executors.
+// The CancelOrder workflow cancels an order and notifies the customer.
+// The OrderStatus workflow looks up an order and generates a status report.
+// The BatchCancelOrders workflow accepts a complex JSON input to cancel multiple orders.
+// Both CancelOrder and OrderStatus reuse the same OrderLookup executor, demonstrating executor sharing.
+
+using Microsoft.Agents.AI.Hosting.AzureFunctions;
+using Microsoft.Agents.AI.Workflows;
+using Microsoft.Azure.Functions.Worker.Builder;
+using Microsoft.Extensions.Hosting;
+using SequentialWorkflow;
+
+// Define executors for all workflows
+OrderLookup orderLookup = new();
+OrderCancel orderCancel = new();
+SendEmail sendEmail = new();
+StatusReport statusReport = new();
+BatchCancelProcessor batchCancelProcessor = new();
+BatchCancelSummary batchCancelSummary = new();
+
+// Build the CancelOrder workflow: OrderLookup -> OrderCancel -> SendEmail
+Workflow cancelOrder = new WorkflowBuilder(orderLookup)
+    .WithName("CancelOrder")
+    .WithDescription("Cancel an order and notify the customer")
+    .AddEdge(orderLookup, orderCancel)
+    .AddEdge(orderCancel, sendEmail)
+    .Build();
+
+// Build the OrderStatus workflow: OrderLookup -> StatusReport
+// This workflow shares the OrderLookup executor with the CancelOrder workflow.
+Workflow orderStatus = new WorkflowBuilder(orderLookup)
+    .WithName("OrderStatus")
+    .WithDescription("Look up an order and generate a status report")
+    .AddEdge(orderLookup, statusReport)
+    .Build();
+
+// Build the BatchCancelOrders workflow: BatchCancelProcessor -> BatchCancelSummary
+// This workflow demonstrates using a complex JSON object as the workflow input.
+Workflow batchCancelOrders = new WorkflowBuilder(batchCancelProcessor)
+    .WithName("BatchCancelOrders")
+    .WithDescription("Cancel multiple orders in a batch using a complex JSON input")
+    .AddEdge(batchCancelProcessor, batchCancelSummary)
+    .Build();
+
+using IHost app = FunctionsApplication
+    .CreateBuilder(args)
+    .ConfigureFunctionsWebApplication()
+    .ConfigureDurableWorkflows(workflows => workflows.AddWorkflows(cancelOrder, orderStatus, batchCancelOrders))
+    .Build();
+app.Run();
@@ -0,0 +1,147 @@
+# Sequential Workflow Sample
+
+This sample demonstrates how to use the Microsoft Agent Framework to create an Azure Functions app that hosts durable workflows with sequential executor chains. It showcases two workflows that share a common executor, demonstrating executor reuse across workflows.
+
+## Key Concepts Demonstrated
+
+- Defining workflows with sequential executor chains using `WorkflowBuilder`
+- Sharing executors across multiple workflows (the `OrderLookup` executor is used by both workflows)
+- Registering workflows with the Function app using `ConfigureDurableWorkflows`
+- Durable orchestration ensuring workflows survive process restarts and failures
+- Starting workflows via HTTP requests
+- Viewing workflow execution history and status in the Durable Task Scheduler (DTS) dashboard
+
+## Workflows
+
+This sample defines two workflows:
+
+1. **CancelOrder**: `OrderLookup` → `OrderCancel` → `SendEmail` — Looks up an order, cancels it, and sends a confirmation email.
+2. **OrderStatus**: `OrderLookup` → `StatusReport` — Looks up an order and generates a status report.
+
+Both workflows share the `OrderLookup` executor, which is registered only once by the framework.
+
+## 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 HTTP requests to the workflow endpoints.
+
+You can use the `demo.http` file to trigger the workflows, or a command line tool like `curl` as shown below:
+
+### Cancel an Order
+
+Bash (Linux/macOS/WSL):
+
+```bash
+curl -X POST http://localhost:7071/api/workflows/CancelOrder/run \
+    -H "Content-Type: text/plain" \
+    -d "12345"
+```
+
+PowerShell:
+
+```powershell
+Invoke-RestMethod -Method Post `
+    -Uri http://localhost:7071/api/workflows/CancelOrder/run `
+    -ContentType text/plain `
+    -Body "12345"
+```
+
+The response will confirm the workflow orchestration has started:
+
+```text
+Workflow orchestration started for CancelOrder. Orchestration runId: abc123def456
+```
+
+> **Tip:** You can provide a custom run ID by appending a `runId` query parameter:
+>
+> ```bash
+> curl -X POST "http://localhost:7071/api/workflows/CancelOrder/run?runId=my-order-123" \
+>     -H "Content-Type: text/plain" \
+>     -d "12345"
+> ```
+>
+> If not provided, a unique run ID is auto-generated.
+
+### Wait for the Workflow Result
+
+By default, the HTTP endpoint returns `202 Accepted` immediately with the run ID. If you want to wait for the workflow to complete and get the result in the response, add the `x-ms-wait-for-response: true` header:
+
+Bash (Linux/macOS/WSL):
+
+```bash
+curl -X POST http://localhost:7071/api/workflows/CancelOrder/run \
+    -H "Content-Type: text/plain" \
+    -H "x-ms-wait-for-response: true" \
+    -d "12345"
+```
+
+PowerShell:
+
+```powershell
+Invoke-RestMethod -Method Post `
+    -Uri http://localhost:7071/api/workflows/CancelOrder/run `
+    -ContentType text/plain `
+    -Headers @{ "x-ms-wait-for-response" = "true" } `
+    -Body "12345"
+```
+
+The response will contain the workflow result as plain text (200 OK):
+
+```text
+Cancellation email sent for order 12345 to jerry@example.com.
+```
+
+To get the result as JSON, also include the `Accept: application/json` header:
+
+```bash
+curl -X POST http://localhost:7071/api/workflows/CancelOrder/run \
+    -H "Content-Type: text/plain" \
+    -H "x-ms-wait-for-response: true" \
+    -H "Accept: application/json" \
+    -d "12345"
+```
+
+```json
+{
+    "runId": "abc123def456",
+    "workflowStatus": "Completed",
+    "result": "Cancellation email sent for order 12345 to jerry@example.com."
+}
+```
+
+In the function app logs, you will see the sequential execution of each executor:
+
+```text
+│ [Activity] OrderLookup: Starting lookup for order '12345'
+│ [Activity] OrderLookup: Found order '12345' for customer 'Jerry'
+│ [Activity] OrderCancel: Starting cancellation for order '12345'
+│ [Activity] OrderCancel: ✓ Order '12345' has been cancelled
+│ [Activity] SendEmail: Sending email to 'jerry@example.com'...
+│ [Activity] SendEmail: ✓ Email sent successfully!
+```
+
+### Get Order Status
+
+```bash
+curl -X POST http://localhost:7071/api/workflows/OrderStatus/run \
+    -H "Content-Type: text/plain" \
+    -d "12345"
+```
+
+The `OrderStatus` workflow reuses the same `OrderLookup` executor and then generates a status report:
+
+```text
+│ [Activity] OrderLookup: Starting lookup for order '12345'
+│ [Activity] OrderLookup: Found order '12345' for customer 'Jerry'
+│ [Activity] StatusReport: Generating report for order '12345'
+│ [Activity] StatusReport: ✓ Order 12345 for Jerry: Status=Active, Date=2025-01-01
+```
+
+### Viewing Workflows in the DTS Dashboard
+
+After running a workflow, you can navigate to the Durable Task Scheduler (DTS) dashboard to visualize the completed orchestration, inspect inputs/outputs for each step, and view execution history.
+
+If you are using the DTS emulator, the dashboard is available at `http://localhost:8082`.
@@ -0,0 +1,48 @@
+# Default endpoint address for local testing
+@authority=http://localhost:7071
+
+### Cancel an order
+POST {{authority}}/api/workflows/CancelOrder/run
+Content-Type: text/plain
+
+12345
+
+### Cancel an order and wait for the result
+POST {{authority}}/api/workflows/CancelOrder/run
+Content-Type: text/plain
+x-ms-wait-for-response: true
+
+12345
+
+### Cancel an order and wait for the result (JSON response)
+POST {{authority}}/api/workflows/CancelOrder/run
+Content-Type: text/plain
+Accept: application/json
+x-ms-wait-for-response: true
+
+12345
+
+### Cancel an order with a custom run ID
+POST {{authority}}/api/workflows/CancelOrder/run?runId=my-custom-id-123
+Content-Type: text/plain
+
+99999
+
+### Get order status (shares OrderLookup executor with CancelOrder)
+POST {{authority}}/api/workflows/OrderStatus/run
+Content-Type: text/plain
+
+12345
+
+### Get order status and wait for the result
+POST {{authority}}/api/workflows/OrderStatus/run
+Content-Type: text/plain
+x-ms-wait-for-response: true
+
+12345
+
+### Batch cancel orders with a complex JSON input
+POST {{authority}}/api/workflows/BatchCancelOrders/run
+Content-Type: application/json
+
+{"orderIds": ["1001", "1002", "1003"], "reason": "Customer requested cancellation", "notifyCustomers": true}
@@ -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"
+      }
+    }
+  }
+}
@@ -0,0 +1,42 @@
+<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.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" />
+  </ItemGroup>
+</Project>
@@ -0,0 +1,73 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Agents.AI.Workflows;
+
+namespace WorkflowConcurrency;
+
+/// <summary>
+/// Parses and validates the incoming question before sending to AI agents.
+/// </summary>
+internal sealed class ParseQuestionExecutor() : Executor<string, string>("ParseQuestion")
+{
+    public override ValueTask<string> HandleAsync(
+        string message,
+        IWorkflowContext context,
+        CancellationToken cancellationToken = default)
+    {
+        Console.WriteLine();
+        Console.ForegroundColor = ConsoleColor.Magenta;
+        Console.WriteLine("┌─────────────────────────────────────────────────────────────────┐");
+        Console.WriteLine("│ [ParseQuestion] Preparing question for AI agents...");
+
+        string formattedQuestion = message.Trim();
+        if (!formattedQuestion.EndsWith('?'))
+        {
+            formattedQuestion += "?";
+        }
+
+        Console.WriteLine($"│ [ParseQuestion] Question: \"{formattedQuestion}\"");
+        Console.WriteLine("│ [ParseQuestion] → Sending to Physicist and Chemist in PARALLEL...");
+        Console.WriteLine("└─────────────────────────────────────────────────────────────────┘");
+        Console.ResetColor();
+
+        return ValueTask.FromResult(formattedQuestion);
+    }
+}
+
+/// <summary>
+/// Aggregates responses from all AI agents into a comprehensive answer.
+/// This is the Fan-in point where parallel results are collected.
+/// </summary>
+internal sealed class AggregatorExecutor() : Executor<string[], string>("Aggregator")
+{
+    public override ValueTask<string> HandleAsync(
+        string[] message,
+        IWorkflowContext context,
+        CancellationToken cancellationToken = default)
+    {
+        Console.WriteLine();
+        Console.ForegroundColor = ConsoleColor.Cyan;
+        Console.WriteLine("┌─────────────────────────────────────────────────────────────────┐");
+        Console.WriteLine($"│ [Aggregator] 📋 Received {message.Length} AI agent responses");
+        Console.WriteLine("│ [Aggregator] Combining into comprehensive answer...");
+        Console.WriteLine("│ [Aggregator] ✓ Aggregation complete!");
+        Console.WriteLine("└─────────────────────────────────────────────────────────────────┘");
+        Console.ResetColor();
+
+        string aggregatedResult = "═══════════════════════════════════════════════════════════════\n" +
+                                 "                    AI EXPERT PANEL RESPONSES\n" +
+                                 "═══════════════════════════════════════════════════════════════\n\n";
+
+        for (int i = 0; i < message.Length; i++)
+        {
+            string expertLabel = i == 0 ? "⚛️ PHYSICIST" : "🧪 CHEMIST";
+            aggregatedResult += $"{expertLabel}:\n{message[i]}\n\n";
+        }
+
+        aggregatedResult += "═══════════════════════════════════════════════════════════════\n" +
+                          $"Summary: Received perspectives from {message.Length} AI experts.\n" +
+                          "═══════════════════════════════════════════════════════════════";
+
+        return ValueTask.FromResult(aggregatedResult);
+    }
+}
@@ -0,0 +1,45 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Azure;
+using Azure.AI.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Agents.AI.DurableTask;
+using Microsoft.Agents.AI.Hosting.AzureFunctions;
+using Microsoft.Agents.AI.Workflows;
+using Microsoft.Azure.Functions.Worker.Builder;
+using Microsoft.Extensions.Hosting;
+using OpenAI.Chat;
+using WorkflowConcurrency;
+
+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.");
+string? azureOpenAiKey = Environment.GetEnvironmentVariable("AZURE_OPENAI_KEY");
+
+// Create Azure OpenAI client
+AzureOpenAIClient openAiClient = !string.IsNullOrEmpty(azureOpenAiKey)
+    ? new AzureOpenAIClient(new Uri(endpoint), new AzureKeyCredential(azureOpenAiKey))
+    : new AzureOpenAIClient(new Uri(endpoint), new AzureCliCredential());
+ChatClient chatClient = openAiClient.GetChatClient(deploymentName);
+
+// Define the 4 executors for the workflow
+ParseQuestionExecutor parseQuestion = new();
+AIAgent physicist = chatClient.AsAIAgent("You are a physics expert. Be concise (2-3 sentences).", "Physicist");
+AIAgent chemist = chatClient.AsAIAgent("You are a chemistry expert. Be concise (2-3 sentences).", "Chemist");
+AggregatorExecutor aggregator = new();
+
+// Build workflow: ParseQuestion -> [Physicist, Chemist] (parallel) -> Aggregator
+Workflow workflow = new WorkflowBuilder(parseQuestion)
+    .WithName("ExpertReview")
+    .AddFanOutEdge(parseQuestion, [physicist, chemist])
+    .AddFanInBarrierEdge([physicist, chemist], aggregator)
+    .Build();
+
+using IHost app = FunctionsApplication
+    .CreateBuilder(args)
+    .ConfigureFunctionsWebApplication()
+    .ConfigureDurableWorkflows(workflows => workflows.AddWorkflows(workflow))
+    .Build();
+app.Run();
@@ -0,0 +1,90 @@
+# Concurrent Workflow Sample
+
+This sample demonstrates how to use the Microsoft Agent Framework to create an Azure Functions app that orchestrates concurrent execution of multiple AI agents using the fan-out/fan-in pattern within a durable workflow.
+
+## Key Concepts Demonstrated
+
+- Defining workflows with fan-out/fan-in edges for parallel execution using `WorkflowBuilder`
+- Mixing custom executors with AI agents in a single workflow
+- Concurrent execution of multiple AI agents (physics and chemistry experts)
+- Response aggregation from parallel branches into a unified result
+- Durable orchestration with automatic checkpointing and resumption from failures
+- Viewing workflow execution history and status in the Durable Task Scheduler (DTS) dashboard
+
+## Workflow
+
+This sample defines a single workflow:
+
+**ExpertReview**: `ParseQuestion` → [`Physicist`, `Chemist`] (parallel) → `Aggregator`
+
+1. **ParseQuestion** — A custom executor that validates and formats the incoming question.
+2. **Physicist** and **Chemist** — AI agents that run concurrently, each providing an expert perspective.
+3. **Aggregator** — A custom executor that combines the parallel responses into a comprehensive answer.
+
+## 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.
+
+This sample requires Azure OpenAI. Set the following environment variables:
+
+- `AZURE_OPENAI_ENDPOINT` — Your Azure OpenAI endpoint URL.
+- `AZURE_OPENAI_DEPLOYMENT` — The name of your chat model deployment.
+- `AZURE_OPENAI_KEY` (optional) — Your Azure OpenAI API key. If not set, Azure CLI credentials are used.
+
+## Running the Sample
+
+With the environment setup and function app running, you can test the sample by sending an HTTP request with a science question to the workflow endpoint.
+
+You can use the `demo.http` file to trigger the workflow, or a command line tool like `curl` as shown below:
+
+Bash (Linux/macOS/WSL):
+
+```bash
+curl -X POST http://localhost:7071/api/workflows/ExpertReview/run \
+    -H "Content-Type: text/plain" \
+    -d "What is temperature?"
+```
+
+PowerShell:
+
+```powershell
+Invoke-RestMethod -Method Post `
+    -Uri http://localhost:7071/api/workflows/ExpertReview/run `
+    -ContentType text/plain `
+    -Body "What is temperature?"
+```
+
+The response will confirm the workflow orchestration has started:
+
+```text
+Workflow orchestration started for ExpertReview. Orchestration runId: abc123def456
+```
+
+> **Tip:** You can provide a custom run ID by appending a `runId` query parameter:
+>
+> ```bash
+> curl -X POST "http://localhost:7071/api/workflows/ExpertReview/run?runId=my-review-123" \
+>     -H "Content-Type: text/plain" \
+>     -d "What is temperature?"
+> ```
+>
+> If not provided, a unique run ID is auto-generated.
+
+In the function app logs, you will see the fan-out/fan-in execution pattern:
+
+```text
+│ [ParseQuestion] Preparing question for AI agents...
+│ [ParseQuestion] Question: "What is temperature?"
+│ [ParseQuestion] → Sending to Physicist and Chemist in PARALLEL...
+│ [Aggregator] 📋 Received 2 AI agent responses
+│ [Aggregator] Combining into comprehensive answer...
+│ [Aggregator] ✓ Aggregation complete!
+```
+
+The Physicist and Chemist AI agents execute concurrently, and the Aggregator combines their responses into a formatted expert panel result.
+
+### Viewing Workflows in the DTS Dashboard
+
+After running a workflow, you can navigate to the Durable Task Scheduler (DTS) dashboard to visualize the completed orchestration, inspect inputs/outputs for each step, and view execution history.
+
+If you are using the DTS emulator, the dashboard is available at `http://localhost:8082`.
@@ -0,0 +1,14 @@
+# Default endpoint address for local testing
+@authority=http://localhost:7071
+
+### Prompt the agent
+POST {{authority}}/api/workflows/ExpertReview/run
+Content-Type: text/plain
+
+What is temperature?
+
+### Start with a custom run ID
+POST {{authority}}/api/workflows/ExpertReview/run?runId=my-review-123
+Content-Type: text/plain
+
+What is gravity?
@@ -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"
+      }
+    }
+  }
+}
@@ -0,0 +1,43 @@
+<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>WorkflowHITLFunctions</AssemblyName>
+    <RootNamespace>WorkflowHITLFunctions</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.AspNetCore" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Sdk" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <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" />
+  </ItemGroup>
+  -->
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Hosting.AzureFunctions\Microsoft.Agents.AI.Hosting.AzureFunctions.csproj" />
+  </ItemGroup>
+</Project>
@@ -0,0 +1,63 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Agents.AI.Workflows;
+
+namespace WorkflowHITLFunctions;
+
+/// <summary>Expense approval request passed to the RequestPort.</summary>
+public record ApprovalRequest(string ExpenseId, decimal Amount, string EmployeeName);
+
+/// <summary>Approval response received from the RequestPort.</summary>
+public record ApprovalResponse(bool Approved, string? Comments);
+
+/// <summary>Looks up expense details and creates an approval request.</summary>
+internal sealed class CreateApprovalRequest() : Executor<string, ApprovalRequest>("RetrieveRequest")
+{
+    public override ValueTask<ApprovalRequest> HandleAsync(
+        string message,
+        IWorkflowContext context,
+        CancellationToken cancellationToken = default)
+    {
+        // In a real scenario, this would look up expense details from a database
+        return new ValueTask<ApprovalRequest>(new ApprovalRequest(message, 1500.00m, "Jerry"));
+    }
+}
+
+/// <summary>Prepares the approval request for finance review after manager approval.</summary>
+internal sealed class PrepareFinanceReview() : Executor<ApprovalResponse, ApprovalRequest>("PrepareFinanceReview")
+{
+    public override ValueTask<ApprovalRequest> HandleAsync(
+        ApprovalResponse message,
+        IWorkflowContext context,
+        CancellationToken cancellationToken = default)
+    {
+        if (!message.Approved)
+        {
+            throw new InvalidOperationException("Cannot proceed to finance review — manager denied the expense.");
+        }
+
+        // In a real scenario, this would retrieve the original expense details
+        return new ValueTask<ApprovalRequest>(new ApprovalRequest("EXP-2025-001", 1500.00m, "Jerry"));
+    }
+}
+
+/// <summary>Processes the expense reimbursement based on the parallel approval responses.</summary>
+internal sealed class ExpenseReimburse() : Executor<ApprovalResponse[], string>("Reimburse")
+{
+    public override async ValueTask<string> HandleAsync(
+        ApprovalResponse[] message,
+        IWorkflowContext context,
+        CancellationToken cancellationToken = default)
+    {
+        // Check that all parallel approvals passed
+        ApprovalResponse? denied = Array.Find(message, r => !r.Approved);
+        if (denied is not null)
+        {
+            return $"Expense reimbursement denied. Comments: {denied.Comments}";
+        }
+
+        // Simulate payment processing
+        await Task.Delay(1000, cancellationToken);
+        return $"Expense reimbursed at {DateTime.UtcNow:O}";
+    }
+}
@@ -0,0 +1,51 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample demonstrates a Human-in-the-Loop (HITL) workflow hosted in Azure Functions.
+//
+// ┌──────────────────────┐   ┌────────────────┐   ┌─────────────────────┐    ┌────────────────────┐
+// │ CreateApprovalRequest│──►│ManagerApproval │──►│PrepareFinanceReview │──┬►│  BudgetApproval    │──┐
+// └──────────────────────┘   │ (RequestPort)  │   └─────────────────────┘  │ │  (RequestPort)     │  │
+//                            └────────────────┘                            │ └────────────────────┘  │  ┌─────────────────┐
+//                                                                          │                         ├─►│ExpenseReimburse │
+//                                                                          │ ┌────────────────────┐  │  └─────────────────┘
+//                                                                          └►│ComplianceApproval  │──┘
+//                                                                            │  (RequestPort)     │
+//                                                                            └────────────────────┘
+//
+// The workflow pauses at three RequestPorts — one for the manager, then two in parallel for finance.
+// After manager approval, BudgetApproval and ComplianceApproval run concurrently via fan-out/fan-in.
+// The framework auto-generates three HTTP endpoints for each workflow:
+//   POST /api/workflows/{name}/run          - Start the workflow
+//   GET  /api/workflows/{name}/status/{id}  - Check status and pending approvals
+//   POST /api/workflows/{name}/respond/{id} - Send approval response to resume
+
+using Microsoft.Agents.AI.Hosting.AzureFunctions;
+using Microsoft.Agents.AI.Workflows;
+using Microsoft.Azure.Functions.Worker.Builder;
+using Microsoft.Extensions.Hosting;
+using WorkflowHITLFunctions;
+
+// Define executors and RequestPorts for the three HITL pause points
+CreateApprovalRequest createRequest = new();
+RequestPort<ApprovalRequest, ApprovalResponse> managerApproval = RequestPort.Create<ApprovalRequest, ApprovalResponse>("ManagerApproval");
+PrepareFinanceReview prepareFinanceReview = new();
+RequestPort<ApprovalRequest, ApprovalResponse> budgetApproval = RequestPort.Create<ApprovalRequest, ApprovalResponse>("BudgetApproval");
+RequestPort<ApprovalRequest, ApprovalResponse> complianceApproval = RequestPort.Create<ApprovalRequest, ApprovalResponse>("ComplianceApproval");
+ExpenseReimburse reimburse = new();
+
+// Build the workflow: CreateApprovalRequest -> ManagerApproval -> PrepareFinanceReview -> [BudgetApproval AND ComplianceApproval] -> ExpenseReimburse
+Workflow expenseApproval = new WorkflowBuilder(createRequest)
+    .WithName("ExpenseReimbursement")
+    .WithDescription("Expense reimbursement with manager and parallel finance approvals")
+    .AddEdge(createRequest, managerApproval)
+    .AddEdge(managerApproval, prepareFinanceReview)
+    .AddFanOutEdge(prepareFinanceReview, [budgetApproval, complianceApproval])
+    .AddFanInBarrierEdge([budgetApproval, complianceApproval], reimburse)
+    .Build();
+
+using IHost app = FunctionsApplication
+    .CreateBuilder(args)
+    .ConfigureFunctionsWebApplication()
+    .ConfigureDurableWorkflows(workflows => workflows.AddWorkflow(expenseApproval, exposeStatusEndpoint: true))
+    .Build();
+app.Run();
@@ -0,0 +1,266 @@
+# Human-in-the-Loop (HITL) Workflow — Azure Functions
+
+This sample demonstrates a durable workflow with Human-in-the-Loop support hosted in Azure Functions. The workflow pauses at three `RequestPort` nodes — one sequential manager approval, then two parallel finance approvals (budget and compliance) via fan-out/fan-in. Approval responses are sent via HTTP endpoints.
+
+## Key Concepts Demonstrated
+
+- Using multiple `RequestPort` nodes for sequential and parallel human-in-the-loop interactions in a durable workflow
+- Fan-out/fan-in pattern for parallel approval steps
+- Auto-generated HTTP endpoints for running workflows, checking status, and sending HITL responses
+- Pausing orchestrations via `WaitForExternalEvent` and resuming via `RaiseEventAsync`
+- Viewing inputs the workflow is waiting for via the status endpoint
+
+## Workflow
+
+This sample implements the following workflow:
+
+```
+┌──────────────────────┐   ┌────────────────┐   ┌─────────────────────┐    ┌────────────────────┐
+│ CreateApprovalRequest│──►│ManagerApproval │──►│PrepareFinanceReview │──┬►│  BudgetApproval    │──┐
+└──────────────────────┘   │ (RequestPort)  │   └─────────────────────┘  │ │  (RequestPort)     │  │
+                           └────────────────┘                            │ └────────────────────┘  │  ┌─────────────────┐
+                                                                         │                         ├─►│ExpenseReimburse │
+                                                                         │ ┌────────────────────┐  │  └─────────────────┘
+                                                                         └►│ComplianceApproval  │──┘
+                                                                           │  (RequestPort)     │
+                                                                           └────────────────────┘
+```
+
+## HTTP Endpoints
+
+The framework auto-generates these endpoints for workflows with `RequestPort` nodes:
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| POST | `/api/workflows/ExpenseReimbursement/run` | Start the workflow |
+| GET | `/api/workflows/ExpenseReimbursement/status/{runId}` | Check status and inputs the workflow is waiting for |
+| POST | `/api/workflows/ExpenseReimbursement/respond/{runId}` | Send approval response to resume |
+
+## Environment Setup
+
+See the [README.md](../../README.md) file in the parent directory for information on how to configure the environment, including how to install and run the Durable Task Scheduler.
+
+## Running the Sample
+
+With the environment setup and function app running, you can test the sample by sending HTTP requests to the workflow endpoints.
+
+You can use the `demo.http` file to trigger the workflow, or a command line tool like `curl` as shown below:
+
+### Step 1: Start the Workflow
+
+Bash (Linux/macOS/WSL):
+
+```bash
+curl -X POST http://localhost:7071/api/workflows/ExpenseReimbursement/run \
+    -H "Content-Type: text/plain" -d "EXP-2025-001"
+```
+
+PowerShell:
+
+```powershell
+Invoke-RestMethod -Method Post `
+    -Uri http://localhost:7071/api/workflows/ExpenseReimbursement/run `
+    -ContentType text/plain `
+    -Body "EXP-2025-001"
+```
+
+The response will confirm the workflow orchestration has started:
+
+```text
+Workflow orchestration started for ExpenseReimbursement. Orchestration runId: abc123def456
+```
+
+> [!TIP]
+> You can provide a custom run ID by appending a `runId` query parameter:
+>
+> Bash (Linux/macOS/WSL):
+>
+> ```bash
+> curl -X POST "http://localhost:7071/api/workflows/ExpenseReimbursement/run?runId=expense-001" \
+>     -H "Content-Type: text/plain" -d "EXP-2025-001"
+> ```
+>
+> PowerShell:
+>
+> ```powershell
+> Invoke-RestMethod -Method Post `
+>     -Uri "http://localhost:7071/api/workflows/ExpenseReimbursement/run?runId=expense-001" `
+>     -ContentType text/plain `
+>     -Body "EXP-2025-001"
+> ```
+>
+> If not provided, a unique run ID is auto-generated.
+
+### Step 2: Check Workflow Status
+
+The workflow pauses at the `ManagerApproval` RequestPort. Query the status endpoint to see what input it is waiting for:
+
+Bash (Linux/macOS/WSL):
+
+```bash
+curl http://localhost:7071/api/workflows/ExpenseReimbursement/status/{runId}
+```
+
+PowerShell:
+
+```powershell
+Invoke-RestMethod -Uri http://localhost:7071/api/workflows/ExpenseReimbursement/status/{runId}
+```
+
+```json
+{
+  "runId": "{runId}",
+  "status": "Running",
+  "waitingForInput": [
+    { "eventName": "ManagerApproval", "input": { "ExpenseId": "EXP-2025-001", "Amount": 1500.00, "EmployeeName": "Jerry" } }
+  ]
+}
+```
+
+> [!TIP]
+> You can also verify this in the DTS dashboard at `http://localhost:8082`. Find the orchestration by its `runId` and you will see it is in a "Running" state, paused at a `WaitForExternalEvent` call for the `ManagerApproval` event.
+
+### Step 3: Send Manager Approval Response
+
+Bash (Linux/macOS/WSL):
+
+```bash
+curl -X POST http://localhost:7071/api/workflows/ExpenseReimbursement/respond/{runId} \
+    -H "Content-Type: application/json" \
+    -d '{"eventName": "ManagerApproval", "response": {"Approved": true, "Comments": "Approved by manager."}}'
+```
+
+PowerShell:
+
+```powershell
+Invoke-RestMethod -Method Post `
+    -Uri http://localhost:7071/api/workflows/ExpenseReimbursement/respond/{runId} `
+    -ContentType application/json `
+    -Body '{"eventName": "ManagerApproval", "response": {"Approved": true, "Comments": "Approved by manager."}}'
+```
+
+```json
+{
+  "message": "Response sent to workflow.",
+  "runId": "{runId}",
+  "eventName": "ManagerApproval",
+  "validated": true
+}
+```
+
+### Step 4: Check Workflow Status Again
+
+The workflow now pauses at both the `BudgetApproval` and `ComplianceApproval` RequestPorts in parallel:
+
+Bash (Linux/macOS/WSL):
+
+```bash
+curl http://localhost:7071/api/workflows/ExpenseReimbursement/status/{runId}
+```
+
+PowerShell:
+
+```powershell
+Invoke-RestMethod -Uri http://localhost:7071/api/workflows/ExpenseReimbursement/status/{runId}
+```
+
+```json
+{
+  "runId": "{runId}",
+  "status": "Running",
+  "waitingForInput": [
+    { "eventName": "BudgetApproval", "input": { "ExpenseId": "EXP-2025-001", "Amount": 1500.00, "EmployeeName": "Jerry" } },
+    { "eventName": "ComplianceApproval", "input": { "ExpenseId": "EXP-2025-001", "Amount": 1500.00, "EmployeeName": "Jerry" } }
+  ]
+}
+```
+
+### Step 5a: Send Budget Approval Response
+
+Bash (Linux/macOS/WSL):
+
+```bash
+curl -X POST http://localhost:7071/api/workflows/ExpenseReimbursement/respond/{runId} \
+    -H "Content-Type: application/json" \
+    -d '{"eventName": "BudgetApproval", "response": {"Approved": true, "Comments": "Budget approved."}}'
+```
+
+PowerShell:
+
+```powershell
+Invoke-RestMethod -Method Post `
+    -Uri http://localhost:7071/api/workflows/ExpenseReimbursement/respond/{runId} `
+    -ContentType application/json `
+    -Body '{"eventName": "BudgetApproval", "response": {"Approved": true, "Comments": "Budget approved."}}'
+```
+
+```json
+{
+  "message": "Response sent to workflow.",
+  "runId": "{runId}",
+  "eventName": "BudgetApproval",
+  "validated": true
+}
+```
+
+### Step 5b: Send Compliance Approval Response
+
+Bash (Linux/macOS/WSL):
+
+```bash
+curl -X POST http://localhost:7071/api/workflows/ExpenseReimbursement/respond/{runId} \
+    -H "Content-Type: application/json" \
+    -d '{"eventName": "ComplianceApproval", "response": {"Approved": true, "Comments": "Compliance approved."}}'
+```
+
+PowerShell:
+
+```powershell
+Invoke-RestMethod -Method Post `
+    -Uri http://localhost:7071/api/workflows/ExpenseReimbursement/respond/{runId} `
+    -ContentType application/json `
+    -Body '{"eventName": "ComplianceApproval", "response": {"Approved": true, "Comments": "Compliance approved."}}'
+```
+
+```json
+{
+  "message": "Response sent to workflow.",
+  "runId": "{runId}",
+  "eventName": "ComplianceApproval",
+  "validated": true
+}
+```
+
+### Step 6: Check Final Status
+
+After all approvals, the workflow completes and the expense is reimbursed:
+
+Bash (Linux/macOS/WSL):
+
+```bash
+curl http://localhost:7071/api/workflows/ExpenseReimbursement/status/{runId}
+```
+
+PowerShell:
+
+```powershell
+Invoke-RestMethod -Uri http://localhost:7071/api/workflows/ExpenseReimbursement/status/{runId}
+```
+
+```json
+{
+  "runId": "{runId}",
+  "status": "Completed",
+  "waitingForInput": null
+}
+```
+
+### Viewing Workflows in the DTS Dashboard
+
+After running a workflow, you can navigate to the Durable Task Scheduler (DTS) dashboard to visualize the orchestration and inspect its execution history.
+
+If you are using the DTS emulator, the dashboard is available at `http://localhost:8082`.
+
+1. Open the dashboard and look for the orchestration instance matching the `runId` returned in Step 1 (e.g., `abc123def456` or your custom ID like `expense-001`).
+2. Click into the instance to see the execution timeline, which shows each executor activity and the `WaitForExternalEvent` pauses where the workflow waited for human input — including the two parallel finance approvals.
+3. Expand individual activity steps to inspect inputs and outputs — for example, the `ManagerApproval`, `BudgetApproval`, and `ComplianceApproval` external events will show the approval request sent and the response received.
@@ -0,0 +1,53 @@
+# Default endpoint address for local testing
+@authority=http://localhost:7071
+
+### Step 1: Start the expense reimbursement workflow
+POST {{authority}}/api/workflows/ExpenseReimbursement/run
+Content-Type: text/plain
+
+EXP-2025-001
+
+### Step 1 (alternative): Start the workflow with a custom run ID
+POST {{authority}}/api/workflows/ExpenseReimbursement/run?runId=expense-001
+Content-Type: text/plain
+
+EXP-2025-001
+
+### Step 2: Check workflow status (replace {runId} with actual run ID from Step 1)
+GET {{authority}}/api/workflows/ExpenseReimbursement/status/{runId}
+
+### Step 3: Send manager approval (replace {runId} with actual run ID from Step 1)
+POST {{authority}}/api/workflows/ExpenseReimbursement/respond/{runId}
+Content-Type: application/json
+
+{"eventName": "ManagerApproval", "response": {"Approved": true, "Comments": "Approved by manager."}}
+
+### Step 3 (alternative): Deny the expense at manager level
+POST {{authority}}/api/workflows/ExpenseReimbursement/respond/{runId}
+Content-Type: application/json
+
+{"eventName": "ManagerApproval", "response": {"Approved": false, "Comments": "Insufficient documentation. Please resubmit."}}
+
+### Step 4: Check workflow status after manager approval (now waiting for parallel finance approvals)
+GET {{authority}}/api/workflows/ExpenseReimbursement/status/{runId}
+
+### Step 5a: Send budget approval (replace {runId} with actual run ID from Step 1)
+POST {{authority}}/api/workflows/ExpenseReimbursement/respond/{runId}
+Content-Type: application/json
+
+{"eventName": "BudgetApproval", "response": {"Approved": true, "Comments": "Budget approved."}}
+
+### Step 5b: Send compliance approval (replace {runId} with actual run ID from Step 1)
+POST {{authority}}/api/workflows/ExpenseReimbursement/respond/{runId}
+Content-Type: application/json
+
+{"eventName": "ComplianceApproval", "response": {"Approved": true, "Comments": "Compliance approved."}}
+
+### Step 5b (alternative): Deny the expense at compliance level
+POST {{authority}}/api/workflows/ExpenseReimbursement/respond/{runId}
+Content-Type: application/json
+
+{"eventName": "ComplianceApproval", "response": {"Approved": false, "Comments": "Compliance requirements not met."}}
+
+### Step 6: Check final workflow status after all approvals
+GET {{authority}}/api/workflows/ExpenseReimbursement/status/{runId}
@@ -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"
+      }
+    }
+  }
+}
@@ -0,0 +1,35 @@
+<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>WorkflowMcpTool</AssemblyName>
+    <RootNamespace>WorkflowMcpTool</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <FrameworkReference Include="Microsoft.AspNetCore.App" />
+  </ItemGroup>
+
+  <!-- Azure Functions packages -->
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Azure.Functions.Worker" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.DurableTask" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.DurableTask.AzureManaged" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Sdk" />
+  </ItemGroup>
+
+  <!-- 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" />
+  </ItemGroup>
+  -->
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Hosting.AzureFunctions\Microsoft.Agents.AI.Hosting.AzureFunctions.csproj" />
+  </ItemGroup>
+</Project>
@@ -0,0 +1,59 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Agents.AI.Workflows;
+
+namespace WorkflowMcpTool;
+
+internal sealed class TranslateText() : Executor<string, TranslationResult>("TranslateText")
+{
+    public override ValueTask<TranslationResult> HandleAsync(
+        string message,
+        IWorkflowContext context,
+        CancellationToken cancellationToken = default)
+    {
+        Console.WriteLine($"[Activity] TranslateText: '{message}'");
+        return ValueTask.FromResult(new TranslationResult(message, message.ToUpperInvariant()));
+    }
+}
+
+internal sealed class FormatOutput() : Executor<TranslationResult, string>("FormatOutput")
+{
+    public override ValueTask<string> HandleAsync(
+        TranslationResult message,
+        IWorkflowContext context,
+        CancellationToken cancellationToken = default)
+    {
+        Console.WriteLine("[Activity] FormatOutput: Formatting result");
+        return ValueTask.FromResult($"Original: {message.Original} => Translated: {message.Translated}");
+    }
+}
+
+internal sealed class LookupOrder() : Executor<string, OrderInfo>("LookupOrder")
+{
+    public override ValueTask<OrderInfo> HandleAsync(
+        string message,
+        IWorkflowContext context,
+        CancellationToken cancellationToken = default)
+    {
+        Console.WriteLine($"[Activity] LookupOrder: '{message}'");
+        return ValueTask.FromResult(new OrderInfo(message, "Alice Johnson", "Wireless Headphones", Quantity: 2, UnitPrice: 49.99m));
+    }
+}
+
+internal sealed class EnrichOrder() : Executor<OrderInfo, OrderSummary>("EnrichOrder")
+{
+    public override ValueTask<OrderSummary> HandleAsync(
+        OrderInfo message,
+        IWorkflowContext context,
+        CancellationToken cancellationToken = default)
+    {
+        Console.WriteLine($"[Activity] EnrichOrder: '{message.OrderId}'");
+        return ValueTask.FromResult(new OrderSummary(message, TotalPrice: message.Quantity * message.UnitPrice, Status: "Confirmed"));
+    }
+}
+
+internal sealed record TranslationResult(string Original, string Translated);
+
+internal sealed record OrderInfo(string OrderId, string CustomerName, string Product, int Quantity, decimal UnitPrice);
+
+internal sealed record OrderSummary(OrderInfo Order, decimal TotalPrice, string Status);
@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample demonstrates how to expose a durable workflow as an MCP (Model Context Protocol) tool.
+// When using AddWorkflow with exposeMcpToolTrigger: true, the Functions host will automatically
+// generate a remote MCP endpoint for the app at /runtime/webhooks/mcp with a workflow-specific
+// tool name. MCP-compatible clients can then invoke the workflow as a tool.
+
+using Microsoft.Agents.AI.Hosting.AzureFunctions;
+using Microsoft.Agents.AI.Workflows;
+using Microsoft.Azure.Functions.Worker.Builder;
+using Microsoft.Extensions.Hosting;
+using WorkflowMcpTool;
+
+// Define executors
+TranslateText translateText = new();
+FormatOutput formatOutput = new();
+LookupOrder lookupOrder = new();
+EnrichOrder enrichOrder = new();
+
+// Build a simple workflow: TranslateText -> FormatOutput
+Workflow translateWorkflow = new WorkflowBuilder(translateText)
+    .WithName("Translate")
+    .WithDescription("Translate text to uppercase and format the result")
+    .AddEdge(translateText, formatOutput)
+    .Build();
+
+// Build a workflow that returns a POCO: LookupOrder -> EnrichOrder
+Workflow orderLookupWorkflow = new WorkflowBuilder(lookupOrder)
+    .WithName("OrderLookup")
+    .WithDescription("Look up an order by ID and return enriched order details")
+    .AddEdge(lookupOrder, enrichOrder)
+    .Build();
+
+using IHost app = FunctionsApplication
+    .CreateBuilder(args)
+    .ConfigureFunctionsWebApplication()
+    .ConfigureDurableWorkflows(workflows =>
+    {
+        // Expose both workflows as MCP tool triggers.
+        workflows.AddWorkflow(translateWorkflow, exposeStatusEndpoint: false, exposeMcpToolTrigger: true);
+        workflows.AddWorkflow(orderLookupWorkflow, exposeStatusEndpoint: false, exposeMcpToolTrigger: true);
+    })
+    .Build();
+app.Run();
@@ -0,0 +1,81 @@
+# Workflow as MCP Tool Sample
+
+This sample demonstrates how to expose durable workflows as [MCP (Model Context Protocol)](https://modelcontextprotocol.io/) tools, enabling MCP-compatible clients to invoke workflows directly.
+
+## Key Concepts Demonstrated
+
+- **Workflow as MCP Tool**: Expose workflows as callable MCP tools using `exposeMcpToolTrigger: true`
+- **MCP Server Hosting**: The Azure Functions host automatically generates a remote MCP endpoint at `/runtime/webhooks/mcp`
+- **String and POCO Results**: Shows workflows returning both plain strings and structured JSON objects
+
+## Sample Architecture
+
+The sample creates two workflows exposed as MCP tools:
+
+### Translate Workflow (returns a string)
+
+| Executor | Input | Output | Description |
+|----------|-------|--------|-------------|
+| **TranslateText** | `string` | `TranslationResult` | Converts input text to uppercase |
+| **FormatOutput** | `TranslationResult` | `string` | Formats the result into a readable string |
+
+### OrderLookup Workflow (returns a POCO)
+
+| Executor | Input | Output | Description |
+|----------|-------|--------|-------------|
+| **LookupOrder** | `string` | `OrderInfo` | Looks up an order by ID |
+| **EnrichOrder** | `OrderInfo` | `OrderSummary` | Adds computed fields (total price, status) |
+
+## Environment Setup
+
+See the [README.md](../../README.md) file in the parent directory for complete setup instructions, including:
+
+- Prerequisites installation
+- Durable Task Scheduler setup
+- Storage emulator configuration
+
+For this sample, you'll also need [Node.js](https://nodejs.org/en/download) to use the [MCP Inspector](https://modelcontextprotocol.io/docs/tools/inspector).
+
+## Running the Sample
+
+1. **Start the Function App**:
+
+   ```bash
+   cd dotnet/samples/04-hosting/DurableWorkflows/AzureFunctions/04_WorkflowMcpTool
+   func start
+   ```
+
+2. **Note the MCP Server Endpoint**: When the app starts, you'll see the MCP server endpoint in the terminal output:
+
+   ```text
+   MCP server endpoint:  http://localhost:7071/runtime/webhooks/mcp
+   ```
+
+## Invoking Workflows via MCP Inspector
+
+1. Install and run the [MCP Inspector](https://modelcontextprotocol.io/docs/tools/inspector):
+
+   ```bash
+   npx @modelcontextprotocol/inspector
+   ```
+
+2. Connect to the MCP server endpoint:
+   - For **Transport Type**, select **"Streamable HTTP"**
+   - For **URL**, enter `http://localhost:7071/runtime/webhooks/mcp`
+   - Click the **Connect** button
+
+3. Click the **List Tools** button. You should see two tools: `Translate` and `OrderLookup`.
+
+4. Test the **Translate** tool (returns a plain string):
+   - Select the `Translate` tool
+   - Set `hello world` as the `input` parameter
+   - Click **Run Tool**
+   - Expected result: `Original: hello world => Translated: HELLO WORLD`
+
+5. Test the **OrderLookup** tool (returns a JSON object):
+   - Select the `OrderLookup` tool
+   - Set `ORD-2025-42` as the `input` parameter
+   - Click **Run Tool**
+   - Expected result: A JSON object containing order details such as `OrderId`, `CustomerName`, `Product`, `TotalPrice`, and `Status`
+
+You'll see the workflow executor activities logged in the terminal where you ran `func start`.
@@ -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"
+      }
+    }
+  }
+}
@@ -0,0 +1,42 @@
+<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>WorkflowAndAgents</AssemblyName>
+    <RootNamespace>WorkflowAndAgents</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <FrameworkReference Include="Microsoft.AspNetCore.App" />
+  </ItemGroup>
+
+  <!-- Azure Functions packages -->
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Azure.Functions.Worker" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.DurableTask" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.DurableTask.AzureManaged" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Sdk" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Azure.AI.OpenAI" />
+    <PackageReference Include="Azure.Identity" />
+  </ItemGroup>
+
+  <!-- Local projects that should be switched to package references when using the sample outside of this MAF repo -->
+  <!--
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Agents.AI.Hosting.AzureFunctions" />
+    <PackageReference Include="Microsoft.Agents.AI.OpenAI" />
+  </ItemGroup>
+  -->
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Hosting.AzureFunctions\Microsoft.Agents.AI.Hosting.AzureFunctions.csproj" />
+    <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
+  </ItemGroup>
+</Project>
@@ -0,0 +1,31 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Agents.AI.Workflows;
+
+namespace WorkflowAndAgents;
+
+internal sealed class TranslateText() : Executor<string, TranslationResult>("TranslateText")
+{
+    public override ValueTask<TranslationResult> HandleAsync(
+        string message,
+        IWorkflowContext context,
+        CancellationToken cancellationToken = default)
+    {
+        Console.WriteLine($"[Activity] TranslateText: '{message}'");
+        return ValueTask.FromResult(new TranslationResult(message, message.ToUpperInvariant()));
+    }
+}
+
+internal sealed class FormatOutput() : Executor<TranslationResult, string>("FormatOutput")
+{
+    public override ValueTask<string> HandleAsync(
+        TranslationResult message,
+        IWorkflowContext context,
+        CancellationToken cancellationToken = default)
+    {
+        Console.WriteLine("[Activity] FormatOutput: Formatting result");
+        return ValueTask.FromResult($"Original: {message.Original} => Translated: {message.Translated}");
+    }
+}
+
+internal sealed record TranslationResult(string Original, string Translated);
@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample demonstrates using ConfigureDurableOptions to register BOTH agents AND workflows
+// in a single Azure Functions app. It uses a workflow to translate text and a standalone AI agent
+// accessible via HTTP and MCP tool triggers.
+
+#pragma warning disable IDE0002 // Simplify Member Access
+
+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.Hosting;
+using OpenAI.Chat;
+using WorkflowAndAgents;
+
+// 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_NAME")
+    ?? throw new InvalidOperationException("AZURE_OPENAI_DEPLOYMENT_NAME is not set.");
+
+// Use Azure Key Credential if provided, otherwise use Azure CLI Credential.
+string? azureOpenAiKey = Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY");
+AzureOpenAIClient client = !string.IsNullOrEmpty(azureOpenAiKey)
+    ? new AzureOpenAIClient(new Uri(endpoint), new AzureKeyCredential(azureOpenAiKey))
+    // WARNING: DefaultAzureCredential is convenient for development but requires careful consideration in production.
+    // In production, consider using a specific credential (e.g., ManagedIdentityCredential) to avoid
+    // latency issues, unintended credential probing, and potential security risks from fallback mechanisms.
+    : new AzureOpenAIClient(new Uri(endpoint), new DefaultAzureCredential());
+
+ChatClient chatClient = client.GetChatClient(deploymentName);
+
+// Define a standalone AI agent
+AIAgent assistant = chatClient.AsAIAgent(
+    "You are a helpful assistant. Answer questions clearly and concisely.",
+    "Assistant",
+    description: "A general-purpose helpful assistant.");
+
+// Define workflow executors
+TranslateText translateText = new();
+FormatOutput formatOutput = new();
+
+// Build a workflow: TranslateText -> FormatOutput
+Workflow translateWorkflow = new WorkflowBuilder(translateText)
+    .WithName("Translate")
+    .WithDescription("Translate text to uppercase and format the result")
+    .AddEdge(translateText, formatOutput)
+    .Build();
+
+// Use ConfigureDurableOptions to register both agents and workflows together
+using IHost app = FunctionsApplication
+    .CreateBuilder(args)
+    .ConfigureFunctionsWebApplication()
+    .ConfigureDurableOptions(options =>
+    {
+        // Register the standalone agent with HTTP and MCP tool triggers
+        options.Agents.AddAIAgent(assistant, enableHttpTrigger: true, enableMcpToolTrigger: true);
+
+        // Register the workflow with an HTTP endpoint and MCP tool trigger
+        options.Workflows.AddWorkflow(translateWorkflow, exposeStatusEndpoint: false, exposeMcpToolTrigger: true);
+    })
+    .Build();
+app.Run();
@@ -0,0 +1,76 @@
+# Workflow and Agents Sample
+
+This sample demonstrates how to use `ConfigureDurableOptions` to register **both** AI agents **and** workflows in a single Azure Functions app. This is the recommended approach when your application needs both standalone agents and orchestrated workflows.
+
+## Key Concepts Demonstrated
+
+- **Unified Configuration**: Use `ConfigureDurableOptions` to register agents and workflows together
+- **Standalone Agent**: An AI agent accessible via HTTP and MCP tool triggers
+- **Workflow**: A simple text translation workflow also exposed as an MCP tool
+- **Mixed Triggers**: Both agents and workflows coexist in the same Functions host
+
+## Sample Architecture
+
+### Standalone Agent
+
+| Agent | Description |
+|-------|-------------|
+| **Assistant** | A general-purpose AI assistant accessible via HTTP (`/agents/Assistant/run`) and as an MCP tool |
+
+### Translate Workflow
+
+| Executor | Input | Output | Description |
+|----------|-------|--------|-------------|
+| **TranslateText** | `string` | `TranslationResult` | Converts input text to uppercase |
+| **FormatOutput** | `TranslationResult` | `string` | Formats the result into a readable string |
+
+## Environment Setup
+
+See the [README.md](../../README.md) file in the parent directory for complete setup instructions, including:
+
+- Prerequisites installation
+- Durable Task Scheduler setup
+- Storage emulator configuration
+
+This sample also requires Azure OpenAI credentials. Set the following in `local.settings.json`:
+
+- `AZURE_OPENAI_ENDPOINT`: Your Azure OpenAI endpoint URL
+- `AZURE_OPENAI_DEPLOYMENT_NAME`: Your chat model deployment name
+- `AZURE_OPENAI_API_KEY` (optional): If not set, Azure CLI credential is used
+
+## Running the Sample
+
+1. **Start the Function App**:
+
+   ```bash
+   cd dotnet/samples/04-hosting/DurableWorkflows/AzureFunctions/05_WorkflowAndAgents
+   func start
+   ```
+
+2. **Expected Functions**: When the app starts, you should see functions for both the agent and the workflow:
+
+   - `dafx-Assistant` (entity trigger for the agent)
+   - `http-Assistant` (HTTP trigger for the agent)
+   - `mcptool-Assistant` (MCP tool trigger for the agent)
+   - `wf-Translate` (orchestration trigger for the workflow)
+   - `mcptool-wf-Translate` (MCP tool trigger for the workflow)
+
+## Invoking the Agent via HTTP
+
+```bash
+curl -X POST http://localhost:7071/agents/Assistant/run \
+  -H "Content-Type: application/json" \
+  -d '{"query": "What is the capital of France?"}'
+```
+
+## Invoking via MCP Inspector
+
+1. Install and run the [MCP Inspector](https://modelcontextprotocol.io/docs/tools/inspector):
+
+   ```bash
+   npx @modelcontextprotocol/inspector
+   ```
+
+2. Connect to `http://localhost:7071/runtime/webhooks/mcp` using **Streamable HTTP** transport.
+
+3. Click **List Tools** to see both the `Assistant` agent tool and the `Translate` workflow tool.
@@ -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"
+      }
+    }
+  }
+}