Schnellstart: Erste Schritte mit Azure OpenAI-Audiogenerierung

Erfahren Sie mehr über schlüssellose Authentifizierung und Festlegen von Umgebungsvariablen.

Erfahren Sie mehr über das Suchen nach API-Schlüsseln und Festlegen von Umgebungsvariablen.

1. Erstellen Sie die to-audio.js Datei mit dem folgenden Code:

   require("dotenv").config();
   const { AzureOpenAI } = require("openai");
   const { DefaultAzureCredential, getBearerTokenProvider } = require("@azure/identity");
   const { writeFileSync } = require("node:fs");
   
   // Keyless authentication    
   const credential = new DefaultAzureCredential();
   const scope = "https://ai.azure.com/.default";
   const azureADTokenProvider = getBearerTokenProvider(credential, scope);
   
   // Set environment variables or edit the corresponding values here.
   const endpoint = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
   const deployment = process.env.AZURE_OPENAI_DEPLOYMENT_NAME || "gpt-4o-mini-audio-preview"; 
   const apiVersion = process.env.OPENAI_API_VERSION || "2025-01-01-preview"; 
   
   const client = new AzureOpenAI({ 
       endpoint, 
       azureADTokenProvider, 
       apiVersion, 
       deployment 
   }); 
   
   async function main() {
   
       // Make the audio chat completions request
       const response = await client.chat.completions.create({ 
           model: "gpt-4o-mini-audio-preview", 
           modalities: ["text", "audio"], 
           audio: { voice: "alloy", format: "wav" }, 
           messages: [ 
           { 
               role: "user", 
               content: "Is a golden retriever a good family dog?" 
           } 
           ] 
       }); 
   
   // Inspect returned data 
   console.log(response.choices[0]); 
   
   // Write the output audio data to a file
   writeFileSync( 
       "dog.wav", 
       Buffer.from(response.choices[0].message.audio.data, 'base64'), 
       { encoding: "utf-8" } 
   ); 
   }
   
   main().catch((err) => {
     console.error("Error occurred:", err);
   });
   
   module.exports = { main };
   

2. Melden Sie sich mit dem folgenden Befehl bei Azure an:

   az login
   

3. Führen Sie die JavaScript-Datei aus.

   node to-audio.js
   

1. Erstellen Sie die to-audio.js Datei mit dem folgenden Code:

   require("dotenv").config();
   const { AzureOpenAI } = require("openai");
   const { writeFileSync } = require("node:fs");
   
   // Set environment variables or edit the corresponding values here.
   const endpoint = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
   const apiKey = process.env.AZURE_OPENAI_API_KEY || "AZURE_OPENAI_API_KEY";
   const apiVersion = "2025-01-01-preview"; 
   const deployment = "gpt-4o-mini-audio-preview"; 
   
   const client = new AzureOpenAI({ 
       endpoint, 
       apiKey, 
       apiVersion, 
       deployment 
   });  
   
   async function main() {
   
       // Make the audio chat completions request
       const response = await client.chat.completions.create({ 
           model: "gpt-4o-mini-audio-preview", 
           modalities: ["text", "audio"], 
           audio: { voice: "alloy", format: "wav" }, 
           messages: [ 
           { 
               role: "user", 
               content: "Is a golden retriever a good family dog?" 
           } 
           ] 
       }); 
   
   // Inspect returned data 
   console.log(response.choices[0]); 
   
   // Write the output audio data to a file
   writeFileSync( 
       "dog.wav", 
       Buffer.from(response.choices[0].message.audio.data, 'base64'), 
       { encoding: "utf-8" } 
   ); 
   }
   
   main().catch((err) => {
     console.error("Error occurred:", err);
   });
   
   module.exports = { main };
   

2. Führen Sie die JavaScript-Datei aus.

   node to-audio.js
   

1. Erstellen Sie die from-audio.js Datei mit dem folgenden Code:

   require("dotenv").config();
   const { AzureOpenAI } = require("openai");
   const { DefaultAzureCredential, getBearerTokenProvider } = require("@azure/identity");
   const fs = require('fs').promises;
   const { writeFileSync } = require("node:fs");
   
   // Keyless authentication    
   const credential = new DefaultAzureCredential();
   const scope = "https://ai.azure.com/.default";
   const azureADTokenProvider = getBearerTokenProvider(credential, scope);
   
   // Set environment variables or edit the corresponding values here.
   const endpoint = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
   const apiVersion = "2025-01-01-preview"; 
   const deployment = "gpt-4o-mini-audio-preview"; 
   
   const client = new AzureOpenAI({ 
       endpoint, 
       azureADTokenProvider, 
       apiVersion, 
       deployment 
   });    
   
   async function main() {
   
       // Buffer the audio for input to the chat completion
       const wavBuffer = await fs.readFile("dog.wav"); 
       const base64str = Buffer.from(wavBuffer).toString("base64"); 
   
       // Make the audio chat completions request
       const response = await client.chat.completions.create({
           model: "gpt-4o-mini-audio-preview",
           modalities: ["text", "audio"],
           audio: { voice: "alloy", format: "wav" }, 
           messages: [
               {
                   role: "user",
                   content: [
                       { 
                           type: "text", 
                           text: "Describe in detail the spoken audio input." 
                       },
                       { 
                           type: "input_audio", 
                           input_audio: { 
                               data: base64str, 
                               format: "wav" 
                           } 
                       }
                   ]
               }
           ]
       });
   
       console.log(response.choices[0]); 
   
       // Write the output audio data to a file
       writeFileSync( 
           "analysis.wav", 
           Buffer.from(response.choices[0].message.audio.data, 'base64'), 
           { encoding: "utf-8" } 
       ); 
   }
   
   main().catch((err) => {
       console.error("Error occurred:", err);
   });
   
   module.exports = { main };
   

2. Melden Sie sich mit dem folgenden Befehl bei Azure an:

   az login
   

3. Führen Sie die JavaScript-Datei aus.

   node from-audio.js
   

