Quickstart

1
import { fetchAccessToken } from '@humeai/voice';
2
// initialize access token to make authenticated requests.
3
let accessToken;
4
// fetch and set the access token
5
(async () => {
6
  accessToken = await fetchAccessToken(
7
    import.meta.env.HUME_API_KEY,
8
    import.meta.env.HUME_CLIENT_SECRET
9
  );
10
})();

1
import { VoiceClient, createSocketConfig } from '@humeai/voice';
2
// define EVI configuration
3
const config = createSocketConfig({
4
  auth: { type: 'accessToken', value: accessToken },
5
});
6
// instantiate client with configuration
7
const client = VoiceClient.create(config);
8
// setup event handlers for WebSocket
9
client.on('open', () => {
10
  console.log('WebSocket connection opened');
11
});
12
client.on('message', (message) => {
13
  console.log(message)
14
});
15
client.on('close', () => {
16
  console.log('WebSocket connection closed');
17
});
18
// establish an authenticated WebSocket connection
19
client.connect().then(() => {
20
  /* handle success */
21
}).catch(() => {
22
  /* handle error */
23
});

1
import { getAudioStream, checkForAudioTracks } from '@humeai/voice';
2
// define function for capturing audio
3
async function captureAudio() {
4
  // prompt for permission and get the audio stream if granted
5
  const audioStream = await getAudioStream();
6
  // ensures there is only one audio track in the media stream
7
  checkForAudioTracks();
8
  // get the supported mimeType
9
  const result = getSupportedMimeType();
10
  const mimeType = result.mimeType;
11
  // create a MediaRecorder to record the audio stream
12
  const rec = new MediaRecorder(audioStream, { mimeType });
13
  // event handler for when recorded audio data is available
14
  rec.ondataavailable = ({ data }) => {
15
    if (data.size > 0 && client.readyState === WebSocket.OPEN) {
16
      const buffer = await event.data.arrayBuffer();
17
      // send the buffer (audio binary) through the WebSocket
18
      client.sendAudio(buffer);
19
    }
20
  };
21
  // start recording
22
  rec.start(100);
23
}
24
// update the WebSocket open event handler to capture audio
25
client.on('open', async () => {
26
  console.log('Websocket connection opened');
27
  await captureAudio();
28
});

1
import { arrayBufferToBlob } from '@humeai/voice';
2
// queue to hold the audio blobs
3
let audioQueue = [];
4
// flag to check if audio is currently being played
5
let isPlaying = false;
6
// the current audio to be played
7
let currentAudio;
8
// function to play the audio blob from the queue
9
function playAudio(): void {
10
  if (audioQueue.length > 0 && !isPlaying) {
11
    // update isPlaying state
12
    isPlaying = true;
13
    // pull next audio output from the queue
14
    const audioBlob = audioQueue.shift();
15
    if (audioBlob) {
16
      const audioUrl = URL.createObjectURL(audioBlob);
17
      // converts Blob to AudioElement for playback
18
      currentAudio = new Audio(audioUrl);
19
      // play audio
20
      currentAudio.play();
21
      // callback for when audio finishes playing
22
      currentAudio.onended = async () => {
23
        // update isPlaying state
24
        isPlaying = false;
25
        // attempt to pull next audio output from queue
26
        if (audioQueue.length) playAudio();
27
      };
28
    }
29
  }
30
}
31
// update the client's WebSocket message event handler.
32
client.on('message', (message) => {
33
  switch (message.type) {
34
    case 'audio_output':
35
      // extract audio output from the message
36
      const audioOutput = message.data;
37
      // convert audio output binary to a Blob
38
      const blob = base64ToBlob(audioOutput, mimeType);
39
      // add Blob to the playback queue
40
      audioQueue.push(blob);
41
      if (audioQueue.length <= 1) {
42
        // attempt to play next audio output from the queue
43
        await playAudio();
44
      }
45
      break;
46
  }
47
});

1
// function for stopping the audio and clearing the queue
2
function stopAudio(): void {
3
  currentAudio?.pause();
4
  currentAudio = null;
5
  isPlaying = false;
6
  audioQueue.length = 0;
7
}
8
// update client's WebSocket message event handler
9
client.on('message', (message) => {
10
  switch (message.type) {
11
    case 'audio_output':
12
      // extract audio output from the message
13
      const audioOutput = message.data;
14
      // convert audio output binary to a Blob
15
      const blob = base64ToBlob(audioOutput, mimeType);
16
      // add Blob to the playback queue
17
      audioQueue.push(blob);
18
      if (audioQueue.length <= 1) {
19
        // play next audio output from the audio playback queue
20
        await playAudio();
21
      }
22
      break;
23
    case 'user_interruption':
24
      // stop audio playback and clear audio queue
25
      stopAudio();
26
      break;
27
  }
28
});