GPT Realtime API för tal och ljud

Läs mer om nyckellös autentisering och inställning av miljövariabler.

Läs mer om att hitta API-nycklar och ange miljövariabler.

1. index.js Skapa filen med följande kod:

   import OpenAI from 'openai';
   import { OpenAIRealtimeWS } from 'openai/realtime/ws';
   import { DefaultAzureCredential, getBearerTokenProvider } from '@azure/identity';
   import { OpenAIRealtimeError } from 'openai/realtime/internal-base';
   
   let isCreated = false;
   let isConfigured = false;
   let responseDone = false;
   
   // Set this to false, if you want to continue receiving events after an error is received.
   const throwOnError = true;
   
   async function main() {
       // The endpoint of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_ENDPOINT
       // environment variable or replace the default value below.
       // You can find it in the Azure AI Foundry portal in the Overview page of your Azure OpenAI resource.
       // Example: https://{your-resource}.openai.azure.com
       const endpoint = process.env.AZURE_OPENAI_ENDPOINT || 'AZURE_OPENAI_ENDPOINT';
       const baseUrl = endpoint.replace(/\/$/, "") + '/openai/v1';
   
       // The deployment name of your Azure OpenAI model is required. You can set it in the AZURE_OPENAI_DEPLOYMENT_NAME
       // environment variable or replace the default value below.
       // You can find it in the Azure AI Foundry portal in the "Models + endpoints" page of your Azure OpenAI resource.
       // Example: gpt-realtime
       const deploymentName = process.env.AZURE_OPENAI_DEPLOYMENT_NAME || 'gpt-realtime';
   
       // Keyless authentication
       const credential = new DefaultAzureCredential();
       const scope = 'https://cognitiveservices.azure.com/.default';
       const azureADTokenProvider = getBearerTokenProvider(credential, scope);
       const token = await azureADTokenProvider();
   
       // The APIs are compatible with the OpenAI client library.
       // You can use the OpenAI client library to access the Azure OpenAI APIs.
       // Make sure to set the baseURL and apiKey to use the Azure OpenAI endpoint and token.
       const openAIClient = new OpenAI({
           baseURL: baseUrl,
           apiKey: token,
       });
       const realtimeClient = await OpenAIRealtimeWS.create(openAIClient, {
           model: deploymentName
       });
   
       realtimeClient.on('error', (receivedError) => receiveError(receivedError));
       realtimeClient.on('session.created', (receivedEvent) => receiveEvent(receivedEvent));
       realtimeClient.on('session.updated', (receivedEvent) => receiveEvent(receivedEvent));
       realtimeClient.on('response.output_audio.delta', (receivedEvent) => receiveEvent(receivedEvent));
       realtimeClient.on('response.output_audio_transcript.delta', (receivedEvent) => receiveEvent(receivedEvent));
       realtimeClient.on('response.done', (receivedEvent) => receiveEvent(receivedEvent));
   
       console.log('Waiting for events...');
       while (!isCreated) {
           console.log('Waiting for session.created event...');
           await new Promise((resolve) => setTimeout(resolve, 100));
       }
   
       // After the session is created, configure it to enable audio input and output.
       const sessionConfig = {
           'type': 'realtime',
           'instructions': 'You are a helpful assistant. You respond by voice and text.',
           'output_modalities': ['audio'],
           'audio': {
               'input': {
                   'transcription': {
                       'model': 'whisper-1'
                   },
                   'format': {
                       'type': 'audio/pcm',
                       'rate': 24000,
                   },
                   'turn_detection': {
                       'type': 'server_vad',
                       'threshold': 0.5,
                       'prefix_padding_ms': 300,
                       'silence_duration_ms': 200,
                       'create_response': true
                   }
               },
               'output': {
                   'voice': 'alloy',
                   'format': {
                       'type': 'audio/pcm',
                       'rate': 24000,
                   }
               }
           }
       };
   
       realtimeClient.send({
           'type': 'session.update',
           'session': sessionConfig
       });
       while (!isConfigured) {
           console.log('Waiting for session.updated event...');
           await new Promise((resolve) => setTimeout(resolve, 100));
       }
   
       // After the session is configured, data can be sent to the session.    
       realtimeClient.send({
           'type': 'conversation.item.create',
           'item': {
               'type': 'message',
               'role': 'user',
               'content': [{
                   type: 'input_text',
                   text: 'Please assist the user.'
               }
               ]
           }
       });
   
       realtimeClient.send({
           type: 'response.create'
       });
   
   
   
       // While waiting for the session to finish, the events can be handled in the event handlers.
       // In this example, we just wait for the first response.done event.
       while (!responseDone) {
           console.log('Waiting for response.done event...');
           await new Promise((resolve) => setTimeout(resolve, 100));
       }
   
       console.log('The sample completed successfully.');
       realtimeClient.close();
   }
   
   function receiveError(err) {
       if (err instanceof OpenAIRealtimeError) {
           console.error('Received an error event.');
           console.error(`Message: ${err.cause.message}`);
           console.error(`Stack: ${err.cause.stack}`);
       }
   
       if (throwOnError) {
           throw err;
       }
   }
   
   function receiveEvent(event) {
       console.log(`Received an event: ${event.type}`);
   
       switch (event.type) {
           case 'session.created':
               console.log(`Session ID: ${event.session.id}`);
               isCreated = true;
               break;
           case 'session.updated':
               console.log(`Session ID: ${event.session.id}`);
               isConfigured = true;
               break;
           case 'response.output_audio_transcript.delta':
               console.log(`Transcript delta: ${event.delta}`);
               break;
           case 'response.output_audio.delta':
               let audioBuffer = Buffer.from(event.delta, 'base64');
               console.log(`Audio delta length: ${audioBuffer.length} bytes`);
               break;
           case 'response.done':
               console.log(`Response ID: ${event.response.id}`);
               console.log(`The final response is: ${event.response.output[0].content[0].transcript}`);
               responseDone = true;
               break;
           default:
               console.warn(`Unhandled event type: ${event.type}`);
       }
   }
   
   main().catch((err) => {
       console.error('The sample encountered an error:', err);
   });
   export {
       main
   };
   

