chore: import upstream snapshot with attribution

dotnet/samples/04-hosting/DurableAgents/ConsoleApps/07_ReliableStreaming/07_ReliableStreaming.csproj

@@ -0,0 +1,31 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+    <OutputType>Exe</OutputType>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <AssemblyName>ReliableStreaming</AssemblyName>
+    <RootNamespace>ReliableStreaming</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Azure.AI.OpenAI" />
+    <PackageReference Include="Azure.Identity" />
+    <PackageReference Include="Microsoft.DurableTask.Client.AzureManaged" />
+    <PackageReference Include="Microsoft.DurableTask.Worker.AzureManaged" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" />
+    <PackageReference Include="StackExchange.Redis" />
+  </ItemGroup>
+
+  <!-- Local projects that should be switched to package references when using the sample outside of this MAF repo -->
+  <!--
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Agents.AI.DurableTask" />
+    <PackageReference Include="Microsoft.Agents.AI.OpenAI" />
+  </ItemGroup>
+  -->
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.DurableTask\Microsoft.Agents.AI.DurableTask.csproj" />
+    <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
+  </ItemGroup>
+</Project>

dotnet/samples/04-hosting/DurableAgents/ConsoleApps/07_ReliableStreaming/Program.cs

@@ -0,0 +1,367 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample demonstrates how to implement reliable streaming for durable agents using Redis Streams.
+// It reads prompts from stdin and streams agent responses to stdout in real-time.
+
+using System.ComponentModel;
+using Azure;
+using Azure.AI.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Agents.AI.DurableTask;
+using Microsoft.DurableTask.Client.AzureManaged;
+using Microsoft.DurableTask.Worker.AzureManaged;
+using Microsoft.Extensions.AI;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using OpenAI.Chat;
+using ReliableStreaming;
+using StackExchange.Redis;
+
+// Get the Azure OpenAI endpoint and deployment name from environment variables.
+string endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT")
+    ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
+string deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME")
+    ?? throw new InvalidOperationException("AZURE_OPENAI_DEPLOYMENT_NAME is not set.");
+
+// Get Redis connection string from environment variable.
+string redisConnectionString = Environment.GetEnvironmentVariable("REDIS_CONNECTION_STRING")
+    ?? "localhost:6379";
+
+// Get the Redis stream TTL from environment variable (default: 10 minutes).
+int redisStreamTtlMinutes = int.Parse(Environment.GetEnvironmentVariable("REDIS_STREAM_TTL_MINUTES") ?? "10");
+
+// Get DTS connection string from environment variable
+string dtsConnectionString = Environment.GetEnvironmentVariable("DURABLE_TASK_SCHEDULER_CONNECTION_STRING")
+    ?? "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None";
+
+// Use Azure Key Credential if provided, otherwise use Azure CLI Credential.
+string? azureOpenAiKey = Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY");
+// 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.
+AzureOpenAIClient client = !string.IsNullOrEmpty(azureOpenAiKey)
+    ? new AzureOpenAIClient(new Uri(endpoint), new AzureKeyCredential(azureOpenAiKey))
+    : new AzureOpenAIClient(new Uri(endpoint), new DefaultAzureCredential());
+
+// Travel Planner agent instructions - designed to produce longer responses for demonstrating streaming.
+const string TravelPlannerName = "TravelPlanner";
+const string TravelPlannerInstructions =
+    """
+    You are an expert travel planner who creates detailed, personalized travel itineraries.
+    When asked to plan a trip, you should:
+    1. Create a comprehensive day-by-day itinerary
+    2. Include specific recommendations for activities, restaurants, and attractions
+    3. Provide practical tips for each destination
+    4. Consider weather and local events when making recommendations
+    5. Include estimated times and logistics between activities
+    
+    Always use the available tools to get current weather forecasts and local events
+    for the destination to make your recommendations more relevant and timely.
+    
+    Format your response with clear headings for each day and include emoji icons
+    to make the itinerary easy to scan and visually appealing.
+    """;
+
+// Mock travel tools that return hardcoded data for demonstration purposes.
+[Description("Gets the weather forecast for a destination on a specific date. Use this to provide weather-aware recommendations in the itinerary.")]
+static string GetWeatherForecast(string destination, string date)
+{
+    Dictionary<string, (string condition, int highF, int lowF)> weatherByRegion = new(StringComparer.OrdinalIgnoreCase)
+    {
+        ["Tokyo"] = ("Partly cloudy with a chance of light rain", 58, 45),
+        ["Paris"] = ("Overcast with occasional drizzle", 52, 41),
+        ["New York"] = ("Clear and cold", 42, 28),
+        ["London"] = ("Foggy morning, clearing in afternoon", 48, 38),
+        ["Sydney"] = ("Sunny and warm", 82, 68),
+        ["Rome"] = ("Sunny with light breeze", 62, 48),
+        ["Barcelona"] = ("Partly sunny", 59, 47),
+        ["Amsterdam"] = ("Cloudy with light rain", 46, 38),
+        ["Dubai"] = ("Sunny and hot", 85, 72),
+        ["Singapore"] = ("Tropical thunderstorms in afternoon", 88, 77),
+        ["Bangkok"] = ("Hot and humid, afternoon showers", 91, 78),
+        ["Los Angeles"] = ("Sunny and pleasant", 72, 55),
+        ["San Francisco"] = ("Morning fog, afternoon sun", 62, 52),
+        ["Seattle"] = ("Rainy with breaks", 48, 40),
+        ["Miami"] = ("Warm and sunny", 78, 65),
+        ["Honolulu"] = ("Tropical paradise weather", 82, 72),
+    };
+
+    (string condition, int highF, int lowF) forecast = ("Partly cloudy", 65, 50);
+    foreach (KeyValuePair<string, (string, int, int)> entry in weatherByRegion)
+    {
+        if (destination.Contains(entry.Key, StringComparison.OrdinalIgnoreCase))
+        {
+            forecast = entry.Value;
+            break;
+        }
+    }
+
+    return $"""
+        Weather forecast for {destination} on {date}:
+        Conditions: {forecast.condition}
+        High: {forecast.highF}°F ({(forecast.highF - 32) * 5 / 9}°C)
+        Low: {forecast.lowF}°F ({(forecast.lowF - 32) * 5 / 9}°C)
+        
+        Recommendation: {GetWeatherRecommendation(forecast.condition)}
+        """;
+}
+
+[Description("Gets local events and activities happening at a destination around a specific date. Use this to suggest timely activities and experiences.")]
+static string GetLocalEvents(string destination, string date)
+{
+    Dictionary<string, string[]> eventsByCity = new(StringComparer.OrdinalIgnoreCase)
+    {
+        ["Tokyo"] = [
+            "🎭 Kabuki Theater Performance at Kabukiza Theatre - Traditional Japanese drama",
+            "🌸 Winter Illuminations at Yoyogi Park - Spectacular light displays",
+            "🍜 Ramen Festival at Tokyo Station - Sample ramen from across Japan",
+            "🎮 Gaming Expo at Tokyo Big Sight - Latest video games and technology",
+        ],
+        ["Paris"] = [
+            "🎨 Impressionist Exhibition at Musée d'Orsay - Extended evening hours",
+            "🍷 Wine Tasting Tour in Le Marais - Local sommelier guided",
+            "🎵 Jazz Night at Le Caveau de la Huchette - Historic jazz club",
+            "🥐 French Pastry Workshop - Learn from master pâtissiers",
+        ],
+        ["New York"] = [
+            "🎭 Broadway Show: Hamilton - Limited engagement performances",
+            "🏀 Knicks vs Lakers at Madison Square Garden",
+            "🎨 Modern Art Exhibit at MoMA - New installations",
+            "🍕 Pizza Walking Tour of Brooklyn - Artisan pizzerias",
+        ],
+        ["London"] = [
+            "👑 Royal Collection Exhibition at Buckingham Palace",
+            "🎭 West End Musical: The Phantom of the Opera",
+            "🍺 Craft Beer Festival at Brick Lane",
+            "🎪 Winter Wonderland at Hyde Park - Rides and markets",
+        ],
+        ["Sydney"] = [
+            "🏄 Pro Surfing Competition at Bondi Beach",
+            "🎵 Opera at Sydney Opera House - La Bohème",
+            "🦘 Wildlife Night Safari at Taronga Zoo",
+            "🍽️ Harbor Dinner Cruise with fireworks",
+        ],
+        ["Rome"] = [
+            "🏛️ After-Hours Vatican Tour - Skip the crowds",
+            "🍝 Pasta Making Class in Trastevere",
+            "🎵 Classical Concert at Borghese Gallery",
+            "🍷 Wine Tasting in Roman Cellars",
+        ],
+    };
+
+    string[] events = [
+        "🎭 Local theater performance",
+        "🍽️ Food and wine festival",
+        "🎨 Art gallery opening",
+        "🎵 Live music at local venues",
+    ];
+
+    foreach (KeyValuePair<string, string[]> entry in eventsByCity)
+    {
+        if (destination.Contains(entry.Key, StringComparison.OrdinalIgnoreCase))
+        {
+            events = entry.Value;
+            break;
+        }
+    }
+
+    string eventList = string.Join("\n• ", events);
+    return $"""
+        Local events in {destination} around {date}:
+        
+        • {eventList}
+        
+        💡 Tip: Book popular events in advance as they may sell out quickly!
+        """;
+}
+
+static string GetWeatherRecommendation(string condition)
+{
+    return condition switch
+    {
+        string c when c.Contains("rain", StringComparison.OrdinalIgnoreCase) || c.Contains("drizzle", StringComparison.OrdinalIgnoreCase) =>
+            "Bring an umbrella and waterproof jacket. Consider indoor activities for backup.",
+        string c when c.Contains("fog", StringComparison.OrdinalIgnoreCase) =>
+            "Morning visibility may be limited. Plan outdoor sightseeing for afternoon.",
+        string c when c.Contains("cold", StringComparison.OrdinalIgnoreCase) =>
+            "Layer up with warm clothing. Hot drinks and cozy cafés recommended.",
+        string c when c.Contains("hot", StringComparison.OrdinalIgnoreCase) || c.Contains("warm", StringComparison.OrdinalIgnoreCase) =>
+            "Stay hydrated and use sunscreen. Plan strenuous activities for cooler morning hours.",
+        string c when c.Contains("thunder", StringComparison.OrdinalIgnoreCase) || c.Contains("storm", StringComparison.OrdinalIgnoreCase) =>
+            "Keep an eye on weather updates. Have indoor alternatives ready.",
+        _ => "Pleasant conditions expected. Great day for outdoor exploration!"
+    };
+}
+
+// Configure the console app to host the AI agent.
+IHost host = Host.CreateDefaultBuilder(args)
+    .ConfigureLogging(loggingBuilder => loggingBuilder.SetMinimumLevel(LogLevel.Warning))
+    .ConfigureServices(services =>
+    {
+        services.ConfigureDurableAgents(
+            options =>
+            {
+                // Define the Travel Planner agent with tools for weather and events
+                options.AddAIAgentFactory(TravelPlannerName, sp =>
+                {
+                    return client.GetChatClient(deploymentName).AsAIAgent(
+                        instructions: TravelPlannerInstructions,
+                        name: TravelPlannerName,
+                        services: sp,
+                        tools: [
+                            AIFunctionFactory.Create(GetWeatherForecast),
+                            AIFunctionFactory.Create(GetLocalEvents),
+                        ]);
+                });
+            },
+            workerBuilder: builder => builder.UseDurableTaskScheduler(dtsConnectionString),
+            clientBuilder: builder => builder.UseDurableTaskScheduler(dtsConnectionString));
+
+        // Register Redis connection as a singleton
+        services.AddSingleton<IConnectionMultiplexer>(_ =>
+            ConnectionMultiplexer.Connect(redisConnectionString));
+
+        // Register the Redis stream response handler - this captures agent responses
+        // and publishes them to Redis Streams for reliable delivery.
+        services.AddSingleton(sp =>
+            new RedisStreamResponseHandler(
+                sp.GetRequiredService<IConnectionMultiplexer>(),
+                TimeSpan.FromMinutes(redisStreamTtlMinutes)));
+        services.AddSingleton<IAgentResponseHandler>(sp =>
+            sp.GetRequiredService<RedisStreamResponseHandler>());
+    })
+    .Build();
+
+await host.StartAsync();
+
+// Get the agent proxy from services
+IServiceProvider services = host.Services;
+AIAgent? agentProxy = services.GetKeyedService<AIAgent>(TravelPlannerName);
+RedisStreamResponseHandler streamHandler = services.GetRequiredService<RedisStreamResponseHandler>();
+
+if (agentProxy == null)
+{
+    Console.ForegroundColor = ConsoleColor.Red;
+    Console.Error.WriteLine($"Agent '{TravelPlannerName}' not found.");
+    Console.ResetColor();
+    Environment.Exit(1);
+    return;
+}
+
+// Console colors for better UX
+Console.ForegroundColor = ConsoleColor.Cyan;
+Console.WriteLine("=== Reliable Streaming Sample ===");
+Console.ResetColor();
+Console.WriteLine("Enter a travel planning request (or 'exit' to quit):");
+Console.WriteLine();
+
+string? lastCursor = null;
+
+async Task ReadStreamTask(string conversationId, string? cursor, CancellationToken cancellationToken)
+{
+    // Initialize lastCursor to the starting cursor position
+    // This ensures we have a valid cursor even if cancellation happens before any chunks are processed
+    lastCursor = cursor;
+
+    await foreach (StreamChunk chunk in streamHandler.ReadStreamAsync(conversationId, cursor, cancellationToken))
+    {
+        if (chunk.Error != null)
+        {
+            Console.ForegroundColor = ConsoleColor.Red;
+            Console.Error.WriteLine($"\n[Error: {chunk.Error}]");
+            Console.ResetColor();
+            break;
+        }
+
+        if (chunk.IsDone)
+        {
+            Console.WriteLine();
+            Console.WriteLine();
+            break;
+        }
+
+        if (chunk.Text != null)
+        {
+            Console.Write(chunk.Text);
+            Console.Out.Flush();
+        }
+
+        // Always update lastCursor to track the latest entry ID, even if text is null
+        // This ensures we can resume from the correct position after interruption
+        if (!string.IsNullOrEmpty(chunk.EntryId))
+        {
+            lastCursor = chunk.EntryId;
+        }
+    }
+}
+
+// New conversation: prompt from stdin
+Console.ForegroundColor = ConsoleColor.Yellow;
+Console.Write("You: ");
+Console.ResetColor();
+
+string? prompt = Console.ReadLine();
+if (string.IsNullOrWhiteSpace(prompt) || prompt.Equals("exit", StringComparison.OrdinalIgnoreCase))
+{
+    return;
+}
+
+// Create a new agent session
+AgentSession session = await agentProxy.CreateSessionAsync();
+AgentSessionId sessionId = session.GetService<AgentSessionId>();
+string conversationId = sessionId.ToString();
+
+Console.ForegroundColor = ConsoleColor.Green;
+Console.WriteLine($"Conversation ID: {conversationId}");
+Console.WriteLine("Press [Enter] to interrupt the stream.");
+Console.ResetColor();
+
+// Run the agent in the background
+DurableAgentRunOptions options = new() { IsFireAndForget = true };
+await agentProxy.RunAsync(prompt, session, options, CancellationToken.None);
+
+bool streamCompleted = false;
+while (!streamCompleted)
+{
+    // On a key press, cancel the cancellation token to stop the stream
+    using CancellationTokenSource userCancellationSource = new();
+    _ = Task.Run(() =>
+    {
+        _ = Console.ReadLine();
+        userCancellationSource.Cancel();
+    });
+
+    try
+    {
+        // Start reading the stream and wait for it to complete
+        await ReadStreamTask(conversationId, lastCursor, userCancellationSource.Token);
+        streamCompleted = true;
+    }
+    catch (OperationCanceledException)
+    {
+        Console.ForegroundColor = ConsoleColor.Yellow;
+        Console.WriteLine("Stream cancelled. Press [Enter] to reconnect and resume the stream from the last cursor.");
+        // Ensure lastCursor is set - if it's still null, we at least have the starting cursor
+        string cursorValue = lastCursor ?? "(n/a)";
+        Console.WriteLine($"Last cursor: {cursorValue}");
+        Console.ResetColor();
+        // Explicitly flush to ensure the message is written immediately
+        Console.Out.Flush();
+    }
+
+    if (!streamCompleted)
+    {
+        Console.ReadLine();
+        Console.ForegroundColor = ConsoleColor.Green;
+        Console.WriteLine($"Resuming conversation: {conversationId} from cursor: {lastCursor ?? "(beginning)"}");
+        Console.ResetColor();
+    }
+}
+
+Console.ForegroundColor = ConsoleColor.Green;
+Console.WriteLine("Conversation completed.");
+Console.ResetColor();
+
+await host.StopAsync();

