Voice AI for Blog sites with Azure OpenAI Service

   [Function("TopicCondensor")]
   public async Task<IActionResult> Run([HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req)
   {
       string requestBodyStream = await new StreamReader(req.Body).ReadToEndAsync();

       if (string.IsNullOrEmpty(requestBodyStream))
       {
           return new BadRequestObjectResult("Request body cannot be empty");
       }
       var aiData = JsonConvert.DeserializeObject<AIData>(requestBodyStream);

       string gptApiKey = await GetGPTApiKey();
       using var httpClient = new HttpClient();
       httpClient.DefaultRequestHeaders.Add("api-key", gptApiKey);

       var requestUri = $"[GPT4.1mini_Endpoint_In_AzureAI_Foundry]";

       var requestBody = new
       {
           //instruct the model with deliberate and careful prompting designed with the contents of the Azure blog in mind
           messages = new[]
           {
               new { role = "system", content = "You are a helpful assistant taht helps users with Azure cloud computing and related topics." },
               new { role = "user", content = $"Look and read this technical webpage/article and its contents: {aiData?.webUrl}, then I want you to craft your answer as strictly 3 seperate and SHORT questions (about 10 words max each) that a learner could theoretically ask based on your understanding of the web page" +
               ".Then shorten them for brevity as if they were flashcard questions. BE CREATIVE ABOUT THE QUESTIONS, Do not just rehash the main talking points, but ask further on a level or 2 beyond the webpage contents. DO NOT begin the questions with the words How or What. Assume that the learner is generally an intermediate to early expert in terms of their understanding of the topic already and has an Enterprise Azure mindset and is likely a Web Developer, System Architect, Product Manager or Tester. Structure the questions you pick in your reply here as Question1|Question2|Question3" }
           },
           temperature = 0.97, // boost creativity by getting closer to 1
           max_tokens = 290 // helps with shortening AI Response
       };

       var json = System.Text.Json.JsonSerializer.Serialize(requestBody);
       var content = new StringContent(json, Encoding.UTF8, "application/json");

       var response = await httpClient.PostAsync(requestUri, content);
       string responseString = await response.Content.ReadAsStringAsync();

       Console.WriteLine(responseString);

       var result = JsonConvert.DeserializeObject<OpenAiResponse>(responseString);

       return new OkObjectResult(result.choices[0].message.content);
   }

//Assuming we have enabled Managed Identity for the requesting Azure Function,
//plus GET persmissions for secrets through Access Policy
private async Task<string> GetGPTApiKey()
{
    var keyVaultUrl = "[Your_keyvault_URI]";

    //exponential backoff retry strategy
    SecretClientOptions retryoptions = new SecretClientOptions()
    {
        Retry =
            {
                Delay= TimeSpan.FromSeconds(2),
                MaxDelay = TimeSpan.FromSeconds(15),
                MaxRetries = 8,
                Mode = RetryMode.Exponential
             }
    };

    var client = new SecretClient(new Uri(keyVaultUrl), new DefaultAzureCredential(), retryoptions);
    KeyVaultSecret secret = await client.GetSecretAsync("[AIFoundryGPTEndpointKey]");
    return secret.Value;
}

//generated classes, probably needs consolidation :D

public class AIData
{
  public string webUrl { get; set; }
}

public class OpenAiResponse
{
  public List<Choice> choices { get; set; }
}

public class Choice
{
  public Message message { get; set; }
}

public class Message
{
  public string content { get; set; }
}

public class TextInput
{
  public string text { get; set; }
}

[Function("GetSpeech")]
public async Task<IActionResult> GetSpeech([HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req)
{
    // Read input text from request body
    string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
    if (string.IsNullOrWhiteSpace(requestBody))
    {
        return new BadRequestObjectResult("Request body cannot be empty");
    }
    var input = JsonConvert.DeserializeObject<TextInput>(requestBody);
    if (input == null || string.IsNullOrWhiteSpace(input.text))
    {
        return new BadRequestObjectResult("Input text is required.");
    }

    // Step 1: Send text to GPT-4.1 for consolidation
    string gptApiKey = await GetGPTApiKey();

    string gptUri = "[GPT4.1mini_Endpoint_In_AzureAI_Foundry]";
    var gptRequestBody = new
    {
        messages = new[]
        {
            new { role = "system", content = "You are a helpful assistant to answer questions you receive. Be creative in your answer and offer a note in the answer that might not be well known about that topic" },
            new { role = "user", content = input.text }
        },
        temperature = 0.98, // boost creativity
        max_tokens = 300
    };
    var gptJson = System.Text.Json.JsonSerializer.Serialize(gptRequestBody);
    using var httpClient = new HttpClient();
    httpClient.DefaultRequestHeaders.Add("api-key", gptApiKey);
    var gptContent = new StringContent(gptJson, Encoding.UTF8, "application/json");
    var gptResponse = await httpClient.PostAsync(gptUri, gptContent);
    if (!gptResponse.IsSuccessStatusCode)
    {
        return new StatusCodeResult((int)gptResponse.StatusCode);
    }
    string gptResponseString = await gptResponse.Content.ReadAsStringAsync();
    var gptResult = JsonConvert.DeserializeObject<OpenAiResponse>(gptResponseString);
    string consolidatedText = gptResult?.choices?[0]?.message?.content;
    if (string.IsNullOrWhiteSpace(consolidatedText))
    {
        return new BadRequestObjectResult("Failed to get consolidated text from GPT-4.1.");
    }

    // Step 2: Send consolidated text to gpt4o-mini-tts for audio output and stream it
    string ttsApiKey = gptApiKey; // Use same key if applicable, otherwise replace
    string ttsUri = "GPT4ominitts_Endpoint_In_AzureAI_Foundry]";
    var ttsRequestBody = new
    {
        input = consolidatedText,
        voice = "alloy", // or another supported voice, alloy is universally approachable
        model = "gpt-4o-mini-tts"
    };
    var ttsJson = System.Text.Json.JsonSerializer.Serialize(ttsRequestBody);
    using var ttsClient = new HttpClient();
    ttsClient.DefaultRequestHeaders.Add("api-key", ttsApiKey);
    var ttsContent = new StringContent(ttsJson, Encoding.UTF8, "application/json");

    // Chunked response to start reading data as soon as available
    var ttsResponse = await ttsClient.SendAsync(new HttpRequestMessage(HttpMethod.Post, ttsUri) { Content = ttsContent }, HttpCompletionOption.ResponseHeadersRead);
    if (!ttsResponse.IsSuccessStatusCode)
    {
        return new StatusCodeResult((int)ttsResponse.StatusCode);
    }
    var audioStream = await ttsResponse.Content.ReadAsStreamAsync();

    // Return a FileStreamResult to stream the audio back to the client
    return new FileStreamResult(audioStream, "audio/mpeg")
    {
        FileDownloadName = "speech.mp3"
    };
}