2. Logga in på Azure med följande kommando:

   az login
   

3. Kör JavaScript-filen.

   node index.js
   

1. index.js Skapa filen med följande kod:

   import OpenAI from 'openai';
   import { OpenAIRealtimeWS } from 'openai/realtime/ws';
   import { OpenAIRealtimeError } from 'openai/realtime/internal-base';
   
   let isCreated = false;
   let isConfigured = false;
   let responseDone = false;
   
   // Set this to false, if you want to continue receiving events after an error is received.
   const throwOnError = true;
   
   async function main() {
       // The endpoint of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_ENDPOINT
       // environment variable or replace the default value below.
       // You can find it in the Azure AI Foundry portal in the Overview page of your Azure OpenAI resource.
       // Example: https://{your-resource}.openai.azure.com
       const endpoint = process.env.AZURE_OPENAI_ENDPOINT || 'AZURE_OPENAI_ENDPOINT';
       const baseUrl = endpoint.replace(/\/$/, "") + '/openai/v1';
   
       // The deployment name of your Azure OpenAI model is required. You can set it in the AZURE_OPENAI_DEPLOYMENT_NAME
       // environment variable or replace the default value below.
       // You can find it in the Azure AI Foundry portal in the "Models + endpoints" page of your Azure OpenAI resource.
       // Example: gpt-realtime
       const deploymentName = process.env.AZURE_OPENAI_DEPLOYMENT_NAME || 'gpt-realtime';
   
       // API Key of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_API_KEY
       // environment variable or replace the default value below.
       // You can find it in the Azure AI Foundry portal in the Overview page of your Azure OpenAI resource.
       const token = process.env.AZURE_OPENAI_API_KEY || '<Your API Key>';
   
       // The APIs are compatible with the OpenAI client library.
       // You can use the OpenAI client library to access the Azure OpenAI APIs.
       // Make sure to set the baseURL and apiKey to use the Azure OpenAI endpoint and token.
       const openAIClient = new OpenAI({
           baseURL: baseUrl,
           apiKey: token,
       });
   
       // Due to the current SDK limitation we need to explicitly
       // pass API key as Header
       const realtimeClient = await OpenAIRealtimeWS.create(
           openAIClient, {
           model: deploymentName,
           options: {
               headers: {
                   "api-key": token
               }
           }
       });
   
       realtimeClient.on('error', (receivedError) => receiveError(receivedError));
       realtimeClient.on('session.created', (receivedEvent) => receiveEvent(receivedEvent));
       realtimeClient.on('session.updated', (receivedEvent) => receiveEvent(receivedEvent));
       realtimeClient.on('response.output_audio.delta', (receivedEvent) => receiveEvent(receivedEvent));
       realtimeClient.on('response.output_audio_transcript.delta', (receivedEvent) => receiveEvent(receivedEvent));
       realtimeClient.on('response.done', (receivedEvent) => receiveEvent(receivedEvent));
   
       console.log('Waiting for events...');
       while (!isCreated) {
           console.log('Waiting for session.created event...');
           await new Promise((resolve) => setTimeout(resolve, 100));
       }
   
       // After the session is created, configure it to enable audio input and output.
       const sessionConfig = {
           'type': 'realtime',
           'instructions': 'You are a helpful assistant. You respond by voice and text.',
           'output_modalities': ['audio'],
           'audio': {
               'input': {
                   'transcription': {
                       'model': 'whisper-1'
                   },
                   'format': {
                       'type': 'audio/pcm',
                       'rate': 24000,
                   },
                   'turn_detection': {
                       'type': 'server_vad',
                       'threshold': 0.5,
                       'prefix_padding_ms': 300,
                       'silence_duration_ms': 200,
                       'create_response': true
                   }
               },
               'output': {
                   'voice': 'alloy',
                   'format': {
                       'type': 'audio/pcm',
                       'rate': 24000,
                   }
               }
           }
       };
   
       realtimeClient.send({
           'type': 'session.update',
           'session': sessionConfig
       });
       while (!isConfigured) {
           console.log('Waiting for session.updated event...');
           await new Promise((resolve) => setTimeout(resolve, 100));
       }
   
       // After the session is configured, data can be sent to the session.
       realtimeClient.send({
           'type': 'conversation.item.create',
           'item': {
               'type': 'message',
               'role': 'user',
               'content': [{
                   type: 'input_text',
                   text: 'Please assist the user.'
               }
               ]
           }
       });
   
       realtimeClient.send({
           type: 'response.create'
       });
   
       // While waiting for the session to finish, the events can be handled in the event handlers.
       // In this example, we just wait for the first response.done event.
       while (!responseDone) {
           console.log('Waiting for response.done event...');
           await new Promise((resolve) => setTimeout(resolve, 100));
       }
   
       console.log('The sample completed successfully.');
       realtimeClient.close();
   }
   
   function receiveError(err) {
       if (err instanceof OpenAIRealtimeError) {
           console.error('Received an error event.');
           console.error(`Message: ${err.cause.message}`);
           console.error(`Stack: ${err.cause.stack}`);
       }
   
       if (throwOnError) {
           throw err;
       }
   }
   
   function receiveEvent(event) {
       console.log(`Received an event: ${event.type}`);
   
       switch (event.type) {
           case 'session.created':
               console.log(`Session ID: ${event.session.id}`);
               isCreated = true;
               break;
           case 'session.updated':
               console.log(`Session ID: ${event.session.id}`);
               isConfigured = true;
               break;
           case 'response.output_audio_transcript.delta':
               console.log(`Transcript delta: ${event.delta}`);
               break;
           case 'response.output_audio.delta':
               let audioBuffer = Buffer.from(event.delta, 'base64');
               console.log(`Audio delta length: ${audioBuffer.length} bytes`);
               break;
           case 'response.done':
               console.log(`Response ID: ${event.response.id}`);
               console.log(`The final response is: ${event.response.output[0].content[0].transcript}`);
               responseDone = true;
               break;
           default:
               console.warn(`Unhandled event type: ${event.type}`);
       }
   }
   
   main().catch((err) => {
       console.error('The sample encountered an error:', err);
   });
   export {
       main
   };
   

