Why does Azure OpenAI Completion Request Fail with the gpt-4o Model?

I built a RAG web service that worked about 6 months ago, but now it fails completely.
I discovered that the SDK has changed; deprecated models were replaced with new ones. However, the new API calls are not working correctly.

Below is the code that uses the new API. When I use the new model: gpt-4o, the call to CompleteChatAsync never returns unless a CancellationToken is provided—in which case it times out after 30 sec. I get exceptions such as "The task canceled" or "Resource not found". The same code works fine with the model gpt-35-turbo-16k.

The Resource Group and the Resource are in 'eastus'.
The gpt-4o model with Deployment Name/Model ID 'gpt-4o-2024-08-06' was deployed successfully a while ago.

Note: The model deployment name mentioned is gpt-40-24-08-06 and the target URI endpoint is:
https://azureopenaiexperiment.openai.azure.com/openai/deployments/gpt-4o-2024-08-06/chat/completions?api-version=2024-08-01-preview

My question is: Why is it not working? What am I missing?

Additional Environment Details:
Windows 11, Visual Studio 2022.
.NET 9
Microsoft.NETCore.APP 9.0.0
Microsoft.Windows.SDK.NET.Ref.Windows 10.0.26100.54

Code:

CSHARPCopied
public async Task<string?> GenerateResponseAsync(CompletionModel model, string prompt,  
                                                 List<string> contextList, CancellationToken cancellationToken)
{
    _logger.LogInformation("GenerateResponseAsync entered");

    ArgumentNullException.ThrowIfNull(model, nameof(model));
    ArgumentNullException.ThrowIfNullOrWhiteSpace(prompt, nameof(prompt));

    string respMessage = "";

    try
    {
        Uri azureOpenAIResourceUri = new Uri(_azureSettings.AzureOpenAiEndpoint);
        AzureKeyCredential azureOpenAiApiKey = new AzureKeyCredential(_azureSettings.AzureOpenAiApiKey);

        AzureOpenAIClient azureClient = new(azureOpenAIResourceUri, azureOpenAiApiKey);               
        ChatClient chatClient = azureClient.GetChatClient(model.DeploymentName);
        
        if (chatClient == null)
        {
            throw new Exception("Failed to create AzureOpenAIClient");
        }

        List<ChatMessage>? chatMessages = ConstructMessages(model, prompt, contextList);
        if (chatMessages == null)
        {
            throw new Exception("Failed to construct messages");
        }

        _logger.LogInformation("Creating ChatCompletionOptions...");
        ChatCompletionOptions? chatCompletionOptions = new ChatCompletionOptions()
        {
             FrequencyPenalty = 0f,
             PresencePenalty = 0f,
             MaxOutputTokenCount = model.TokenLimit - 1000,
             TopP = 0,
             Temperature = 1.0f,
        };

        using var timeoutTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(30));
        var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutTokenSource.Token);

        _logger.LogInformation("Calling CompleteChatAsync...");
        ChatCompletion chatCompletion = await chatClient.CompleteChatAsync(chatMessages.ToArray(), chatCompletionOptions, linkedTokenSource.Token);
        if (chatCompletion != null)
        {
            ChatMessageContent msgContent = chatCompletion.Content;
            if (msgContent != null)
            {
                respMessage = (msgContent.Count > 0) ? msgContent[0].Text : "";
            }
        }

        _logger.LogInformation($"CONTENT: {respMessage}");
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, ex.Message);
        throw;
    }
    finally
    {
        _logger.LogInformation("GenerateResponse exiting");
    }

    return respMessage;
}

public List<ChatMessage>? ConstructMessages(CompletionModel model, string prompt, List<string> contextList)
{
    _logger.LogInformation("ConstructMessages entered");

    try
    {
        StringBuilder sb = new StringBuilder($"QUESTION: {prompt}");
        sb.AppendLine(Environment.NewLine);
        sb.AppendLine("CONTEXT:");
        sb.AppendLine(Environment.NewLine);

        if (contextList != null)
        {
            for (int i = 0; i < contextList.Count; i++)
            {
                sb.AppendLine("## " + contextList[i].Trim('\n').Trim('\r'));
                sb.AppendLine(Environment.NewLine);
            }
        }

        List<ChatMessage> chatMessages = new List<ChatMessage>()
        {
            // The system message represents instructions or other guidance about how the assistant should behave
            new SystemChatMessage(_azureSettings.AzureOpenAiCompletionSystemInstruction),
            new UserChatMessage(sb.ToString()),
        };

        _logger.LogInformation($"SystemInstruction: {chatMessages[0]}");
        _logger.LogInformation($"User Message: {chatMessages[1]}");

        string totPayloadStr = _azureSettings.AzureOpenAiCompletionSystemInstruction + sb.ToString();
        
        if (IsExceedsModelTokenLimit(totPayloadStr, model) == true)
        {
            throw new Exception("Total prompt + system + context message size exceeds the model limit");
        }

        _logger.LogInformation("Exiting exiting...");
        return chatMessages;
    }
    catch(Exception ex)
    {
        _logger.LogError($"ConstructMessages exception: {ex.Message}");
    }
    return null;
}

Please help me identify what I'm missing.