dotnet/samples/04-hosting/DurableAgents/ConsoleApps/07_ReliableStreaming/README.md

@@ -0,0 +1,181 @@
+# Reliable Streaming with Redis
+
+This sample demonstrates how to implement reliable streaming for durable agents using Redis Streams as a message broker. It enables clients to disconnect and reconnect to ongoing agent responses without losing messages, inspired by [OpenAI's background mode](https://platform.openai.com/docs/guides/background) for the Responses API.
+
+## Key Concepts Demonstrated
+
+- **Reliable message delivery**: Agent responses are persisted to Redis Streams, allowing clients to resume from any point
+- **Real-time streaming**: Chunks are printed to stdout as they arrive (like `tail -f`)
+- **Cursor-based resumption**: Each chunk includes an entry ID that can be used to resume the stream
+- **Fire-and-forget agent invocation**: The agent runs in the background while the client streams from Redis
+
+## Environment Setup
+
+See the [README.md](../README.md) file in the parent directory for more information on how to configure the environment, including how to install and run common sample dependencies.
+
+### Additional Requirements: Redis
+
+This sample requires a Redis instance. Start a local Redis instance using Docker:
+
+```bash
+docker run -d --name redis -p 6379:6379 redis:latest
+```
+
+To verify Redis is running:
+
+```bash
+docker ps | grep redis
+```
+
+## Running the Sample
+
+With the environment setup, you can run the sample:
+
+```bash
+cd dotnet/samples/04-hosting/DurableAgents/ConsoleApps/07_ReliableStreaming
+dotnet run --framework net10.0
+```
+
+The app will prompt you for a travel planning request:
+
+```text
+=== Reliable Streaming Sample ===
+Enter a travel planning request (or 'exit' to quit):
+
+You: Plan a 7-day trip to Tokyo, Japan for next month. Include daily activities, restaurant recommendations, and tips for getting around.
+```
+
+The agent's response will stream to your console in real-time as chunks arrive from Redis:
+
+```text
+Starting new conversation: @dafx-travelplanner@a1b2c3d4e5f67890abcdef1234567890
+Press [Enter] to interrupt the stream.
+
+TravelPlanner: # 7-Day Tokyo Adventure
+
+## Day 1: Arrival and Exploration
+...
+```
+
+### Demonstrating Stream Interruption and Resumption
+
+This is the key feature of reliable streaming. Follow these steps to see it in action:
+
+1. **Start a stream**: Run the app and enter a travel planning request
+2. **Note the conversation ID**: The conversation ID is displayed at the start of the stream (e.g., `Starting new conversation: @dafx-travelplanner@a1b2c3d4e5f67890abcdef1234567890`)
+3. **Interrupt the stream**: While the agent is still generating text, press **`Enter`** to interrupt. The agent continues running in the background - your messages are being saved to Redis.
+4. **Resume the stream**: Press **`Enter`** again to reconnect and resume the stream from the last cursor position. The app will automatically resume from where it left off.
+
+```text
+Starting new conversation: @dafx-travelplanner@a1b2c3d4e5f67890abcdef1234567890
+Press [Enter] to interrupt the stream.
+
+TravelPlanner: # 7-Day Tokyo Adventure
+
+## Day 1: Arrival and Exploration
+[Streaming content...]
+
+[Press Enter to interrupt]
+Stream cancelled. Press [Enter] to reconnect and resume the stream from the last cursor.
+Last cursor: 1734567890123-0
+
+[Press Enter to resume]
+Resuming conversation: @dafx-travelplanner@a1b2c3d4e5f67890abcdef1234567890 from cursor: 1734567890123-0
+
+[Stream continues from where it left off...]
+```
+
+## Viewing Agent State
+
+You can view the state of the agent in the Durable Task Scheduler dashboard:
+
+1. Open your browser and navigate to `http://localhost:8082`
+2. In the dashboard, you can see:
+   - **Agents**: View the state of the TravelPlanner agent, including conversation history and current state
+   - **Orchestrations**: View any orchestrations that may have been triggered by the agent
+
+The conversation ID displayed in the console output (shown as "Starting new conversation: {conversationId}") corresponds to the agent's conversation thread. You can use this to identify the agent in the dashboard and inspect:
+
+- The agent's conversation state
+- Tool calls made by the agent (weather and events lookups)
+- The streaming response state
+
+Note that while the console app streams responses from Redis, the agent state in DTS shows the underlying durable agent execution, including all tool calls and conversation context.
+
+## Architecture Overview
+
+```text
+┌─────────────┐      stdin (prompt)     ┌─────────────────────┐
+│   Client    │  ─────────────────────► │  Console App        │
+│  (stdin)    │                         │  (Program.cs)       │
+└─────────────┘                         └──────────────┬──────┘
+       ▲                                               │
+       │ stdout (chunks)                    Signal Entity
+       │                                               │
+       │                                               ▼
+       │                                    ┌─────────────────────┐
+       │                                    │   AgentEntity       │
+       │                                    │   (Durable Entity)  │
+       │                                    └──────────┬──────────┘
+       │                                               │
+       │                                    IAgentResponseHandler
+       │                                               │
+       │                                               ▼
+       │                                    ┌─────────────────────┐
+       │                                    │ RedisStreamResponse │
+       │                                    │      Handler        │
+       │                                    └──────────┬──────────┘
+       │                                               │
+       │                                     XADD (write)
+       │                                               │
+       │                                               ▼
+       │                                    ┌─────────────────────┐
+       └─────────── XREAD (poll) ────────── │   Redis Streams     │
+                                            │  (Durable Log)      │
+                                            └─────────────────────┘
+```
+
+### Data Flow
+
+1. **Client sends prompt**: The console app reads the prompt from stdin and generates a new agent thread.
+
+2. **Agent invoked**: The durable agent is signaled to run the travel planner agent. This is fire-and-forget from the console app's perspective.
+
+3. **Responses captured**: As the agent generates responses, the `RedisStreamResponseHandler` (implementing `IAgentResponseHandler`) extracts the text from each `AgentRunResponseUpdate` and publishes it to a Redis Stream keyed by the agent session's conversation ID.
+
+4. **Client polls Redis**: The console app streams events by polling the Redis Stream and printing chunks to stdout as they arrive.
+
+5. **Resumption**: If the client interrupts the stream (e.g., by pressing Enter in the sample), it can resume from the last cursor position by providing the conversation ID and cursor to the call to resume the stream.
+
+## Message Delivery Guarantees
+
+This sample provides **at-least-once delivery** with the following characteristics:
+
+- **Durability**: Messages are persisted to Redis Streams with configurable TTL (default: 10 minutes).
+- **Ordering**: Messages are delivered in order within a session.
+- **Real-time**: Chunks are printed as soon as they arrive from Redis.
+
+### Important Considerations
+
+- **No exactly-once delivery**: If a client disconnects exactly when receiving a message, it may receive that message again upon resumption. Clients should handle duplicate messages idempotently.
+- **TTL expiration**: Streams expire after the configured TTL. Clients cannot resume streams that have expired.
+- **Redis guarantees**: Redis streams are backed by Redis persistence mechanisms (RDB/AOF). Ensure your Redis instance is configured for durability as needed.
+
+## Configuration
+
+| Environment Variable | Description | Default |
+|---------------------|-------------|---------|
+| `REDIS_CONNECTION_STRING` | Redis connection string | `localhost:6379` |
+| `REDIS_STREAM_TTL_MINUTES` | How long streams are retained after last write | `10` |
+| `AZURE_OPENAI_ENDPOINT` | Azure OpenAI endpoint URL | (required) |
+| `AZURE_OPENAI_DEPLOYMENT_NAME` | Azure OpenAI deployment name | (required) |
+| `AZURE_OPENAI_API_KEY` | API key (optional, uses Azure CLI auth if not set) | (optional) |
+
+## Cleanup
+
+To stop and remove the Redis Docker containers:
+
+```bash
+docker stop redis
+docker rm redis
+```

dotnet/samples/04-hosting/DurableAgents/ConsoleApps/07_ReliableStreaming/RedisStreamResponseHandler.cs

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