2. Kör JavaScript-filen.

   node index.js
   

Läs mer om nyckellös autentisering och inställning av miljövariabler.

Läs mer om att hitta API-nycklar och ange miljövariabler.

1. text-in-audio-out.py Skapa filen med följande kod:

   import os
   import base64
   import asyncio
   from openai import AsyncOpenAI
   from azure.identity import DefaultAzureCredential, get_bearer_token_provider
   
   async def main() -> None:
       """
       When prompted for user input, type a message and hit enter to send it to the model.
       Enter "q" to quit the conversation.
       """
   
       credential = DefaultAzureCredential()
       token_provider = get_bearer_token_provider(credential, "https://cognitiveservices.azure.com/.default")
       token = token_provider()
   
       # The endpoint of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_ENDPOINT
       # environment variable.
       # You can find it in the Azure AI Foundry portal in the Overview page of your Azure OpenAI resource.
       # Example: https://{your-resource}.openai.azure.com
       endpoint = os.environ["AZURE_OPENAI_ENDPOINT"]
   
       # The deployment name of the model you want to use is required. You can set it in the AZURE_OPENAI_DEPLOYMENT_NAME
       # environment variable.
       # You can find it in the Azure AI Foundry portal in the "Models + endpoints" page of your Azure OpenAI resource.
       # Example: gpt-realtime
       deployment_name = os.environ["AZURE_OPENAI_DEPLOYMENT_NAME"]
   
       base_url = endpoint.replace("https://", "wss://").rstrip("/") + "/openai/v1"
   
       # The APIs are compatible with the OpenAI client library.
       # You can use the OpenAI client library to access the Azure OpenAI APIs.
       # Make sure to set the baseURL and apiKey to use the Azure OpenAI endpoint and token.
       client = AsyncOpenAI(
           websocket_base_url=base_url,
           api_key=token
       )
       async with client.realtime.connect(
           model=deployment_name,
       ) as connection:
           # after the connection is created, configure the session.
           await connection.session.update(session={
               "instructions": "You are a helpful assistant. You respond by voice and text.",
               "output_modalities": ["audio"],
               "audio": {
                   "input": {
                       "transcription": {
                           "model": "whisper-1",
                       },
                       "format": {
                           "type": "audio/pcm",
                           "rate": 24000,
                       },
                       "turn_detection": {
                           "type": "server_vad",
                           "threshold": 0.5,
                           "prefix_padding_ms": 300,
                           "silence_duration_ms": 200,
                           "create_responese": True,
                       }
                   },
                   "output": {
                       "voice": "alloy",
                       "format": {
                           "type": "audio/pcm",
                           "rate": 24000,
                       }
                   }
               }
           })
   
           # After the session is configured, data can be sent to the session.
           while True:
               user_input = input("Enter a message: ")
               if user_input == "q":
                   print("Stopping the conversation.")
                   break
   
               await connection.conversation.item.create(
                   item={
                       "type": "message",
                       "role": "user",
                       "content": [{"type": "input_text", "text": user_input}],
                   }
               )
               await connection.response.create()
               async for event in connection:
                   if event.type == "response.output_text.delta":
                       print(event.delta, flush=True, end="")
                   elif event.type == "response.output_audio.delta":
   
                       audio_data = base64.b64decode(event.delta)
                       print(f"Received {len(audio_data)} bytes of audio data.")
                   elif event.type == "response.output_audio_transcript.delta":
                       print(f"Received text delta: {event.delta}")
                   elif event.type == "response.output_text.done":
                       print()
                   elif event.type == "response.done":
                       break
   
       print("Conversation ended.")
       credential.close()
   
   asyncio.run(main())
   

