.NET ChatHistoryProvider vs Session

[ahmar-husain]

Hi, I have some confusion regarding ChatHistoryProvider and AgentSession, specifically in the context of resuming an ongoing conversation.

From what I understand:

• If I don’t use sessions and only use a persistent ChatHistoryProvider, the agent should still be able to resume the conversation because the full chat history can be retrieved from the provider.

• On the other hand, if I don’t use a persistent chat history provider (instead an InMemory one) ,serialize and store the AgentSession, then later deserialize it and resume the same session, the agent will also have the full conversation context.

So both approaches seem to allow resuming a conversation.However, I’m trying to understand which approach is recommended or intended.

One concern I noticed is that persisting sessions alone can cause the session object to grow significantly, since it contains the entire chat history, and currently there doesn’t seem to be a built-in way to reduce or trim the history within the session. With a ChatHistoryProvider, however, we can apply a history reducer, which helps control the size of the stored history.

Right now I’m using a hybrid approach:

• persist the session
• also persist the chat history after reduction

What I noticed is that when the history reducer runs, it reduces the stored history, and when the session is serialized again afterward, the session history also appears reduced. So there seems to be some connection between the session state and the chat history provider.

I’m trying to better understand:

What is the recommended pattern for long-running conversations? Should we rely primarily on sessions, chat history providers, or a combination of both? Any guidance would be appreciated.

    using Microsoft.Agents.AI;
    using Microsoft.Extensions.AI;
    using Pipelines.Sockets.Unofficial.Arenas;
    using stateless.Models;
    using stateless.Services;
    using System.ComponentModel;
    using System.Text.Json;
    
    namespace stateless.Agents
    {
        public record AgentResponse(string Text, bool RequiresApproval, List<FunctionApproval>? ApprovalRequests);
        public class ShipmentAgent(IChatClient chatClient, ISessionStorage sessionStorage)
        {
    
            public AIAgent Create(string userid)
            {
                return chatClient.AsAIAgent(new ChatClientAgentOptions
                {
                    ChatOptions = new ChatOptions()
                    {
                        Instructions = @"You are a container shipment agent,
                    },
                    Description = "A Shipment agent",
                    //Csutom history provider to save history in redis per user
                    ChatHistoryProvider = new RedisChatHistoryProvider(stateKey: $"history:{userid}", summarizingChatReducer: new SummarizingChatReducer(chatClient, 11, 21)),
                });
            }
    
            public async Task<AgentResponse> StartAsync(string userId, string message, List<FunctionApproval>? approvals = null)
            {
                var agent = Create(userId);
                AgentSession session = await GetSession(userId, agent);
                var response = await agent.RunAsync(message, session);
                var serializedUpdatedSession = await agent.SerializeSessionAsync(session);
                await sessionStorage.SaveSessionAsync(userId, serializedUpdatedSession.ToString());
                return new AgentResponse(response.Text, false, Enumerable.Empty<FunctionApproval>().ToList());
    
            }
            private async Task<AgentSession> GetSession(string userId, AIAgent agent)
            {
                var serializedSession = await sessionStorage.GetSessionAsync(userId);
                AgentSession session;
                if (!string.IsNullOrEmpty(serializedSession))
                {
                    var sessionJsonElement = JsonSerializer.Deserialize<JsonElement>(serializedSession);
                    session = await agent.DeserializeSessionAsync(sessionJsonElement);
                }
                else
                {
                    session = await agent.CreateSessionAsync();
                }
                return session;
            }
        }
    }

Custom history Provider

using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;

using StackExchange.Redis;

using ChatMessage = Microsoft.Extensions.AI.ChatMessage;



public sealed class RedisChatHistoryProvider : ChatHistoryProvider
{
    private readonly ProviderSessionState<State> _sessionState;
    private readonly ConnectionMultiplexer _redis;
    private readonly IDatabase _db;
    SummarizingChatReducer _summarizingChatReducer;

    public RedisChatHistoryProvider(
        Func<AgentSession?, State>? stateInitializer = null,
        string? stateKey = null, SummarizingChatReducer summarizingChatReducer = null)
    {
        this._sessionState = new ProviderSessionState<State>(stateInitializer ?? (_ => new State()), stateKey ?? this.GetType().Name);
        _redis = ConnectionMultiplexer.Connect("localhost:6379");
        _db = _redis.GetDatabase();
        _summarizingChatReducer = summarizingChatReducer;
    }

    public override string StateKey => this._sessionState.StateKey;

    protected override ValueTask<IEnumerable<ChatMessage>> ProvideChatHistoryAsync(InvokingContext context, CancellationToken cancellationToken = default)
    {
        string messages = _db.StringGet(this.StateKey);
        if (messages == null)
            return new(new List<ChatMessage>());
        return new((System.Text.Json.JsonSerializer.Deserialize<IEnumerable<ChatMessage>>(messages)).OrderBy(x => x.CreatedAt));
    }

    protected override async ValueTask StoreChatHistoryAsync(InvokedContext context, CancellationToken cancellationToken = default)
    {
        string messages = _db.StringGet(this.StateKey);
        List<ChatMessage> storedMessage = messages is null ? new List<ChatMessage>() : (System.Text.Json.JsonSerializer.Deserialize<IEnumerable<ChatMessage>>(messages)).OrderBy(x => x.CreatedAt).ToList();

        IEnumerable<ChatMessage> reducedmessage = new List<ChatMessage>();
        
        // Filter out messages containing FunctionApprovalRequestContent - they can't be serialized
        var allNewMessages = context.RequestMessages
             .Concat(context.ResponseMessages ?? [])
             .Where(m => !m.Contents.OfType<FunctionApprovalRequestContent>().Any() && !m.Contents.OfType<FunctionApprovalResponseContent>().Any())
             .ToList();
        
        // If no messages to save (all were approval requests), return early
        if (!allNewMessages.Any())
            return;
        
        var state = this._sessionState.GetOrInitializeState(context.Session);

        state.Messages.AddRange(allNewMessages);

        if (_summarizingChatReducer is not null)
        {
            reducedmessage = await _summarizingChatReducer.ReduceAsync(state.Messages, cancellationToken);
            if (reducedmessage.Any() && reducedmessage.Count() < state.Messages.Count)
            {

                state.Messages.Clear();
                await _db.StringSetAsync(this.StateKey, System.Text.Json.JsonSerializer.Serialize(reducedmessage));
                //adding previous summary back to the message list to provide more context for the next summarization
                state.Messages.Add(reducedmessage.FirstOrDefault(x => x.Role == ChatRole.Assistant));
            }
            else
            {
                storedMessage.AddRange(allNewMessages);
                await _db.StringSetAsync(this.StateKey, System.Text.Json.JsonSerializer.Serialize(storedMessage));
            }
        }
        else
        {
            storedMessage.AddRange(allNewMessages);
            await _db.StringSetAsync(this.StateKey, System.Text.Json.JsonSerializer.Serialize(storedMessage));
        }

    }

    // Public method to clear chat history
    public async Task ClearHistoryAsync()
    {
        await _db.KeyDeleteAsync(this.StateKey);
    }

    public sealed class State
    {
        [JsonPropertyName("messages")]
        public List<ChatMessage> Messages { get; set; } = [];
    }
}