TTS NodeJS Quickstart Guide

1
// index.ts
2
import { HumeClient } from "hume"
3
import dotenv from "dotenv"
4
5
dotenv.config()
6
7
const hume = new HumeClient({ 
8
  apiKey: process.env.HUME_API_KEY!
9
})

1
// audio_player.ts
2
import { spawn } from 'child_process';
3
4
export const startAudioPlayer = () => {
5
  const ffplay = spawn('ffplay', ['-nodisp', '-autoexit', '-'], {
6
    stdio: ['pipe', 'ignore', 'ignore']
7
  });
8
9
  return {
10
    stdin: ffplay.stdin,
11
    stop: async () => {
12
      ffplay.stdin.end();
13
      await new Promise(resolve => ffplay.on('close', resolve));
14
    }
15
  };
16
};

1
const utterance = {
2
  text: "Dogs became domesticated between 23,000 and 30,000 years ago.",
3
  voice: { name: 'Ava Song', provider: 'HUME_AI' as const }
4
}
5
6
const stream = await hume.tts.synthesizeJsonStreaming({
7
  utterances: [utterance],
8
  // With `stripHeaders: true`, only the first audio chunk will contain
9
  // headers in container formats (wav, mp3). This allows you to start a
10
  // single audio player and stream all audio chunks to it without artifacts.
11
  stripHeaders: true
12
})
13
14
const audioPlayer = startAudioPlayer()
15
for await (const snippet of stream) {
16
  const buffer = Buffer.from(snippet.audio, "base64")
17
  audioPlayer.stdin.write(buffer)
18
}
19
await audioPlayer.stop()

1
// Create voice options for user selection
2
const result = await hume.tts.synthesizeJson({
3
  utterances: [{
4
    description: "Crisp, upper-class British accent with impeccably articulated consonants and perfectly placed vowels. Authoritative and theatrical, as if giving a lecture.",
5
    text: "The science of speech. That's my profession; also my hobby. Happy is the man who can make a living by his hobby!"
6
  }],
7
  numGenerations: 2,
8
  stripHeaders: true,
9
})
10
11
const audioPlayer = startAudioPlayer()
12
let sampleNumber = 1;
13
for (const generation of result.generations) {
14
  const buffer = Buffer.from(generation.audio, "base64")
15
  audioPlayer.stdin.write(buffer)
16
  console.log(`Playing option ${sampleNumber}...`)
17
  sampleNumber++;
18
}
19
await audioPlayer.stop()
20
21
// Select the second voice option for this example
22
const selectedGenerationId = result.generations[1].generationId
23
24
const voiceName = `higgins-${Date.now()}`;
25
await hume.tts.voices.create({
26
  name: voiceName,
27
  generationId: selectedGenerationId,
28
})
29
30
console.log(`Created voice: ${voiceName}`)

1
const audioPlayer = startAudioPlayer()
2
const stream = await hume.tts.synthesizeJsonStreaming({
3
  utterances: [{
4
    voice: { name: voiceName },
5
    text: "YOU can spot an Irishman or a Yorkshireman by his brogue. I can place any man within six miles. I can place him within two miles in London. Sometimes within two streets.",
6
    description: "Bragging about his abilities"
7
  }],
8
  context: {
9
    generationId: selectedGenerationId
10
  },
11
  stripHeaders: true
12
})
13
14
for await (const snippet of stream) {
15
  const buffer = Buffer.from(snippet.audio, "base64")
16
  audioPlayer.stdin.write(buffer)
17
}
18
await audioPlayer.stop()