1. Erstellen Sie die from-audio.js Datei mit dem folgenden Code:

   require("dotenv").config();
   const { AzureOpenAI } = require("openai");
   const fs = require('fs').promises;
   const { writeFileSync } = require("node:fs");
   
   // Set environment variables or edit the corresponding values here.
   const endpoint = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
   const apiKey = process.env.AZURE_OPENAI_API_KEY || "AZURE_OPENAI_API_KEY";
   const apiVersion = "2025-01-01-preview"; 
   const deployment = "gpt-4o-mini-audio-preview"; 
   
   const client = new AzureOpenAI({ 
       endpoint, 
       apiKey, 
       apiVersion, 
       deployment 
   });  
   
   async function main() {
   
       // Buffer the audio for input to the chat completion
       const wavBuffer = await fs.readFile("dog.wav"); 
       const base64str = Buffer.from(wavBuffer).toString("base64"); 
   
       // Make the audio chat completions request
       const response = await client.chat.completions.create({
           model: "gpt-4o-mini-audio-preview",
           modalities: ["text", "audio"],
           audio: { voice: "alloy", format: "wav" }, 
           messages: [
               {
                   role: "user",
                   content: [
                       { 
                           type: "text", 
                           text: "Describe in detail the spoken audio input." 
                       },
                       { 
                           type: "input_audio", 
                           input_audio: { 
                               data: base64str, 
                               format: "wav" 
                           } 
                       }
                   ]
               }
           ]
       });
   
       console.log(response.choices[0]); 
   
       // Write the output audio data to a file
       writeFileSync( 
           "analysis.wav", 
           Buffer.from(response.choices[0].message.audio.data, 'base64'), 
           { encoding: "utf-8" } 
       ); 
   }
   
   main().catch((err) => {
       console.error("Error occurred:", err);
   });
   
   module.exports = { main };
   

2. Führen Sie die JavaScript-Datei aus.

   node from-audio.js
   

1. Erstellen Sie die multi-turn.js Datei mit dem folgenden Code:

   require("dotenv").config();
   const { AzureOpenAI } = require("openai");
   const { DefaultAzureCredential, getBearerTokenProvider } = require("@azure/identity");
   const fs = require('fs').promises;
   
   // Keyless authentication    
   const credential = new DefaultAzureCredential();
   const scope = "https://ai.azure.com/.default";
   const azureADTokenProvider = getBearerTokenProvider(credential, scope);
   
   // Set environment variables or edit the corresponding values here.
   const endpoint = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
   const apiVersion = "2025-01-01-preview"; 
   const deployment = "gpt-4o-mini-audio-preview"; 
   
   const client = new AzureOpenAI({ 
       endpoint, 
       azureADTokenProvider, 
       apiVersion, 
       deployment 
   }); 
   
   async function main() {
   
       // Buffer the audio for input to the chat completion
       const wavBuffer = await fs.readFile("dog.wav"); 
       const base64str = Buffer.from(wavBuffer).toString("base64"); 
   
       // Initialize messages with the first turn's user input 
       const messages = [
           {
               role: "user",
               content: [
                   { 
                       type: "text", 
                       text: "Describe in detail the spoken audio input." 
                   },
                   { 
                       type: "input_audio", 
                       input_audio: { 
                           data: base64str, 
                           format: "wav" 
                       } 
                   }
               ]
           }
       ];
   
       // Get the first turn's response 
   
       const response = await client.chat.completions.create({ 
           model: "gpt-4o-mini-audio-preview",
           modalities: ["text", "audio"], 
           audio: { voice: "alloy", format: "wav" }, 
           messages: messages
       }); 
   
       console.log(response.choices[0]); 
   
       // Add a history message referencing the previous turn's audio by ID 
       messages.push({ 
           role: "assistant", 
           audio: { id: response.choices[0].message.audio.id }
       });
   
       // Add a new user message for the second turn
       messages.push({ 
           role: "user", 
           content: [ 
               { 
                   type: "text", 
                   text: "Very concisely summarize the favorability." 
               } 
           ] 
       }); 
   
       // Send the follow-up request with the accumulated messages
       const followResponse = await client.chat.completions.create({ 
           model: "gpt-4o-mini-audio-preview",
           messages: messages
       });
   
       console.log(followResponse.choices[0].message.content); 
   }
   
   main().catch((err) => {
       console.error("Error occurred:", err);
   });
   
   module.exports = { main };
   

2. Melden Sie sich mit dem folgenden Befehl bei Azure an:

   az login
   

3. Führen Sie die JavaScript-Datei aus.

   node multi-turn.js
   

1. Erstellen Sie die multi-turn.js Datei mit dem folgenden Code:

   require("dotenv").config();
   const { AzureOpenAI } = require("openai");
   const fs = require('fs').promises;
   
   // Set environment variables or edit the corresponding values here.
   const endpoint = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
   const apiKey = process.env.AZURE_OPENAI_API_KEY || "AZURE_OPENAI_API_KEY";
   const apiVersion = "2025-01-01-preview"; 
   const deployment = "gpt-4o-mini-audio-preview"; 
   
   const client = new AzureOpenAI({ 
       endpoint, 
       apiKey, 
       apiVersion, 
       deployment 
   });  
   
   async function main() {
   
       // Buffer the audio for input to the chat completion
       const wavBuffer = await fs.readFile("dog.wav"); 
       const base64str = Buffer.from(wavBuffer).toString("base64"); 
   
       // Initialize messages with the first turn's user input 
       const messages = [
           {
               role: "user",
               content: [
                   { 
                       type: "text", 
                       text: "Describe in detail the spoken audio input." 
                   },
                   { 
                       type: "input_audio", 
                       input_audio: { 
                           data: base64str, 
                           format: "wav" 
                       } 
                   }
               ]
           }
       ];
   
       // Get the first turn's response 
   
       const response = await client.chat.completions.create({ 
           model: "gpt-4o-mini-audio-preview",
           modalities: ["text", "audio"], 
           audio: { voice: "alloy", format: "wav" }, 
           messages: messages
       }); 
   
       console.log(response.choices[0]); 
   
       // Add a history message referencing the previous turn's audio by ID 
       messages.push({ 
           role: "assistant", 
           audio: { id: response.choices[0].message.audio.id }
       });
   
       // Add a new user message for the second turn
       messages.push({ 
           role: "user", 
           content: [ 
               { 
                   type: "text", 
                   text: "Very concisely summarize the favorability." 
               } 
           ] 
       }); 
   
       // Send the follow-up request with the accumulated messages
       const followResponse = await client.chat.completions.create({ 
           model: "gpt-4o-mini-audio-preview",
           messages: messages
       });
   
       console.log(followResponse.choices[0].message.content); 
   }
   
   main().catch((err) => {
       console.error("Error occurred:", err);
   });
   
   module.exports = { main };
   

