I want to implement a custom ChatHistoryProvider. How can I get the ConversationId through the Session property of the context, when the current ConversationId value is null?

[ZeeLyn (ZeeLyn)]

I want to implement a custom ChatHistoryProvider. How can I get the ConversationId through the Session property of the context, when the current ConversationId value is null?

[Yiğit ERDOĞAN (Yigtwxx)]

A null ConversationId there is expected rather than something to route around. From the ChatHistoryProvider docs:

A ChatHistoryProvider is only relevant for scenarios where the underlying AI service that the agent is using does not use in-service chat history storage.

If no service is holding the conversation, nothing has assigned it an id — so there's none for the framework to hand you. Your provider is the thing that owns conversation identity; it isn't a consumer of it.

The built-in providers all solve this the same way: take the identity as a constructor delegate and let the session persist it. CosmosChatHistoryProvider:

public CosmosChatHistoryProvider(
    CosmosClient cosmosClient,
    string databaseId,
    string containerId,
    Func<AgentSession?, State> stateInitializer,   // conversationId / tenantId / userId come from here
    ...)
{
    this._sessionState = new ProviderSessionState<State>(
        Throw.IfNull(stateInitializer),
        stateKey ?? this.GetType().Name);

and then on each call:

var state = this._sessionState.GetOrInitializeState(context.Session);
var partitionKey = BuildPartitionKey(state);

ProviderSessionState<TState> is public, so you can compose it into your own provider. It runs your initializer once and round-trips the result through AgentSession.StateBag:

public TState GetOrInitializeState(AgentSession? session)
{
    if (session?.StateBag.TryGetValue<TState>(this.StateKey, out var state, this._jsonSerializerOptions) is true && state is not null)
    {
        return state;
    }

    state = this._stateInitializer(session);
    if (session is not null)
    {
        session.StateBag.SetValue(this.StateKey, state, this._jsonSerializerOptions);
    }

    return state;
}

Applied to a custom provider:

public sealed class MyChatHistoryProvider : ChatHistoryProvider
{
    public sealed class State
    {
        public string ConversationId { get; set; } = string.Empty;
    }

    private readonly ProviderSessionState<State> _sessionState;

    public MyChatHistoryProvider(Func<AgentSession?, State> stateInitializer, string? stateKey = null)
        => this._sessionState = new ProviderSessionState<State>(
            stateInitializer,
            stateKey ?? nameof(MyChatHistoryProvider));

    public override IReadOnlyList<string> StateKeys => [this._sessionState.StateKey];

    protected override ValueTask<IEnumerable<ChatMessage>> ProvideChatHistoryAsync(
        InvokingContext context, CancellationToken cancellationToken = default)
    {
        State state = this._sessionState.GetOrInitializeState(context.Session);
        // state.ConversationId is stable for the life of the session
        ...
    }

    protected override ValueTask StoreChatHistoryAsync(
        InvokedContext context, CancellationToken cancellationToken = default)
    {
        State state = this._sessionState.GetOrInitializeState(context.Session);
        ...
    }
}

wired with whatever id your application already owns:

new MyChatHistoryProvider(_ => new MyChatHistoryProvider.State
{
    ConversationId = myConversationId
});

If you want the id generated on first use instead of supplied, put that in the initializer — _ => new State { ConversationId = Guid.NewGuid().ToString("N") }. It's called once per session and the value is persisted from then on.

Two details that will bite otherwise:

• Override StateKeys to report the key you used, as above. It's what makes the state survive session serialization/deserialization — miss it and you get a fresh id every time the session round-trips.
• Don't cache the id in an instance field. Per the same docs: "Since a ChatHistoryProvider is used with many different sessions, it should not store any session-specific information within its own instance fields. Instead, any session-specific state should be stored in the associated AgentSession.StateBag." One provider instance serves every session, so an instance field will leak one conversation's history into another.

Note that the overrides to implement are ProvideChatHistoryAsync / StoreChatHistoryAsync, not InvokingCoreAsync / InvokedCoreAsync — the latter pair is what applies the request/response message filters before delegating to the former. InMemoryChatHistoryProvider is the smallest complete example of the shape.