diff --git a/dotnet/agent-framework-dotnet.slnx b/dotnet/agent-framework-dotnet.slnx
index 2c5ea815c5..246b3e7e7b 100644
--- a/dotnet/agent-framework-dotnet.slnx
+++ b/dotnet/agent-framework-dotnet.slnx
@@ -54,6 +54,7 @@
+
diff --git a/dotnet/samples/Durable/Workflow/ConsoleApps/07_SubWorkflows/07_SubWorkflows.csproj b/dotnet/samples/Durable/Workflow/ConsoleApps/07_SubWorkflows/07_SubWorkflows.csproj
new file mode 100644
index 0000000000..d8d36ead01
--- /dev/null
+++ b/dotnet/samples/Durable/Workflow/ConsoleApps/07_SubWorkflows/07_SubWorkflows.csproj
@@ -0,0 +1,28 @@
+
+
+ net10.0
+ Exe
+ enable
+ enable
+ SubWorkflows
+ SubWorkflows
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/dotnet/samples/Durable/Workflow/ConsoleApps/07_SubWorkflows/Executors.cs b/dotnet/samples/Durable/Workflow/ConsoleApps/07_SubWorkflows/Executors.cs
new file mode 100644
index 0000000000..25c7228642
--- /dev/null
+++ b/dotnet/samples/Durable/Workflow/ConsoleApps/07_SubWorkflows/Executors.cs
@@ -0,0 +1,233 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Agents.AI.Workflows;
+using Microsoft.Agents.AI.Workflows.Checkpointing;
+
+namespace SubWorkflows;
+
+///
+/// Event emitted when the fraud check risk score is calculated.
+///
+internal sealed class FraudRiskAssessedEvent(int riskScore) : WorkflowEvent($"Risk score: {riskScore}/100")
+{
+ public int RiskScore => riskScore;
+}
+
+///
+/// Represents an order being processed through the workflow.
+///
+internal sealed class OrderInfo
+{
+ public required string OrderId { get; set; }
+
+ public decimal Amount { get; set; }
+
+ public string? PaymentTransactionId { get; set; }
+
+ public string? TrackingNumber { get; set; }
+
+ public string? Carrier { get; set; }
+}
+
+// Main workflow executors
+
+///
+/// Entry point executor that receives the order ID and creates an OrderInfo object.
+///
+internal sealed class OrderReceived() : Executor("OrderReceived")
+{
+ public override ValueTask HandleAsync(string message, IWorkflowContext context, CancellationToken cancellationToken = default)
+ {
+ Console.WriteLine();
+ Console.ForegroundColor = ConsoleColor.Cyan;
+ Console.WriteLine($"[OrderReceived] Processing order '{message}'");
+ Console.ResetColor();
+
+ OrderInfo order = new()
+ {
+ OrderId = message,
+ Amount = 99.99m // Simulated order amount
+ };
+
+ return ValueTask.FromResult(order);
+ }
+}
+
+///
+/// Final executor that outputs the completed order summary.
+///
+internal sealed class OrderCompleted() : Executor("OrderCompleted")
+{
+ public override ValueTask HandleAsync(OrderInfo message, IWorkflowContext context, CancellationToken cancellationToken = default)
+ {
+ Console.WriteLine();
+ Console.ForegroundColor = ConsoleColor.Green;
+ Console.WriteLine("┌─────────────────────────────────────────────────────────────────┐");
+ Console.WriteLine($"│ [OrderCompleted] Order '{message.OrderId}' successfully processed!");
+ Console.WriteLine($"│ Payment: {message.PaymentTransactionId}");
+ Console.WriteLine($"│ Shipping: {message.Carrier} - {message.TrackingNumber}");
+ Console.WriteLine("└─────────────────────────────────────────────────────────────────┘");
+ Console.ResetColor();
+
+ return ValueTask.FromResult($"Order {message.OrderId} completed. Tracking: {message.TrackingNumber}");
+ }
+}
+
+// Payment sub-workflow executors
+
+///
+/// Validates payment information for an order.
+///
+internal sealed class ValidatePayment() : Executor("ValidatePayment")
+{
+ public override async ValueTask HandleAsync(OrderInfo message, IWorkflowContext context, CancellationToken cancellationToken = default)
+ {
+ Console.WriteLine();
+ Console.ForegroundColor = ConsoleColor.Yellow;
+ Console.WriteLine($" [Payment/ValidatePayment] Validating payment for order '{message.OrderId}'...");
+ Console.ResetColor();
+
+ await Task.Delay(TimeSpan.FromMilliseconds(100), cancellationToken);
+
+ Console.ForegroundColor = ConsoleColor.Yellow;
+ Console.WriteLine($" [Payment/ValidatePayment] Payment validated for ${message.Amount}");
+ Console.ResetColor();
+
+ return message;
+ }
+}
+
+///
+/// Charges the payment for an order.
+///
+internal sealed class ChargePayment() : Executor("ChargePayment")
+{
+ public override async ValueTask HandleAsync(OrderInfo message, IWorkflowContext context, CancellationToken cancellationToken = default)
+ {
+ Console.ForegroundColor = ConsoleColor.Yellow;
+ Console.WriteLine($" [Payment/ChargePayment] Charging ${message.Amount} for order '{message.OrderId}'...");
+ Console.ResetColor();
+
+ await Task.Delay(TimeSpan.FromMilliseconds(100), cancellationToken);
+
+ message.PaymentTransactionId = $"TXN-{Guid.NewGuid().ToString("N")[..8].ToUpperInvariant()}";
+
+ Console.ForegroundColor = ConsoleColor.Yellow;
+ Console.WriteLine($" [Payment/ChargePayment] ✓ Payment processed: {message.PaymentTransactionId}");
+ Console.ResetColor();
+
+ return message;
+ }
+}
+
+// FraudCheck sub-sub-workflow executors (nested inside Payment)
+
+///
+/// Analyzes transaction patterns for potential fraud.
+///
+internal sealed class AnalyzePatterns() : Executor("AnalyzePatterns")
+{
+ public override async ValueTask HandleAsync(OrderInfo message, IWorkflowContext context, CancellationToken cancellationToken = default)
+ {
+ Console.ForegroundColor = ConsoleColor.DarkYellow;
+ Console.WriteLine($" [Payment/FraudCheck/AnalyzePatterns] Analyzing patterns for order '{message.OrderId}'...");
+ Console.ResetColor();
+
+ await Task.Delay(TimeSpan.FromMilliseconds(100), cancellationToken);
+
+ // Store analysis results in shared state for the next executor in this sub-workflow
+ int patternsFound = new Random().Next(0, 5);
+ await context.QueueStateUpdateAsync("patternsFound", patternsFound, cancellationToken: cancellationToken);
+
+ Console.ForegroundColor = ConsoleColor.DarkYellow;
+ Console.WriteLine($" [Payment/FraudCheck/AnalyzePatterns] ✓ Pattern analysis complete ({patternsFound} suspicious patterns)");
+ Console.ResetColor();
+
+ return message;
+ }
+}
+
+///
+/// Calculates a risk score for the transaction.
+///
+internal sealed class CalculateRiskScore() : Executor("CalculateRiskScore")
+{
+ public override async ValueTask HandleAsync(OrderInfo message, IWorkflowContext context, CancellationToken cancellationToken = default)
+ {
+ Console.ForegroundColor = ConsoleColor.DarkYellow;
+ Console.WriteLine($" [Payment/FraudCheck/CalculateRiskScore] Calculating risk score for order '{message.OrderId}'...");
+ Console.ResetColor();
+
+ await Task.Delay(TimeSpan.FromMilliseconds(100), cancellationToken);
+
+ // Read the pattern count from shared state (written by AnalyzePatterns)
+ int patternsFound = await context.ReadStateAsync("patternsFound", cancellationToken: cancellationToken);
+ int riskScore = Math.Min(patternsFound * 20 + new Random().Next(1, 20), 100);
+
+ // Emit a workflow event from within a nested sub-workflow
+ await context.AddEventAsync(new FraudRiskAssessedEvent(riskScore), cancellationToken);
+
+ Console.ForegroundColor = ConsoleColor.DarkYellow;
+ Console.WriteLine($" [Payment/FraudCheck/CalculateRiskScore] ✓ Risk score: {riskScore}/100 (based on {patternsFound} patterns)");
+ Console.ResetColor();
+
+ return message;
+ }
+}
+
+// Shipping sub-workflow executors
+
+///
+/// Selects a shipping carrier for an order.
+///
+///
+/// This executor uses (void return) combined with
+/// to forward the order to the next
+/// connected executor (CreateShipment). This demonstrates explicit typed message passing
+/// as an alternative to returning a value from the handler.
+///
+internal sealed class SelectCarrier() : Executor("SelectCarrier")
+{
+ public override async ValueTask HandleAsync(OrderInfo message, IWorkflowContext context, CancellationToken cancellationToken = default)
+ {
+ Console.WriteLine();
+ Console.ForegroundColor = ConsoleColor.Blue;
+ Console.WriteLine($" [Shipping/SelectCarrier] Selecting carrier for order '{message.OrderId}'...");
+ Console.ResetColor();
+
+ await Task.Delay(TimeSpan.FromMilliseconds(100), cancellationToken);
+
+ message.Carrier = message.Amount > 50 ? "Express" : "Standard";
+
+ Console.ForegroundColor = ConsoleColor.Blue;
+ Console.WriteLine($" [Shipping/SelectCarrier] ✓ Selected carrier: {message.Carrier}");
+ Console.ResetColor();
+
+ // Use SendMessageAsync to forward the updated order to connected executors.
+ // With a void-return executor, this is the mechanism for passing data downstream.
+ await context.SendMessageAsync(message, cancellationToken: cancellationToken);
+ }
+}
+
+///
+/// Creates shipment and generates tracking number.
+///
+internal sealed class CreateShipment() : Executor("CreateShipment")
+{
+ public override async ValueTask HandleAsync(OrderInfo message, IWorkflowContext context, CancellationToken cancellationToken = default)
+ {
+ Console.ForegroundColor = ConsoleColor.Blue;
+ Console.WriteLine($" [Shipping/CreateShipment] Creating shipment for order '{message.OrderId}'...");
+ Console.ResetColor();
+
+ await Task.Delay(TimeSpan.FromMilliseconds(100), cancellationToken);
+
+ message.TrackingNumber = $"TRACK-{Guid.NewGuid().ToString("N")[..10].ToUpperInvariant()}";
+
+ Console.ForegroundColor = ConsoleColor.Blue;
+ Console.WriteLine($" [Shipping/CreateShipment] ✓ Shipment created: {message.TrackingNumber}");
+ Console.ResetColor();
+
+ return message;
+ }
+}
diff --git a/dotnet/samples/Durable/Workflow/ConsoleApps/07_SubWorkflows/Program.cs b/dotnet/samples/Durable/Workflow/ConsoleApps/07_SubWorkflows/Program.cs
new file mode 100644
index 0000000000..d542f4aba5
--- /dev/null
+++ b/dotnet/samples/Durable/Workflow/ConsoleApps/07_SubWorkflows/Program.cs
@@ -0,0 +1,146 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample demonstrates nested sub-workflows. A sub-workflow can act as an executor
+// within another workflow, including multi-level nesting (sub-workflow within sub-workflow).
+
+using Microsoft.Agents.AI.DurableTask;
+using Microsoft.Agents.AI.DurableTask.Workflows;
+using Microsoft.Agents.AI.Workflows;
+using Microsoft.DurableTask.Client.AzureManaged;
+using Microsoft.DurableTask.Worker.AzureManaged;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using SubWorkflows;
+
+// Get DTS connection string from environment variable
+string dtsConnectionString = Environment.GetEnvironmentVariable("DURABLE_TASK_SCHEDULER_CONNECTION_STRING")
+ ?? "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None";
+
+// Build the FraudCheck sub-workflow (this will be nested inside the Payment sub-workflow)
+AnalyzePatterns analyzePatterns = new();
+CalculateRiskScore calculateRiskScore = new();
+
+Workflow fraudCheckWorkflow = new WorkflowBuilder(analyzePatterns)
+ .WithName("SubFraudCheck")
+ .WithDescription("Analyzes transaction patterns and calculates risk score")
+ .AddEdge(analyzePatterns, calculateRiskScore)
+ .Build();
+
+// Build the Payment sub-workflow: ValidatePayment -> FraudCheck (sub-workflow) -> ChargePayment
+ValidatePayment validatePayment = new();
+ExecutorBinding fraudCheckExecutor = fraudCheckWorkflow.BindAsExecutor("FraudCheck");
+ChargePayment chargePayment = new();
+
+Workflow paymentWorkflow = new WorkflowBuilder(validatePayment)
+ .WithName("SubPaymentProcessing")
+ .WithDescription("Validates and processes payment for an order")
+ .AddEdge(validatePayment, fraudCheckExecutor)
+ .AddEdge(fraudCheckExecutor, chargePayment)
+ .Build();
+
+// Build the Shipping sub-workflow: SelectCarrier -> CreateShipment
+SelectCarrier selectCarrier = new();
+CreateShipment createShipment = new();
+
+Workflow shippingWorkflow = new WorkflowBuilder(selectCarrier)
+ .WithName("SubShippingArrangement")
+ .WithDescription("Selects carrier and creates shipment")
+ .AddEdge(selectCarrier, createShipment)
+ .Build();
+
+// Build the main workflow using sub-workflows as executors
+// OrderReceived -> Payment (sub-workflow) -> Shipping (sub-workflow) -> OrderCompleted
+OrderReceived orderReceived = new();
+OrderCompleted orderCompleted = new();
+ExecutorBinding paymentExecutor = paymentWorkflow.BindAsExecutor("Payment");
+ExecutorBinding shippingExecutor = shippingWorkflow.BindAsExecutor("Shipping");
+
+Workflow orderProcessingWorkflow = new WorkflowBuilder(orderReceived)
+ .WithName("OrderProcessing")
+ .WithDescription("Processes an order through payment and shipping")
+ .AddEdge(orderReceived, paymentExecutor)
+ .AddEdge(paymentExecutor, shippingExecutor)
+ .AddEdge(shippingExecutor, orderCompleted)
+ .Build();
+
+// Configure and start the host
+// Register only the main workflow - sub-workflows are discovered automatically!
+IHost host = Host.CreateDefaultBuilder(args)
+ .ConfigureLogging(logging => logging.SetMinimumLevel(LogLevel.Warning))
+ .ConfigureServices(services =>
+ {
+ services.ConfigureDurableWorkflows(
+ workflowOptions => workflowOptions.AddWorkflow(orderProcessingWorkflow),
+ workerBuilder: builder => builder.UseDurableTaskScheduler(dtsConnectionString),
+ clientBuilder: builder => builder.UseDurableTaskScheduler(dtsConnectionString));
+ })
+ .Build();
+
+await host.StartAsync();
+
+IWorkflowClient workflowClient = host.Services.GetRequiredService();
+
+Console.WriteLine("Durable Sub-Workflows Sample");
+Console.WriteLine("Workflow: OrderReceived -> Payment(sub) -> Shipping(sub) -> OrderCompleted");
+Console.WriteLine(" Payment contains nested FraudCheck sub-workflow (Level 2 nesting)");
+Console.WriteLine();
+Console.WriteLine("Enter an order ID (or 'exit'):");
+
+while (true)
+{
+ Console.Write("> ");
+ string? input = Console.ReadLine();
+ if (string.IsNullOrWhiteSpace(input) || input.Equals("exit", StringComparison.OrdinalIgnoreCase))
+ {
+ break;
+ }
+
+ try
+ {
+ await StartNewWorkflowAsync(input, orderProcessingWorkflow, workflowClient);
+ }
+ catch (Exception ex)
+ {
+ Console.WriteLine($"Error: {ex.Message}");
+ }
+
+ Console.WriteLine();
+}
+
+await host.StopAsync();
+
+// Start a new workflow using streaming to observe events (including from sub-workflows)
+static async Task StartNewWorkflowAsync(string orderId, Workflow workflow, IWorkflowClient client)
+{
+ Console.WriteLine($"\nStarting order processing for '{orderId}'...");
+
+ IStreamingWorkflowRun run = await client.StreamAsync(workflow, orderId);
+ Console.WriteLine($"Run ID: {run.RunId}");
+ Console.WriteLine();
+
+ await foreach (WorkflowEvent evt in run.WatchStreamAsync())
+ {
+ switch (evt)
+ {
+ // Custom event emitted from the FraudCheck sub-sub-workflow
+ case FraudRiskAssessedEvent e:
+ Console.ForegroundColor = ConsoleColor.DarkYellow;
+ Console.WriteLine($" [Event from sub-workflow] {e.GetType().Name}: Risk score {e.RiskScore}/100");
+ Console.ResetColor();
+ break;
+
+ case DurableWorkflowCompletedEvent e:
+ Console.ForegroundColor = ConsoleColor.Green;
+ Console.WriteLine($"✓ Order completed: {e.Result}");
+ Console.ResetColor();
+ break;
+
+ case DurableWorkflowFailedEvent e:
+ Console.ForegroundColor = ConsoleColor.Red;
+ Console.WriteLine($"✗ Failed: {e.ErrorMessage}");
+ Console.ResetColor();
+ break;
+ }
+ }
+}
diff --git a/dotnet/samples/Durable/Workflow/ConsoleApps/07_SubWorkflows/README.md b/dotnet/samples/Durable/Workflow/ConsoleApps/07_SubWorkflows/README.md
new file mode 100644
index 0000000000..4f7773dd03
--- /dev/null
+++ b/dotnet/samples/Durable/Workflow/ConsoleApps/07_SubWorkflows/README.md
@@ -0,0 +1,105 @@
+# Sub-Workflows Sample (Nested Workflows)
+
+This sample demonstrates how to compose complex workflows from simpler, reusable sub-workflows. Sub-workflows are built using `WorkflowBuilder` and embedded as executors via `BindAsExecutor()`. Unlike the in-process workflow runner, the durable workflow backend persists execution state across process restarts — each sub-workflow runs as a separate orchestration instance on the Durable Task Scheduler, providing independent checkpointing, fault tolerance, and hierarchical visualization in the DTS dashboard.
+
+## Key Concepts Demonstrated
+
+- **Sub-workflows**: Using `Workflow.BindAsExecutor()` to embed a workflow as an executor in another workflow
+- **Multi-level nesting**: Sub-workflows within sub-workflows (Level 2 nesting)
+- **Automatic discovery**: Registering only the main workflow; sub-workflows are discovered automatically
+- **Failure isolation**: Each sub-workflow runs as a separate orchestration instance on the DTS backend
+- **Hierarchical visualization**: Parent-child orchestration hierarchy visible in the DTS dashboard
+- **Event propagation**: Custom workflow events (`FraudRiskAssessedEvent`) bubble up from nested sub-workflows to the streaming client
+- **Message passing**: Using `Executor` (void return) with `SendMessageAsync` to forward typed messages to connected executors (`SelectCarrier`)
+- **Shared state within sub-workflows**: Using `QueueStateUpdateAsync`/`ReadStateAsync` to share data between executors within a sub-workflow (`AnalyzePatterns` → `CalculateRiskScore`)
+
+## Overview
+
+The sample implements an order processing workflow composed of two sub-workflows, one of which contains its own nested sub-workflow:
+
+```
+OrderProcessing (main workflow)
+├── OrderReceived
+├── Payment (sub-workflow)
+│ ├── ValidatePayment
+│ ├── FraudCheck (sub-sub-workflow) ← Level 2 nesting!
+│ │ ├── AnalyzePatterns
+│ │ └── CalculateRiskScore
+│ └── ChargePayment
+├── Shipping (sub-workflow)
+│ ├── SelectCarrier ← Uses SendMessageAsync (void-return executor)
+│ └── CreateShipment
+└── OrderCompleted
+```
+
+| Executor | Sub-Workflow | Description |
+|----------|-------------|-------------|
+| OrderReceived | Main | Receives order ID and creates order info |
+| ValidatePayment | Payment | Validates payment information |
+| AnalyzePatterns | FraudCheck (nested in Payment) | Analyzes transaction patterns, stores results in shared state |
+| CalculateRiskScore | FraudCheck (nested in Payment) | Reads shared state, calculates risk score, emits `FraudRiskAssessedEvent` |
+| ChargePayment | Payment | Charges payment amount |
+| SelectCarrier | Shipping | Selects carrier using `SendMessageAsync` (void-return executor) |
+| CreateShipment | Shipping | Creates shipment with tracking |
+| OrderCompleted | Main | Outputs completed order summary |
+
+## How Sub-Workflows Work
+
+For an introduction to sub-workflows and the `BindAsExecutor()` API, see the [Sub-Workflows foundational sample](../../../GettingStarted/Workflows/_Foundational/06_SubWorkflows).
+
+This durable sample extends the same pattern — the key difference is that each sub-workflow runs as a **separate orchestration instance** on the Durable Task Scheduler, providing independent checkpointing, fault tolerance, and hierarchical visualization in the DTS dashboard.
+
+## Environment Setup
+
+See the [README.md](../../README.md) file in the parent directory for information on configuring the environment, including how to install and run the Durable Task Scheduler.
+
+## Running the Sample
+
+```bash
+cd dotnet/samples/Durable/Workflow/ConsoleApps/07_SubWorkflows
+dotnet run --framework net10.0
+```
+
+### Sample Output
+
+```text
+Durable Sub-Workflows Sample
+Workflow: OrderReceived -> Payment(sub) -> Shipping(sub) -> OrderCompleted
+ Payment contains nested FraudCheck sub-workflow (Level 2 nesting)
+
+Enter an order ID (or 'exit'):
+> ORD-001
+Starting order processing for 'ORD-001'...
+Run ID: abc123...
+
+[OrderReceived] Processing order 'ORD-001'
+ [Payment/ValidatePayment] Validating payment for order 'ORD-001'...
+ [Payment/ValidatePayment] Payment validated for $99.99
+ [Payment/FraudCheck/AnalyzePatterns] Analyzing patterns for order 'ORD-001'...
+ [Payment/FraudCheck/AnalyzePatterns] ✓ Pattern analysis complete (2 suspicious patterns)
+ [Payment/FraudCheck/CalculateRiskScore] Calculating risk score for order 'ORD-001'...
+ [Payment/FraudCheck/CalculateRiskScore] ✓ Risk score: 53/100 (based on 2 patterns)
+ [Event from sub-workflow] FraudRiskAssessedEvent: Risk score 53/100
+ [Payment/ChargePayment] Charging $99.99 for order 'ORD-001'...
+ [Payment/ChargePayment] ✓ Payment processed: TXN-A1B2C3D4
+ [Shipping/SelectCarrier] Selecting carrier for order 'ORD-001'...
+ [Shipping/SelectCarrier] ✓ Selected carrier: Express
+ [Shipping/CreateShipment] Creating shipment for order 'ORD-001'...
+ [Shipping/CreateShipment] ✓ Shipment created: TRACK-I9J0K1L2M3
+┌─────────────────────────────────────────────────────────────────┐
+│ [OrderCompleted] Order 'ORD-001' successfully processed!
+│ Payment: TXN-A1B2C3D4
+│ Shipping: Express - TRACK-I9J0K1L2M3
+└─────────────────────────────────────────────────────────────────┘
+✓ Order completed: Order ORD-001 completed. Tracking: TRACK-I9J0K1L2M3
+
+> exit
+```
+
+### Viewing Workflows in the DTS Dashboard
+
+After running the workflow, you can navigate to the Durable Task Scheduler (DTS) dashboard to inspect the orchestration hierarchy, including sub-orchestrations.
+
+If you are using the DTS emulator, the dashboard is available at `http://localhost:8082`.
+
+Because each sub-workflow runs as a separate orchestration instance, the dashboard shows a parent-child hierarchy: the top-level `OrderProcessing` orchestration with `Payment` and `Shipping` as child orchestrations, and `FraudCheck` nested under `Payment`. You can click into each orchestration to inspect its executor inputs/outputs, events, and execution timeline independently.
diff --git a/dotnet/src/Microsoft.Agents.AI.DurableTask/ServiceCollectionExtensions.cs b/dotnet/src/Microsoft.Agents.AI.DurableTask/ServiceCollectionExtensions.cs
index 29e56ea398..2175cf5bb9 100644
--- a/dotnet/src/Microsoft.Agents.AI.DurableTask/ServiceCollectionExtensions.cs
+++ b/dotnet/src/Microsoft.Agents.AI.DurableTask/ServiceCollectionExtensions.cs
@@ -251,7 +251,7 @@ private static void RegisterTasksFromOptions(DurableTaskRegistry registry, Durab
foreach (WorkflowRegistrationInfo registration in registrations)
{
// Register with DurableWorkflowInput