2. Führen Sie die JavaScript-Datei aus.

   node multi-turn.js
   

Erfahren Sie mehr über schlüssellose Authentifizierung und Festlegen von Umgebungsvariablen.

Erfahren Sie mehr über das Suchen nach API-Schlüsseln und Festlegen von Umgebungsvariablen.

1. Erstellen Sie die to-audio.py Datei mit dem folgenden Code:

   import requests
   import base64 
   import os 
   from openai import AzureOpenAI
   from azure.identity import DefaultAzureCredential, get_bearer_token_provider
   
   token_provider=get_bearer_token_provider(DefaultAzureCredential(), "https://ai.azure.com/.default")
   
   # Set environment variables or edit the corresponding values here.
   endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
   
   # Keyless authentication
   client=AzureOpenAI(
       azure_ad_token_provider=token_provider,
       azure_endpoint=endpoint,
       api_version="2025-01-01-preview"
   )
   
   # Make the audio chat completions request
   completion=client.chat.completions.create(
       model="gpt-4o-mini-audio-preview",
       modalities=["text", "audio"],
       audio={"voice": "alloy", "format": "wav"},
       messages=[
           {
               "role": "user",
               "content": "Is a golden retriever a good family dog?"
           }
       ]
   )
   
   print(completion.choices[0])
   
   # Write the output audio data to a file
   wav_bytes=base64.b64decode(completion.choices[0].message.audio.data)
   with open("dog.wav", "wb") as f:
       f.write(wav_bytes)
   

2. Führen Sie die datei Python aus.

   python to-audio.py
   

1. Erstellen Sie die to-audio.py Datei mit dem folgenden Code:

   import base64 
   import os 
   from openai import AzureOpenAI 
   
   # Set environment variables or edit the corresponding values here.
   endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
   api_key = os.environ['AZURE_OPENAI_API_KEY']
   
   client = AzureOpenAI(
       api_version="2025-01-01-preview",  
       api_key=api_key,
       azure_endpoint=endpoint
   )
   
   # Make the audio chat completions request
   completion = client.chat.completions.create(
       model="gpt-4o-mini-audio-preview",
       modalities=["text", "audio"],
       audio={"voice": "alloy", "format": "wav"},
       messages=[
           {
               "role": "user",
               "content": "Is a golden retriever a good family dog?"
           }
       ]
   )
   
   print(completion.choices[0])
   
   # Write the output audio data to a file
   wav_bytes = base64.b64decode(completion.choices[0].message.audio.data)
   with open("dog.wav", "wb") as f:
       f.write(wav_bytes)
   

2. Führen Sie die datei Python aus.

   python to-audio.py
   

1. Erstellen Sie die from-audio.py Datei mit dem folgenden Code:

   import base64
   import os
   from openai import AzureOpenAI
   from azure.identity import DefaultAzureCredential, get_bearer_token_provider
   
   token_provider=get_bearer_token_provider(DefaultAzureCredential(), "https://ai.azure.com/.default")
   
   # Set environment variables or edit the corresponding values here.
   endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
   
   # Keyless authentication
   client=AzureOpenAI(
       azure_ad_token_provider=token_provider,
       azure_endpoint=endpoint,
       api_version="2025-01-01-preview"
   )
   
   # Read and encode audio file  
   with open('dog.wav', 'rb') as wav_reader: 
       encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 
   
   # Make the audio chat completions request
   completion = client.chat.completions.create( 
       model="gpt-4o-mini-audio-preview", 
       modalities=["text", "audio"], 
       audio={"voice": "alloy", "format": "wav"}, 
       messages=[ 
           { 
               "role": "user", 
               "content": [ 
                   {  
                       "type": "text", 
                       "text": "Describe in detail the spoken audio input." 
                   }, 
                   { 
                       "type": "input_audio", 
                       "input_audio": { 
                           "data": encoded_string, 
                           "format": "wav" 
                       } 
                   } 
               ] 
           }, 
       ] 
   ) 
   
   print(completion.choices[0].message.audio.transcript)
   
   # Write the output audio data to a file
   wav_bytes = base64.b64decode(completion.choices[0].message.audio.data)
   with open("analysis.wav", "wb") as f:
       f.write(wav_bytes)
   

2. Führen Sie die datei Python aus.

   python from-audio.py
   

1. Erstellen Sie die from-audio.py Datei mit dem folgenden Code:

   import base64
   import os
   from openai import AzureOpenAI
   
   # Set environment variables or edit the corresponding values here.
   endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
   api_key = os.environ['AZURE_OPENAI_API_KEY']
   
   client = AzureOpenAI(
       api_version="2025-01-01-preview",  
       api_key=api_key, 
       azure_endpoint=endpoint,
   )
   
   # Read and encode audio file  
   with open('dog.wav', 'rb') as wav_reader: 
       encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 
   
   # Make the audio chat completions request
   completion = client.chat.completions.create( 
       model="gpt-4o-mini-audio-preview", 
       modalities=["text", "audio"], 
       audio={"voice": "alloy", "format": "wav"}, 
       messages=[ 
           { 
               "role": "user", 
               "content": [ 
                   {  
                       "type": "text", 
                       "text": "Describe in detail the spoken audio input." 
                   }, 
                   { 
                       "type": "input_audio", 
                       "input_audio": { 
                           "data": encoded_string, 
                           "format": "wav" 
                       } 
                   } 
               ] 
           }, 
       ] 
   ) 
   
   print(completion.choices[0].message.audio.transcript)
   
   # Write the output audio data to a file
   wav_bytes = base64.b64decode(completion.choices[0].message.audio.data)
   with open("analysis.wav", "wb") as f:
       f.write(wav_bytes)
   

2. Führen Sie die datei Python aus.

   python from-audio.py
   