2. Logga in på Azure med följande kommando:

   az login
   

3. Kör Python-filen.

   python text-in-audio-out.py
   

4. När du uppmanas att mata in något, skriv ett meddelande och tryck på Retur för att skicka det till modellen. Ange "q" för att avsluta konversationen.

1. text-in-audio-out.py Skapa filen med följande kod:

   import os
   import base64
   import asyncio
   from openai import AsyncOpenAI
   
   async def main() -> None:
       """
       When prompted for user input, type a message and hit enter to send it to the model.
       Enter "q" to quit the conversation.
       """
   
       # The endpoint of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_ENDPOINT
       # environment variable.
       # You can find it in the Azure AI Foundry portal in the Overview page of your Azure OpenAI resource.
       # Example: https://{your-resource}.openai.azure.com
       endpoint = os.environ["AZURE_OPENAI_ENDPOINT"]
       base_url = endpoint.replace("https://", "wss://").rstrip("/") + "/openai/v1"
   
       # The deployment name of the model you want to use is required. You can set it in the AZURE_OPENAI_DEPLOYMENT_NAME
       # environment variable.
       # You can find it in the Azure AI Foundry portal in the "Models + endpoints" page of your Azure OpenAI resource.
       # Example: gpt-realtime
       deployment_name = os.environ["AZURE_OPENAI_DEPLOYMENT_NAME"]
   
       # API Key of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_API_KEY
       # environment variable.
       # You can find it in the Azure AI Foundry portal in the Overview page of your Azure OpenAI resource.
       token=os.environ["AZURE_OPENAI_API_KEY"]
   
       # The APIs are compatible with the OpenAI client library.
       # You can use the OpenAI client library to access the Azure OpenAI APIs.
       # Make sure to set the baseURL and apiKey to use the Azure OpenAI endpoint and token.
       client = AsyncOpenAI(
           websocket_base_url=base_url,
           api_key=token
       )
       async with client.realtime.connect(
           model=deployment_name,
       ) as connection:
           # after the connection is created, configure the session.
           await connection.session.update(session={
               "instructions": "You are a helpful assistant. You respond by voice and text.",
               "output_modalities": ["audio"],
               "audio": {
                   "input": {
                       "transcription": {
                           "model": "whisper-1",
                       },
                       "format": {
                           "type": "audio/pcm",
                           "rate": 24000,
                       },
                       "turn_detection": {
                           "type": "server_vad",
                           "threshold": 0.5,
                           "prefix_padding_ms": 300,
                           "silence_duration_ms": 200,
                           "create_responese": True,
                       }
                   },
                   "output": {
                       "voice": "alloy",
                       "format": {
                           "type": "audio/pcm",
                           "rate": 24000,
                       }
                   }
               }
           })
   
           # After the session is configured, data can be sent to the session.
           while True:
               user_input = input("Enter a message: ")
               if user_input == "q":
                   print("Stopping the conversation.")
                   break
   
               await connection.conversation.item.create(
                   item={
                       "type": "message",
                       "role": "user",
                       "content": [{"type": "input_text", "text": user_input}],
                   }
               )
               await connection.response.create()
               async for event in connection:
                   if event.type == "response.output_text.delta":
                       print(event.delta, flush=True, end="")
                   elif event.type == "response.output_audio.delta":
   
                       audio_data = base64.b64decode(event.delta)
                       print(f"Received {len(audio_data)} bytes of audio data.")
                   elif event.type == "response.output_audio_transcript.delta":
                       print(f"Received text delta: {event.delta}")
                   elif event.type == "response.output_text.done":
                       print()
                   elif event.type == "response.done":
                       break
   
       print("Conversation ended.")
   
   asyncio.run(main())
   