1
// streaming.ts
2
import WebSocket from "ws";
3
import {SnippetAudioChunk} from "hume/serialization/resources/tts/types/SnippetAudioChunk";
4
import { PublishTts } from "hume/api/resources/tts";
5
6
export class StreamingTtsClient {
7
  private constructor(
8
    private readonly ws: WebSocket,
9
    private readonly queue: Queue<string>
10
  ) { }
11
12
  static async connect(apiKey: string): Promise<StreamingTtsClient> {
13
    if (!apiKey) throw new Error("HUME_API_KEY is not set");
14
15
    const url = `wss://api.hume.ai/v0/tts/stream/input?api_key=${apiKey}&no_binary=true&instant_mode=true&strip_headers=true&format_type=pcm`;
16
    const ws = new WebSocket(url);
17
    const queue = new Queue<string>();
18
19
    ws.onmessage = (event) => {
20
      queue.push(event.data.toString())
21
    };
22
    ws.onclose = (_event) => {
23
      queue.end();
24
    };
25
    ws.onerror = (_error) => {
26
      queue.end();
27
    };
28
29
    await new Promise<void>((resolve, reject) => {
30
      ws.onopen = () => {
31
        resolve();
32
      };
33
      ws.onerror = (e) => {
34
        reject(e);
35
      };
36
    });
37
38
    return new StreamingTtsClient(ws, queue);
39
  }
40
41
  send(message: PublishTts) {
42
    if (this.ws.readyState !== WebSocket.OPEN) throw new Error("WebSocket not connected.");
43
    this.ws.send(JSON.stringify(message));
44
  }
45
46
  disconnect() {
47
    this.ws.close();
48
  }
49
50
  async *[Symbol.asyncIterator]() {
51
    for await (const item of this.queue) {
52
      yield SnippetAudioChunk.parseOrThrow(JSON.parse(item), {
53
        unrecognizedObjectKeys: "passthrough",
54
      });
55
    }
56
  }
57
}
58
59
// Resolves a promise with T, or null to indicate the stream ended.
60
type Resolver<T> = (value: T | null) => void;
61
62
class Queue<T> {
63
  private pushed: T[] = [];
64
  // If non-null, there is a consumer waiting for data, and
65
  // calling `waiting` with a chunk will resolve a promise that
66
  // sends the data to the consumer.
67
  private waiting: Resolver<T> | null = null;
68
  private ended = false;
69
70
  push(x: T) {
71
    if (this.ended) return;
72
    if (this.waiting) {
73
      const w = this.waiting;
74
      this.waiting = null;
75
      w(x);
76
    }
77
    else this.pushed.push(x);
78
  }
79
  end() {
80
    if (this.ended) return;
81
    this.ended = true;
82
    if (this.waiting) { this.waiting(null); this.waiting = null; }
83
  }
84
  async *[Symbol.asyncIterator]() {
85
    while (true) {
86
      if (this.pushed.length) yield this.pushed.shift()!;
87
      else {
88
        const x = await new Promise<T | null>(r => (this.waiting = r));
89
        if (x === null) break;
90
        yield x;
91
      }
92
    }
93
  }
94
}

1
const stream = await StreamingTtsClient.connect(process.env.HUME_API_KEY!);
2
3
// Helper methods for flushing and closing the stream
4
const sendFlush = () => stream.send({ flush: true });
5
const sendClose = () => stream.send({ close: true });
6
7
const voice = { name: "Ava Song", provider: "HUME_AI" } as const;
8
const sendInput = async () => {
9
  stream.send({ text: "Hello world.", voice });
10
  sendFlush();
11
  console.log('Waiting 8 seconds...')
12
  await new Promise(r => setTimeout(r, 8000));
13
  stream.send({ text: "Goodbye, world.", voice });
14
  sendFlush();
15
  sendClose();
16
};

1
const player = startAudioPlayer();
2
const silenceFiller = new SilenceFiller();
3
4
// Pipe silence filler output to audio player stdin
5
silenceFiller.pipe(player.stdin);
6
7
// Handle pipe errors
8
silenceFiller.on('error', (err) => {
9
  console.error("SilenceFiller error:", err);
10
});
11
12
const handleMessages = async () => {
13
  for await (const chunk of stream) {
14
    const buf = Buffer.from(chunk.audio, "base64");
15
    silenceFiller.writeAudio(buf);
16
  }
17
18
  await silenceFiller.endStream();
19
  await player.stop();
20
};
21
22
// Trigger both sending input and receiving audio at the same time.
23
await Promise.all([handleMessages(), sendInput()]);