1. Erstellen Sie die multi-turn.py Datei mit dem folgenden Code:

   import base64 
   import os 
   from openai import AzureOpenAI 
   from azure.identity import DefaultAzureCredential, get_bearer_token_provider
   
   token_provider=get_bearer_token_provider(DefaultAzureCredential(), "https://ai.azure.com/.default")
   
   # Set environment variables or edit the corresponding values here.
   endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
   
   # Keyless authentication
   client=AzureOpenAI(
       azure_ad_token_provider=token_provider,
       azure_endpoint=endpoint,
       api_version="2025-01-01-preview"
   )
   
   # Read and encode audio file  
   with open('dog.wav', 'rb') as wav_reader: 
       encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 
   
   # Initialize messages with the first turn's user input 
   messages = [
       { 
           "role": "user", 
           "content": [ 
               { "type": "text", "text": "Describe in detail the spoken audio input." }, 
               { "type": "input_audio", 
                   "input_audio": { 
                       "data": encoded_string, 
                       "format": "wav" 
                   } 
               } 
           ] 
       }] 
   
   # Get the first turn's response
   
   completion = client.chat.completions.create( 
       model="gpt-4o-mini-audio-preview", 
       modalities=["text", "audio"], 
       audio={"voice": "alloy", "format": "wav"}, 
       messages=messages
   ) 
   
   print("Get the first turn's response:")
   print(completion.choices[0].message.audio.transcript) 
   
   print("Add a history message referencing the first turn's audio by ID:")
   print(completion.choices[0].message.audio.id)
   
   # Add a history message referencing the first turn's audio by ID 
   messages.append({ 
       "role": "assistant", 
       "audio": { "id": completion.choices[0].message.audio.id } 
   }) 
   
   # Add the next turn's user message 
   messages.append({ 
       "role": "user", 
       "content": "Very briefly, summarize the favorability." 
   }) 
   
   # Send the follow-up request with the accumulated messages
   completion = client.chat.completions.create( 
       model="gpt-4o-mini-audio-preview", 
       messages=messages
   ) 
   
   print("Very briefly, summarize the favorability.")
   print(completion.choices[0].message.content)
   

2. Führen Sie die datei Python aus.

   python multi-turn.py
   

1. Erstellen Sie die multi-turn.py Datei mit dem folgenden Code:

   import base64 
   import os 
   from openai import AzureOpenAI 
   
   # Set environment variables or edit the corresponding values here.
   endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
   api_key = os.environ['AZURE_OPENAI_API_KEY']
   
   client = AzureOpenAI(
       api_version="2025-01-01-preview",  
       api_key=api_key, 
       azure_endpoint=endpoint
   )
   
   # Read and encode audio file  
   with open('dog.wav', 'rb') as wav_reader: 
       encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 
   
   # Initialize messages with the first turn's user input 
   messages = [
       { 
           "role": "user", 
           "content": [ 
               { "type": "text", "text": "Describe in detail the spoken audio input." }, 
               { "type": "input_audio", 
                   "input_audio": { 
                       "data": encoded_string, 
                       "format": "wav" 
                   } 
               } 
           ] 
       }] 
   
   # Get the first turn's response 
   
   completion = client.chat.completions.create( 
       model="gpt-4o-mini-audio-preview", 
       modalities=["text", "audio"], 
       audio={"voice": "alloy", "format": "wav"}, 
       messages=messages
   ) 
   
   print("Get the first turn's response:")
   print(completion.choices[0].message.audio.transcript) 
   
   print("Add a history message referencing the first turn's audio by ID:")
   print(completion.choices[0].message.audio.id)
   
   # Add a history message referencing the first turn's audio by ID 
   messages.append({ 
       "role": "assistant", 
       "audio": { "id": completion.choices[0].message.audio.id } 
   }) 
   
   # Add the next turn's user message 
   messages.append({ 
       "role": "user", 
       "content": "Very briefly, summarize the favorability." 
   }) 
   
   # Send the follow-up request with the accumulated messages 
   completion = client.chat.completions.create( 
       model="gpt-4o-mini-audio-preview", 
       messages=messages
   ) 
   
   print("Very briefly, summarize the favorability.")
   print(completion.choices[0].message.content)
   

2. Führen Sie die datei Python aus.

   python multi-turn.py
   

Erfahren Sie mehr über schlüssellose Authentifizierung und Festlegen von Umgebungsvariablen.

Erfahren Sie mehr über das Suchen nach API-Schlüsseln und Festlegen von Umgebungsvariablen.

1. Erstellen Sie die to-audio.py Datei mit dem folgenden Code:

   import requests
   import base64 
   import os 
   from openai import AzureOpenAI
   from azure.identity import DefaultAzureCredential
   
   # Set environment variables or edit the corresponding values here.
   endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
   
   # Keyless authentication
   credential = DefaultAzureCredential()
   token = credential.get_token("https://ai.azure.com/.default")
   
   api_version = '2025-01-01-preview'
   url = f"{endpoint}/openai/deployments/gpt-4o-mini-audio-preview/chat/completions?api-version={api_version}"
   headers= { "Authorization": f"Bearer {token.token}", "Content-Type": "application/json" }
   body = {
     "modalities": ["audio", "text"],
     "model": "gpt-4o-mini-audio-preview",
     "audio": {
         "format": "wav",
         "voice": "alloy"
     },
     "messages": [
       {
         "role": "user",
         "content": [
           {
             "type": "text",
             "text": "Is a golden retriever a good family dog?"
           }
         ]
       }
     ]
   }
   
   # Make the audio chat completions request
   completion = requests.post(url, headers=headers, json=body)
   audio_data = completion.json()['choices'][0]['message']['audio']['data']
   
   # Write the output audio data to a file
   wav_bytes = base64.b64decode(audio_data)
   with open("dog.wav", "wb") as f: 
     f.write(wav_bytes) 
   

2. Führen Sie die datei Python aus.

   python to-audio.py
   

1. Erstellen Sie die to-audio.py Datei mit dem folgenden Code:

   import requests
   import base64 
   import os 
   from openai import AzureOpenAI 
   
   # Set environment variables or edit the corresponding values here.
   endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
   api_key = os.environ['AZURE_OPENAI_API_KEY']
   
   api_version = '2025-01-01-preview'
   url = f"{endpoint}/openai/deployments/gpt-4o-mini-audio-preview/chat/completions?api-version={api_version}"
   headers= { "api-key": api_key, "Content-Type": "application/json" }
   body = {
     "modalities": ["audio", "text"],
     "model": "gpt-4o-mini-audio-preview",
     "audio": {
         "format": "wav",
         "voice": "alloy"
     },
     "messages": [
       {
         "role": "user",
         "content": [
           {
             "type": "text",
             "text": "Is a golden retriever a good family dog?"
           }
         ]
       }
     ]
   }
   
   # Make the audio chat completions request
   completion = requests.post(url, headers=headers, json=body)
   audio_data = completion.json()['choices'][0]['message']['audio']['data']
   
   # Write the output audio data to a file 
   wav_bytes = base64.b64decode(audio_data)
   with open("dog.wav", "wb") as f: 
     f.write(wav_bytes) 
   