2. Kör Python-filen.

   python text-in-audio-out.py
   

3. När du uppmanas att mata in något, skriv ett meddelande och tryck på Retur för att skicka det till modellen. Ange "q" för att avsluta konversationen.

Läs mer om nyckellös autentisering och inställning av miljövariabler.

Läs mer om att hitta API-nycklar och ange miljövariabler.

1. index.ts Skapa filen med följande kod:

   import OpenAI from 'openai';
   import { OpenAIRealtimeWS } from 'openai/realtime/ws';
   import { OpenAIRealtimeError } from 'openai/realtime/internal-base';
   import { DefaultAzureCredential, getBearerTokenProvider } from "@azure/identity";
   import { RealtimeSessionCreateRequest } from 'openai/resources/realtime/realtime';
   
   let isCreated = false;
   let isConfigured = false;
   let responseDone = false;
   
   // Set this to false, if you want to continue receiving events after an error is received.
   const throwOnError = true;
   
   async function main(): Promise<void> {
       // The endpoint of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_ENDPOINT
       // environment variable or replace the default value below.
       // You can find it in the Azure AI Foundry portal in the Overview page of your Azure OpenAI resource.
       // Example: https://{your-resource}.openai.azure.com
       const endpoint = process.env.AZURE_OPENAI_ENDPOINT || 'AZURE_OPENAI_ENDPOINT';
       const baseUrl = endpoint.replace(/\/$/, "") + '/openai/v1';
   
       // The deployment name of your Azure OpenAI model is required. You can set it in the AZURE_OPENAI_DEPLOYMENT_NAME
       // environment variable or replace the default value below.
       // You can find it in the Azure AI Foundry portal in the "Models + endpoints" page of your Azure OpenAI resource.
       // Example: gpt-realtime
       const deploymentName = process.env.AZURE_OPENAI_DEPLOYMENT_NAME || 'gpt-realtime';
   
       // Keyless authentication
       const credential = new DefaultAzureCredential();
       const scope = "https://cognitiveservices.azure.com/.default";
       const azureADTokenProvider = getBearerTokenProvider(credential, scope);
       const token = await azureADTokenProvider();
   
       // The APIs are compatible with the OpenAI client library.
       // You can use the OpenAI client library to access the Azure OpenAI APIs.
       // Make sure to set the baseURL and apiKey to use the Azure OpenAI endpoint and token.
       const openAIClient = new OpenAI({
           baseURL: baseUrl,
           apiKey: token,
       });
       const realtimeClient = await OpenAIRealtimeWS.create(openAIClient, { model: deploymentName });
   
       realtimeClient.on('error', (receivedError) => receiveError(receivedError));
       realtimeClient.on('session.created', (receivedEvent) => receiveEvent(receivedEvent));
       realtimeClient.on('session.updated', (receivedEvent) => receiveEvent(receivedEvent));
       realtimeClient.on('response.output_audio.delta', (receivedEvent) => receiveEvent(receivedEvent));
       realtimeClient.on('response.output_audio_transcript.delta', (receivedEvent) => receiveEvent(receivedEvent));
       realtimeClient.on('response.done', (receivedEvent) => receiveEvent(receivedEvent));
   
       console.log('Waiting for events...');
       while (!isCreated) {
           console.log('Waiting for session.created event...');
           await new Promise((resolve) => setTimeout(resolve, 100));
       }
   
       // After the session is created, configure it to enable audio input and output.
       const sessionConfig: RealtimeSessionCreateRequest = {
           'type': 'realtime',
           'instructions': 'You are a helpful assistant. You respond by voice and text.',
           'output_modalities': ['audio'],
           'audio': {
               'input': {
                   'transcription': {
                       'model': 'whisper-1'
                   },
                   'format': {
                       'type': 'audio/pcm',
                       'rate': 24000,
                   },
                   'turn_detection': {
                       'type': 'server_vad',
                       'threshold': 0.5,
                       'prefix_padding_ms': 300,
                       'silence_duration_ms': 200,
                       'create_response': true
                   }
               },
               'output': {
                   'voice': 'alloy',
                   'format': {
                       'type': 'audio/pcm',
                       'rate': 24000,
                   }
               }
           }
       };
   
       realtimeClient.send({ 'type': 'session.update', 'session': sessionConfig });
   
       while (!isConfigured) {
           console.log('Waiting for session.updated event...');
           await new Promise((resolve) => setTimeout(resolve, 100));
       }
   
       // After the session is configured, data can be sent to the session.
       realtimeClient.send({
           'type': 'conversation.item.create',
           'item': {
               'type': 'message',
               'role': 'user',
               'content': [{ type: 'input_text', text: 'Please assist the user.' }]
           }
       });
   
       realtimeClient.send({ type: 'response.create' });
   
       // While waiting for the session to finish, the events can be handled in the event handlers.
       // In this example, we just wait for the first response.done event. 
       while (!responseDone) {
           console.log('Waiting for response.done event...');
           await new Promise((resolve) => setTimeout(resolve, 100));
       }
   
       console.log('The sample completed successfully.');
       realtimeClient.close();
   }
   
   function receiveError(errorEvent: OpenAIRealtimeError): void {
       if (errorEvent instanceof OpenAIRealtimeError) {
           console.error('Received an error event.');
           console.error(`Message: ${errorEvent.message}`);
           console.error(`Stack: ${errorEvent.stack}`); errorEvent
       }
   
       if (throwOnError) {
           throw errorEvent;
       }
   }
   
   function receiveEvent(event: any): void {
       console.log(`Received an event: ${event.type}`);
   
       switch (event.type) {
           case 'session.created':
               console.log(`Session ID: ${event.session.id}`);
               isCreated = true;
               break;
           case 'session.updated':
               console.log(`Session ID: ${event.session.id}`);
               isConfigured = true;
               break;
           case 'response.output_audio_transcript.delta':
               console.log(`Transcript delta: ${event.delta}`);
               break;
           case 'response.output_audio.delta':
               let audioBuffer = Buffer.from(event.delta, 'base64');
               console.log(`Audio delta length: ${audioBuffer.length} bytes`);
               break;
           case 'response.done':
               console.log(`Response ID: ${event.response.id}`);
               console.log(`The final response is: ${event.response.output[0].content[0].transcript}`);
               responseDone = true;
               break;
           default:
               console.warn(`Unhandled event type: ${event.type}`);
       }
   }
   
   main().catch((err) => {
       console.error("The sample encountered an error:", err);
   });
   
   export { main };    
   

