private void RestoreStates(ConversationState prevStates)
{
    var innerStates = prevStates;
    var state = _services.GetRequiredService<IConversationStateService>();

    if (_sideCarOptions?.IsInheritStates == true)
    {
        var curStates = state.GetCurrentState();
        foreach (var pair in curStates)
        {
            var endNode = pair.Value.Values.LastOrDefault();
            if (endNode == null) continue;

            if (_sideCarOptions?.InheritStateKeys?.Any() == true
                && !_sideCarOptions.InheritStateKeys.Contains(pair.Key))
            {
                continue;
            }

            if (innerStates.ContainsKey(pair.Key))
            {
                innerStates[pair.Key].Values.Add(endNode);
            }
            else
            {
                innerStates[pair.Key] = new StateKeyValue
                {
                    Key = pair.Key,
                    Versioning = pair.Value.Versioning,
                    Readonly = pair.Value.Readonly,
                    Values = [endNode]
                };
            }
        }
    }

    state.SetCurrentState(innerStates);
}

private SideCarOptions? _sideCarOptions;

private bool _enabled = false;
private string _conversationId = string.Empty;

public string Provider => "botsharp";

public BotSharpConversationSideCar(
    IServiceProvider services,
    ILogger<BotSharpConversationSideCar> logger)
{
    _services = services;
    _logger = logger;
}

public bool IsEnabled()
{
    return _enabled;
}

public void AppendConversationDialogs(string conversationId, List<DialogElement> messages)
{
    if (!IsValid(conversationId))
    {
        return;
    }

    var top = _contextStack.Peek();
    top.Dialogs.AddRange(messages);
}

public List<DialogElement> GetConversationDialogs(string conversationId)
{
    if (!IsValid(conversationId))
    {
        return new List<DialogElement>();
    }

    return _contextStack.Peek().Dialogs;
}

public void UpdateConversationBreakpoint(string conversationId, ConversationBreakpoint breakpoint)
{
    if (!IsValid(conversationId))
    {
        return;
    }

    var top = _contextStack.Peek().Breakpoints;
    top.Add(breakpoint);
}

public ConversationBreakpoint? GetConversationBreakpoint(string conversationId)
{
    if (!IsValid(conversationId))
    {
        return null;
    }

    var top = _contextStack.Peek().Breakpoints;
    return top.LastOrDefault();
}

public void UpdateConversationStates(string conversationId, List<StateKeyValue> states)
{
    if (!IsValid(conversationId))
    {
        return;
    }

    var top = _contextStack.Peek();
    top.State = new ConversationState(states);
}

public async Task<RoleDialogModel> SendMessage(string agentId, string text,
    PostbackMessageModel? postback = null,
    List<MessageState>? states = null,
    List<DialogElement>? dialogs = null,
    SideCarOptions? options = null)
{
    _sideCarOptions = options;

foreach (var pair in curStates)
{
    var endNode = pair.Value.Values.LastOrDefault();
    if (endNode == null) continue;

    if (_sideCarOptions?.InheritStateKeys?.Any() == true
        && !_sideCarOptions.InheritStateKeys.Contains(pair.Key))
    {
        continue;
    }

    if (innerStates.ContainsKey(pair.Key))
    {
        innerStates[pair.Key].Values.Add(endNode);
    }
    else
    {
        innerStates[pair.Key] = new StateKeyValue
        {
            Key = pair.Key,
            Versioning = pair.Value.Versioning,
            Readonly = pair.Value.Readonly,
            Values = [endNode]
        };
    }
}