2. Führen Sie die datei Python aus.

   python to-audio.py
   

1. Erstellen Sie die from-audio.py Datei mit dem folgenden Code:

   import requests
   import base64
   import os
   from azure.identity import DefaultAzureCredential
   
   # Set environment variables or edit the corresponding values here.
   endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
   
   # Keyless authentication
   credential = DefaultAzureCredential()
   token = credential.get_token("https://ai.azure.com/.default")
   
   # Read and encode audio file  
   with open('dog.wav', 'rb') as wav_reader: 
     encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 
   
   api_version = '2025-01-01-preview'
   url = f"{endpoint}/openai/deployments/gpt-4o-mini-audio-preview/chat/completions?api-version={api_version}"
   headers= { "Authorization": f"Bearer {token.token}", "Content-Type": "application/json" }
   body = {
     "modalities": ["audio", "text"],
     "model": "gpt-4o-mini-audio-preview",
     "audio": {
         "format": "wav",
         "voice": "alloy"
     },
     "messages": [
       { 
           "role": "user", 
           "content": [ 
               {  
                   "type": "text", 
                   "text": "Describe in detail the spoken audio input." 
               }, 
               { 
                   "type": "input_audio", 
                   "input_audio": { 
                       "data": encoded_string, 
                       "format": "wav" 
                   } 
               } 
           ] 
       }, 
     ]
   }
   
   completion = requests.post(url, headers=headers, json=body)
   
   print(completion.json()['choices'][0]['message']['audio']['transcript'])
   
   # Write the output audio data to a file
   audio_data = completion.json()['choices'][0]['message']['audio']['data'] 
   wav_bytes = base64.b64decode(audio_data)
   with open("analysis.wav", "wb") as f: 
     f.write(wav_bytes) 
   

2. Führen Sie die datei Python aus.

   python from-audio.py
   

1. Erstellen Sie die from-audio.py Datei mit dem folgenden Code:

   import requests
   import base64
   import os
   
   # Set environment variables or edit the corresponding values here.
   endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
   api_key = os.environ['AZURE_OPENAI_API_KEY']
   
   # Read and encode audio file  
   with open('dog.wav', 'rb') as wav_reader: 
     encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 
   
   api_version = '2025-01-01-preview'
   url = f"{endpoint}/openai/deployments/gpt-4o-mini-audio-preview/chat/completions?api-version={api_version}"
   headers= { "api-key": api_key, "Content-Type": "application/json" }
   body = {
     "modalities": ["audio", "text"],
     "model": "gpt-4o-mini-audio-preview",
     "audio": {
         "format": "wav",
         "voice": "alloy"
     },
     "messages": [
       { 
           "role": "user", 
           "content": [ 
               {  
                   "type": "text", 
                   "text": "Describe in detail the spoken audio input." 
               }, 
               { 
                   "type": "input_audio", 
                   "input_audio": { 
                       "data": encoded_string, 
                       "format": "wav" 
                   } 
               } 
           ] 
       }, 
     ]
   }
   
   completion = requests.post(url, headers=headers, json=body)
   
   print(completion.json()['choices'][0]['message']['audio']['transcript'])
   
   # Write the output audio data to a file
   audio_data = completion.json()['choices'][0]['message']['audio']['data'] 
   wav_bytes = base64.b64decode(audio_data)
   with open("analysis.wav", "wb") as f: 
     f.write(wav_bytes) 
   

2. Führen Sie die datei Python aus.

   python from-audio.py
   

1. Erstellen Sie die multi-turn.py Datei mit dem folgenden Code:

   import requests
   import base64 
   import os 
   from openai import AzureOpenAI 
   from azure.identity import DefaultAzureCredential
   
   # Set environment variables or edit the corresponding values here.
   endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
   
   # Keyless authentication
   credential = DefaultAzureCredential()
   token = credential.get_token("https://ai.azure.com/.default")
   
   api_version = '2025-01-01-preview'
   url = f"{endpoint}/openai/deployments/gpt-4o-mini-audio-preview/chat/completions?api-version={api_version}"
   headers= { "Authorization": f"Bearer {token.token}", "Content-Type": "application/json" }
   
   # Read and encode audio file  
   with open('dog.wav', 'rb') as wav_reader: 
     encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 
   
   # Initialize messages with the first turn's user input 
   messages = [
       { 
           "role": "user", 
           "content": [ 
               {  
                   "type": "text", 
                   "text": "Describe in detail the spoken audio input." 
               }, 
               { 
                   "type": "input_audio", 
                   "input_audio": { 
                       "data": encoded_string, 
                       "format": "wav" 
                   } 
               } 
           ] 
       }] 
   
   body = {
     "modalities": ["audio", "text"],
     "model": "gpt-4o-mini-audio-preview",
     "audio": {
         "format": "wav",
         "voice": "alloy"
     },
     "messages": messages
   }
   
   # Get the first turn's response, including generated audio 
   completion = requests.post(url, headers=headers, json=body)
   
   print("Get the first turn's response:")
   print(completion.json()['choices'][0]['message']['audio']['transcript']) 
   
   print("Add a history message referencing the first turn's audio by ID:")
   print(completion.json()['choices'][0]['message']['audio']['id'])
   
   # Add a history message referencing the first turn's audio by ID 
   messages.append({ 
       "role": "assistant", 
       "audio": { "id": completion.json()['choices'][0]['message']['audio']['id'] } 
   }) 
   
   # Add the next turn's user message 
   messages.append({ 
       "role": "user", 
       "content": "Very briefly, summarize the favorability." 
   }) 
   
   body = {
     "model": "gpt-4o-mini-audio-preview",
     "messages": messages
   }
   
   # Send the follow-up request with the accumulated messages
   completion = requests.post(url, headers=headers, json=body) 
   
   print("Very briefly, summarize the favorability.")
   print(completion.json()['choices'][0]['message']['content'])
   

2. Führen Sie die datei Python aus.

   python multi-turn.py
   