2. tsconfig.json Skapa filen för att transpilera TypeScript-koden och kopiera följande kod 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. Installera typdefinitioner för Node

   npm i --save-dev @types/node
   

4. Transpilera från TypeScript till JavaScript.

   tsc
   

5. Logga in på Azure med följande kommando:

   az login
   

6. Kör koden med följande kommando:

   node index.js
   

1. index.ts Skapa filen med följande kod:

   import OpenAI from 'openai';
   import { OpenAIRealtimeWS } from 'openai/realtime/ws';
   import { OpenAIRealtimeError } from 'openai/realtime/internal-base';
   import { RealtimeSessionCreateRequest } from 'openai/resources/realtime/realtime';
   
   let isCreated = false;
   let isConfigured = false;
   let responseDone = false;
   
   // Set this to false, if you want to continue receiving events after an error is received.
   const throwOnError = true;
   
   async function main(): Promise<void> {
       // The endpoint of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_ENDPOINT
       // environment variable or replace the default value below.
       // You can find it in the Azure AI Foundry portal in the Overview page of your Azure OpenAI resource.
       // Example: https://{your-resource}.openai.azure.com
       const endpoint = process.env.AZURE_OPENAI_ENDPOINT || 'AZURE_OPENAI_ENDPOINT';
       const baseUrl = endpoint.replace(/\/$/, "") + '/openai/v1';
   
       // The deployment name of your Azure OpenAI model is required. You can set it in the AZURE_OPENAI_DEPLOYMENT_NAME
       // environment variable or replace the default value below.
       // You can find it in the Azure AI Foundry portal in the "Models + endpoints" page of your Azure OpenAI resource.
       // Example: gpt-realtime
       const deploymentName = process.env.AZURE_OPENAI_DEPLOYMENT_NAME || 'gpt-realtime';
   
       // API Key of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_API_KEY
       // environment variable or replace the default value below.
       // You can find it in the Azure AI Foundry portal in the Overview page of your Azure OpenAI resource.
       const token = process.env.AZURE_OPENAI_API_KEY || '<Your API Key>';
   
       // The APIs are compatible with the OpenAI client library.
       // You can use the OpenAI client library to access the Azure OpenAI APIs.
       // Make sure to set the baseURL and apiKey to use the Azure OpenAI endpoint and token.
       const openAIClient = new OpenAI({
           baseURL: baseUrl,
           apiKey: token,
       });
   
       // Due to the current SDK limitation we need to explicitly
       // pass API key as Header
       const realtimeClient = await OpenAIRealtimeWS.create(
           openAIClient, {
           model: deploymentName,
           options: {
               headers: {
                   "api-key": token
               }
           }
       });
   
       realtimeClient.on('error', (receivedError) => receiveError(receivedError));
       realtimeClient.on('session.created', (receivedEvent) => receiveEvent(receivedEvent));
       realtimeClient.on('session.updated', (receivedEvent) => receiveEvent(receivedEvent));
       realtimeClient.on('response.output_audio.delta', (receivedEvent) => receiveEvent(receivedEvent));
       realtimeClient.on('response.output_audio_transcript.delta', (receivedEvent) => receiveEvent(receivedEvent));
       realtimeClient.on('response.done', (receivedEvent) => receiveEvent(receivedEvent));
   
       console.log('Waiting for events...');
       while (!isCreated) {
           console.log('Waiting for session.created event...');
           await new Promise((resolve) => setTimeout(resolve, 100));
       }
   
       // After the session is created, configure it to enable audio input and output.
       const sessionConfig: RealtimeSessionCreateRequest = {
           'type': 'realtime',
           'instructions': 'You are a helpful assistant. You respond by voice and text.',
           'output_modalities': ['audio'],
           'audio': {
               'input': {
                   'transcription': {
                       'model': 'whisper-1'
                   },
                   'format': {
                       'type': 'audio/pcm',
                       'rate': 24000,
                   },
                   'turn_detection': {
                       'type': 'server_vad',
                       'threshold': 0.5,
                       'prefix_padding_ms': 300,
                       'silence_duration_ms': 200,
                       'create_response': true
                   }
               },
               'output': {
                   'voice': 'alloy',
                   'format': {
                       'type': 'audio/pcm',
                       'rate': 24000,
                   }
               }
           }
       };
   
       realtimeClient.send({
           'type': 'session.update',
           'session': sessionConfig
       });
       while (!isConfigured) {
           console.log('Waiting for session.updated event...');
           await new Promise((resolve) => setTimeout(resolve, 100));
       }
   
       // After the session is configured, data can be sent to the session.    
       realtimeClient.send({
           'type': 'conversation.item.create',
           'item': {
               'type': 'message',
               'role': 'user',
               'content': [{
                   type: 'input_text',
                   text: 'Please assist the user.'
               }
               ]
           }
       });
   
       realtimeClient.send({
           type: 'response.create'
       });
   
       // While waiting for the session to finish, the events can be handled in the event handlers.
       // In this example, we just wait for the first response.done event.
       while (!responseDone) {
           console.log('Waiting for response.done event...');
           await new Promise((resolve) => setTimeout(resolve, 100));
       }
   
       console.log('The sample completed successfully.');
       realtimeClient.close();
   }
   
   function receiveError(errorEvent: OpenAIRealtimeError): void {
       if (errorEvent instanceof OpenAIRealtimeError) {
           console.error('Received an error event.');
           console.error(`Message: ${errorEvent.message}`);
           console.error(`Stack: ${errorEvent.stack}`);
           errorEvent
       }
   
       if (throwOnError) {
           throw errorEvent;
       }
   }
   
   function receiveEvent(event: any): void {
       console.log(`Received an event: ${event.type}`);
   
       switch (event.type) {
           case 'session.created':
               console.log(`Session ID: ${event.session.id}`);
               isCreated = true;
               break;
           case 'session.updated':
               console.log(`Session ID: ${event.session.id}`);
               isConfigured = true;
               break;
           case 'response.output_audio_transcript.delta':
               console.log(`Transcript delta: ${event.delta}`);
               break;
           case 'response.output_audio.delta':
               let audioBuffer = Buffer.from(event.delta, 'base64');
               console.log(`Audio delta length: ${audioBuffer.length} bytes`);
               break;
           case 'response.done':
               console.log(`Response ID: ${event.response.id}`);
               console.log(`The final response is: ${event.response.output[0].content[0].transcript}`);
               responseDone = true;
               break;
           default:
               console.warn(`Unhandled event type: ${event.type}`);
       }
   }
   
   main().catch((err) => {
       console.error("The sample encountered an error:", err);
   });
   
   export {
       main
   };
   

2. tsconfig.json Skapa filen för att transpilera TypeScript-koden och kopiera följande kod 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. Installera typdefinitioner för Node

   npm i --save-dev @types/node
   

4. Transpilera från TypeScript till JavaScript.

   tsc
   

5. Kör koden med följande kommando:

   node index.js