1. Erstellen Sie die multi-turn.py Datei mit dem folgenden Code:

   import requests
   import base64 
   import os 
   from openai import AzureOpenAI 
   
   # Set environment variables or edit the corresponding values here.
   endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
   api_key = os.environ['AZURE_OPENAI_API_KEY']
   
   api_version = '2025-01-01-preview'
   url = f"{endpoint}/openai/deployments/gpt-4o-mini-audio-preview/chat/completions?api-version={api_version}"
   headers= { "api-key": api_key, "Content-Type": "application/json" }
   
   # Read and encode audio file  
   with open('dog.wav', 'rb') as wav_reader: 
     encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 
   
   # Initialize messages with the first turn's user input 
   messages = [
       { 
           "role": "user", 
           "content": [ 
               {  
                   "type": "text", 
                   "text": "Describe in detail the spoken audio input." 
               }, 
               { 
                   "type": "input_audio", 
                   "input_audio": { 
                       "data": encoded_string, 
                       "format": "wav" 
                   } 
               } 
           ] 
       }] 
   
   body = {
     "modalities": ["audio", "text"],
     "model": "gpt-4o-mini-audio-preview",
     "audio": {
         "format": "wav",
         "voice": "alloy"
     },
     "messages": messages
   }
   
   
   # Get the first turn's response, including generated audio 
   completion = requests.post(url, headers=headers, json=body)
   
   print("Get the first turn's response:")
   print(completion.json()['choices'][0]['message']['audio']['transcript']) 
   
   print("Add a history message referencing the first turn's audio by ID:")
   print(completion.json()['choices'][0]['message']['audio']['id'])
   
   # Add a history message referencing the first turn's audio by ID 
   messages.append({ 
       "role": "assistant", 
       "audio": { "id": completion.json()['choices'][0]['message']['audio']['id'] } 
   }) 
   
   # Add the next turn's user message 
   messages.append({ 
       "role": "user", 
       "content": "Very briefly, summarize the favorability." 
   }) 
   
   body = {
     "model": "gpt-4o-mini-audio-preview",
     "messages": messages
   }
   
   # Send the follow-up request with the accumulated messages
   completion = requests.post(url, headers=headers, json=body) 
   
   print("Very briefly, summarize the favorability.")
   print(completion.json()['choices'][0]['message']['content'])
   

2. Führen Sie die datei Python aus.

   python multi-turn.py
   

Erfahren Sie mehr über schlüssellose Authentifizierung und Festlegen von Umgebungsvariablen.

Erfahren Sie mehr über das Suchen nach API-Schlüsseln und Festlegen von Umgebungsvariablen.

1. Erstellen Sie die to-audio.ts Datei mit dem folgenden Code:

   import { writeFileSync } from "node:fs";
   import { AzureOpenAI } from "openai/index.mjs";
   import {
       DefaultAzureCredential,
       getBearerTokenProvider,
     } from "@azure/identity";
   
   // Set environment variables or edit the corresponding values here.
   const endpoint: string = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
   const deployment: string = process.env.AZURE_OPENAI_DEPLOYMENT_NAME || "gpt-4o-mini-audio-preview"; 
   const apiVersion: string = process.env.OPENAI_API_VERSION || "2025-01-01-preview"; 
   
   // Keyless authentication 
   const getClient = (): AzureOpenAI => {
       const credential = new DefaultAzureCredential();
       const scope = "https://ai.azure.com/.default";
       const azureADTokenProvider = getBearerTokenProvider(credential, scope);
       const client = new AzureOpenAI({
         endpoint: endpoint,
         apiVersion: apiVersion,
         azureADTokenProvider,
       });
       return client;
   };
   
   const client = getClient();
   
   async function main(): Promise<void> {
   
       // Make the audio chat completions request
       const response = await client.chat.completions.create({ 
           model: "gpt-4o-mini-audio-preview", 
           modalities: ["text", "audio"], 
           audio: { voice: "alloy", format: "wav" }, 
           messages: [ 
           { 
               role: "user", 
               content: "Is a golden retriever a good family dog?" 
           } 
           ] 
       }); 
   
     // Inspect returned data 
     console.log(response.choices[0]); 
   
     // Write the output audio data to a file
     if (response.choices[0].message.audio) {
       writeFileSync( 
         "dog.wav", 
         Buffer.from(response.choices[0].message.audio.data, 'base64'), 
         { encoding: "utf-8" } 
       ); 
     } else {
       console.error("Audio data is null or undefined.");
     }
   }
   
   main().catch((err: Error) => {
     console.error("Error occurred:", err);
   });
   
   export { main };
   

2. Erstellen Sie die tsconfig.json Datei zum Transpilieren des TypeScript-Codes, und kopieren Sie den folgenden Code für ECMAScript.

   {
       "compilerOptions": {
         "module": "NodeNext",
         "target": "ES2022", // Supports top-level await
         "moduleResolution": "NodeNext",
         "skipLibCheck": true, // Avoid type errors from node_modules
         "strict": true // Enable strict type-checking options
       },
       "include": ["*.ts"]
   }
   

3. Transpilieren von TypeScript zu JavaScript.

   tsc
   

4. Melden Sie sich mit dem folgenden Befehl bei Azure an:

   az login
   

5. Führen Sie den Code mit dem folgenden Befehl aus:

   node to-audio.js
   

1. Erstellen Sie die to-audio.ts Datei mit dem folgenden Code:

   import { writeFileSync } from "node:fs";
   import { AzureOpenAI } from "openai/index.mjs";
   
   // Set environment variables or edit the corresponding values here.
   const endpoint: string = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
   const apiKey: string = process.env.AZURE_OPENAI_API_KEY || "AZURE_OPENAI_API_KEY";
   const apiVersion: string = "2025-01-01-preview"; 
   const deployment: string = "gpt-4o-mini-audio-preview"; 
   
   const client = new AzureOpenAI({ 
     endpoint, 
     apiKey, 
     apiVersion, 
     deployment 
   });  
   
   async function main(): Promise<void> {
   
       // Make the audio chat completions request
       const response = await client.chat.completions.create({ 
           model: "gpt-4o-mini-audio-preview", 
           modalities: ["text", "audio"], 
           audio: { voice: "alloy", format: "wav" }, 
           messages: [ 
           { 
               role: "user", 
               content: "Is a golden retriever a good family dog?" 
           } 
           ] 
       }); 
   
     // Inspect returned data 
     console.log(response.choices[0]); 
   
     // Write the output audio data to a file
     if (response.choices[0].message.audio) {
       writeFileSync( 
         "dog.wav", 
         Buffer.from(response.choices[0].message.audio.data, 'base64'), 
         { encoding: "utf-8" } 
       ); 
     } else {
       console.error("Audio data is null or undefined.");
     }
   }
   
   main().catch((err: Error) => {
     console.error("Error occurred:", err);
   });
   
   export { main };
   

2. Erstellen Sie die tsconfig.json Datei zum Transpilieren des TypeScript-Codes, und kopieren Sie den folgenden Code für ECMAScript.

   {
       "compilerOptions": {
         "module": "NodeNext",
         "target": "ES2022", // Supports top-level await
         "moduleResolution": "NodeNext",
         "skipLibCheck": true, // Avoid type errors from node_modules
         "strict": true // Enable strict type-checking options
       },
       "include": ["*.ts"]
   }
   

3. Transpilieren von TypeScript zu JavaScript.

   tsc
   

4. Führen Sie den Code mit dem folgenden Befehl aus:

   node to-audio.js
   

1. Erstellen Sie die from-audio.ts Datei mit dem folgenden Code:

   import { AzureOpenAI } from "openai";
   import { writeFileSync } from "node:fs";
   import { promises as fs } from 'fs';
   import {
       DefaultAzureCredential,
       getBearerTokenProvider,
     } from "@azure/identity";
   
   // Set environment variables or edit the corresponding values here.
   const endpoint: string = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
   const apiVersion: string = "2025-01-01-preview"; 
   const deployment: string = "gpt-4o-mini-audio-preview"; 
   
   // Keyless authentication 
   const getClient = (): AzureOpenAI => {
       const credential = new DefaultAzureCredential();
       const scope = "https://ai.azure.com/.default";
       const azureADTokenProvider = getBearerTokenProvider(credential, scope);
       const client = new AzureOpenAI({
         endpoint: endpoint,
         apiVersion: apiVersion,
         azureADTokenProvider,
       });
       return client;
   };
   
   const client = getClient();
   
   async function main(): Promise<void> {
   
       // Buffer the audio for input to the chat completion
       const wavBuffer = await fs.readFile("dog.wav"); 
       const base64str = Buffer.from(wavBuffer).toString("base64"); 
   
       // Make the audio chat completions request
       const response = await client.chat.completions.create({ 
         model: "gpt-4o-mini-audio-preview",
         modalities: ["text", "audio"], 
         audio: { voice: "alloy", format: "wav" },
         messages: [ 
           { 
             role: "user", 
             content: [ 
               { 
                 type: "text", 
                 text: "Describe in detail the spoken audio input." 
               }, 
               { 
                 type: "input_audio", 
                 input_audio: { 
                   data: base64str, 
                   format: "wav" 
                 } 
               } 
             ] 
           } 
         ] 
       }); 
   
       console.log(response.choices[0]); 
   
       // Write the output audio data to a file
       if (response.choices[0].message.audio) {
           writeFileSync("analysis.wav", Buffer.from(response.choices[0].message.audio.data, 'base64'), { encoding: "utf-8" });
       }
       else {
           console.error("Audio data is null or undefined.");
     }
   }
   
   main().catch((err: Error) => {
     console.error("Error occurred:", err);
   });
   
   export { main };
   

2. Erstellen Sie die tsconfig.json Datei zum Transpilieren des TypeScript-Codes, und kopieren Sie den folgenden Code für ECMAScript.

   {
       "compilerOptions": {
         "module": "NodeNext",
         "target": "ES2022", // Supports top-level await
         "moduleResolution": "NodeNext",
         "skipLibCheck": true, // Avoid type errors from node_modules
         "strict": true // Enable strict type-checking options
       },
       "include": ["*.ts"]
   }
   

3. Transpilieren von TypeScript zu JavaScript.

   tsc
   

4. Melden Sie sich mit dem folgenden Befehl bei Azure an:

   az login
   

5. Führen Sie den Code mit dem folgenden Befehl aus:

   node from-audio.js
   

1. Erstellen Sie die from-audio.ts Datei mit dem folgenden Code:

   import { AzureOpenAI } from "openai";
   import { writeFileSync } from "node:fs";
   import { promises as fs } from 'fs';
   
   // Set environment variables or edit the corresponding values here.
   const endpoint: string = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
   const apiKey: string = process.env.AZURE_OPENAI_API_KEY || "AZURE_OPENAI_API_KEY";
   const apiVersion: string = "2025-01-01-preview"; 
   const deployment: string = "gpt-4o-mini-audio-preview"; 
   
   const client = new AzureOpenAI({ 
     endpoint, 
     apiKey, 
     apiVersion, 
     deployment 
   });  
   
   async function main(): Promise<void> {
   
     // Buffer the audio for input to the chat completion
     const wavBuffer = await fs.readFile("dog.wav"); 
     const base64str = Buffer.from(wavBuffer).toString("base64"); 
   
     // Make the audio chat completions request
     const response = await client.chat.completions.create({ 
       model: "gpt-4o-mini-audio-preview",
       modalities: ["text", "audio"], 
       audio: { voice: "alloy", format: "wav" },
       messages: [ 
         { 
           role: "user", 
           content: [ 
             { 
               type: "text", 
               text: "Describe in detail the spoken audio input." 
             }, 
             { 
               type: "input_audio", 
               input_audio: { 
                 data: base64str, 
                 format: "wav" 
               } 
             } 
           ] 
         } 
       ] 
     }); 
   
     console.log(response.choices[0]); 
   
     // Write the output audio data to a file
     if (response.choices[0].message.audio) {
         writeFileSync("analysis.wav", Buffer.from(response.choices[0].message.audio.data, 'base64'), { encoding: "utf-8" });
     }
     else {
         console.error("Audio data is null or undefined.");
   }
   }
   
   main().catch((err: Error) => {
   console.error("Error occurred:", err);
   });
   
   export { main };
   

2. Erstellen Sie die tsconfig.json Datei zum Transpilieren des TypeScript-Codes, und kopieren Sie den folgenden Code für ECMAScript.

   {
       "compilerOptions": {
         "module": "NodeNext",
         "target": "ES2022", // Supports top-level await
         "moduleResolution": "NodeNext",
         "skipLibCheck": true, // Avoid type errors from node_modules
         "strict": true // Enable strict type-checking options
       },
       "include": ["*.ts"]
   }
   

3. Transpilieren von TypeScript zu JavaScript.

   tsc
   

4. Führen Sie den Code mit dem folgenden Befehl aus:

   node from-audio.js
   

1. Erstellen Sie die multi-turn.ts Datei mit dem folgenden Code:

   import { AzureOpenAI } from "openai/index.mjs";
   import { promises as fs } from 'fs';
   import { ChatCompletionMessageParam } from "openai/resources/index.mjs";
   import {
       DefaultAzureCredential,
       getBearerTokenProvider,
     } from "@azure/identity";
   
   // Set environment variables or edit the corresponding values here.
   const endpoint: string = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
   const apiVersion: string = "2025-01-01-preview"; 
   const deployment: string = "gpt-4o-mini-audio-preview"; 
   
   // Keyless authentication 
   const getClient = (): AzureOpenAI => {
       const credential = new DefaultAzureCredential();
       const scope = "https://ai.azure.com/.default";
       const azureADTokenProvider = getBearerTokenProvider(credential, scope);
       const client = new AzureOpenAI({
         endpoint: endpoint,
         apiVersion: apiVersion,
         azureADTokenProvider,
       });
       return client;
   };
   
   const client = getClient(); 
   
   async function main(): Promise<void> {
   
       // Buffer the audio for input to the chat completion
       const wavBuffer = await fs.readFile("dog.wav"); 
       const base64str = Buffer.from(wavBuffer).toString("base64"); 
   
       // Initialize messages with the first turn's user input 
       const messages: ChatCompletionMessageParam[] = [
         {
           role: "user",
           content: [
             { 
               type: "text", 
               text: "Describe in detail the spoken audio input." 
             },
             { 
               type: "input_audio", 
               input_audio: { 
                 data: base64str, 
                 format: "wav" 
               } 
             }
           ]
         }
       ];
   
       // Get the first turn's response 
   
       const response = await client.chat.completions.create({ 
           model: "gpt-4o-mini-audio-preview",
           modalities: ["text", "audio"], 
           audio: { voice: "alloy", format: "wav" }, 
           messages: messages
       }); 
   
       console.log(response.choices[0]); 
   
       // Add a history message referencing the previous turn's audio by ID 
       messages.push({ 
           role: "assistant", 
           audio: response.choices[0].message.audio ? { id: response.choices[0].message.audio.id } : undefined
       });
   
       // Add a new user message for the second turn
       messages.push({ 
           role: "user", 
           content: [ 
               { 
                 type: "text", 
                 text: "Very concisely summarize the favorability." 
               } 
           ] 
       }); 
   
       // Send the follow-up request with the accumulated messages
       const followResponse = await client.chat.completions.create({ 
           model: "gpt-4o-mini-audio-preview",
           messages: messages
       });
   
       console.log(followResponse.choices[0].message.content); 
   }
   
   main().catch((err: Error) => {
     console.error("Error occurred:", err);
   });
   
   export { main };
   

2. Erstellen Sie die tsconfig.json Datei zum Transpilieren des TypeScript-Codes, und kopieren Sie den folgenden Code für ECMAScript.

   {
       "compilerOptions": {
         "module": "NodeNext",
         "target": "ES2022", // Supports top-level await
         "moduleResolution": "NodeNext",
         "skipLibCheck": true, // Avoid type errors from node_modules
         "strict": true // Enable strict type-checking options
       },
       "include": ["*.ts"]
   }
   

3. Transpilieren von TypeScript zu JavaScript.

   tsc
   

4. Melden Sie sich mit dem folgenden Befehl bei Azure an:

   az login
   

5. Führen Sie den Code mit dem folgenden Befehl aus:

   node multi-turn.js
   

1. Erstellen Sie die multi-turn.ts Datei mit dem folgenden Code:

   import { AzureOpenAI } from "openai/index.mjs";
   import { promises as fs } from 'fs';
   import { ChatCompletionMessageParam } from "openai/resources/index.mjs";
   
   // Set environment variables or edit the corresponding values here.
   const endpoint: string = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT" as string;
   const apiKey: string = process.env.AZURE_OPENAI_API_KEY || "AZURE_OPENAI_API_KEY";
   const apiVersion: string = "2025-01-01-preview"; 
   const deployment: string = "gpt-4o-mini-audio-preview"; 
   
   const client = new AzureOpenAI({ 
     endpoint, 
     apiKey, 
     apiVersion, 
     deployment 
   });  
   
   async function main(): Promise<void> {
   
       // Buffer the audio for input to the chat completion
       const wavBuffer = await fs.readFile("dog.wav"); 
       const base64str = Buffer.from(wavBuffer).toString("base64"); 
   
       // Initialize messages with the first turn's user input 
       const messages: ChatCompletionMessageParam[] = [
         {
           role: "user",
           content: [
             { 
               type: "text", 
               text: "Describe in detail the spoken audio input." 
             },
             { 
               type: "input_audio", 
               input_audio: { 
                 data: base64str, 
                 format: "wav" 
               } 
             }
           ]
         }
       ];
   
       // Get the first turn's response 
   
       const response = await client.chat.completions.create({ 
         model: "gpt-4o-mini-audio-preview",
         modalities: ["text", "audio"], 
         audio: { voice: "alloy", format: "wav" }, 
         messages: messages
       }); 
   
       console.log(response.choices[0]); 
   
       // Add a history message referencing the previous turn's audio by ID 
       messages.push({ 
           role: "assistant", 
           audio: response.choices[0].message.audio ? { id: response.choices[0].message.audio.id } : undefined
       });
   
       // Add a new user message for the second turn
       messages.push({ 
           role: "user", 
           content: [ 
               { 
                 type: "text", 
                 text: "Very concisely summarize the favorability." 
               } 
           ] 
       }); 
   
       // Send the follow-up request with the accumulated messages
       const followResponse = await client.chat.completions.create({ 
           model: "gpt-4o-mini-audio-preview",
           messages: messages
       });
   
       console.log(followResponse.choices[0].message.content); 
   }
   
   main().catch((err: Error) => {
     console.error("Error occurred:", err);
   });
   
   export { main };
   

2. Erstellen Sie die tsconfig.json Datei zum Transpilieren des TypeScript-Codes, und kopieren Sie den folgenden Code für ECMAScript.

   {
       "compilerOptions": {
         "module": "NodeNext",
         "target": "ES2022", // Supports top-level await
         "moduleResolution": "NodeNext",
         "skipLibCheck": true, // Avoid type errors from node_modules
         "strict": true // Enable strict type-checking options
       },
       "include": ["*.ts"]
   }
   

3. Transpilieren von TypeScript zu JavaScript.

   tsc
   

4. Führen Sie den Code mit dem folgenden Befehl aus:

   node multi-turn.js