pnpm add @livekit/agents @livekit/agents-plugin-elevenlabs

ELEVEN_API_KEY=your_elevenlabs_api_key_here

elevenlabs_tts_agent.ts

import { WorkerOptions, JobContext } from "@livekit/agents";
import { voice } from "@livekit/agents";
import { ElevenLabs } from "@livekit/agents-plugin-elevenlabs";

/**
 * Worker that uses only ElevenLabs TTS to synthesize and publish audio.
 * No STT or LLM involved.
 */
export const worker: WorkerOptions = {
  entry: async (ctx: JobContext) => {
    // Connect to the room (ctx.connect() will use job/agent config)
    await ctx.connect();

    // Create an audio source (sampleRate, channels). Match ElevenLabs output sample rate if known.
    // Common choices: 24000 or 44100. Here we use 24000, mono.
    const SAMPLE_RATE = 24000;
    const CHANNELS = 1;
    const audioSource = new voice.AudioSource(SAMPLE_RATE, CHANNELS);

    // Create and publish a local audio track so participants can hear the TTS
    const localTrack = new voice.LocalAudioTrack(audioSource, "eleven-tts-track");
    await ctx.room.localParticipant.publishTrack(localTrack);

    // Initialize ElevenLabs TTS (voice/model optional fields)
    const tts = new ElevenLabs.TTS({
      model: "eleven_multilingual_v2", // adjust if you prefer another model
      voice: { id: "default" },        // replace with a specific voice id if desired
      // You can provide other settings supported by the plugin here
    });

    // Helper: consume async audio frames from the TTS stream and forward to the audio source
    const forwardAudio = async (audioIterable: AsyncIterable<any>) => {
      try {
        for await (const audioChunk of audioIterable) {
          // audioChunk should include audio frame(s) in the plugin's AudioFrame format
          // Capture frame into audio source so it is published to the room
          await audioSource.captureFrame(audioChunk.audio.frame);
        }
      } catch (err) {
        console.error("Error forwarding audio:", err);
      }
    };

    // Function to speak arbitrary text (creates a fresh TTS stream each time)
    const speakText = async (text: string) => {
      const ttsStream = tts.stream();
      // `run()` gives you the async audio iterable produced by the stream
      const audioIterable = ttsStream.run();

      // Start forwarding audio in background
      ctx.task(forwardAudio(audioIterable));

      // Push the text (verbatim) and then end input to finish generation
      await ttsStream.pushText(text);
      await ttsStream.endInput();
    };

    // Example: speak a static phrase immediately
    await speakText("Hello — this audio is relayed using ElevenLabs TTS only.");

    // Optional: listen for data messages from participants to trigger TTS dynamically
    ctx.room.on("data_received", async (packet) => {
      try {
        // Example: expect a data message with topic "tts" and payload as UTF-8 text
        // Adjust parsing based on how you send data messages from clients
        const payload = packet.data; // Buffer
        const topic = (packet as any).topic ?? undefined;
        if (topic === "tts") {
          const inputText = payload.toString("utf8");
          await speakText(inputText);
        }
      } catch (err) {
        console.error("Error handling data message:", err);
      }
    });

    // Keep the worker running (or exit when job ends). ctx will manage lifecycle.
  },
};

AudioSource

voice.id

speakText(...)

speakText

pnpm add @livekit/agents @livekit/agents-plugin-elevenlabs @livekit/rtc

pnpm add

npm install

eleven_tts_dummy_agent.ts

import { WorkerOptions, JobContext } from "@livekit/agents";
import { voice } from "@livekit/agents";
import { ElevenLabs } from "@livekit/agents-plugin-elevenlabs";

/**
 * Worker that:
 *  - Connects/join a room as an agent (dummy participant).
 *  - Keeps the room alive by staying connected.
 *  - Uses ElevenLabs TTS in standalone mode to synthesize a static message.
 *  - Publishes the synthesized audio to the room as a local audio track.
 *
 * No STT or LLM is used.
 */
export const worker: WorkerOptions = {
  entry: async (ctx: JobContext) => {
    // connect to the room (job config provides tokens/room)
    await ctx.connect();

    // Audio settings
    const SAMPLE_RATE = 24000;
    const CHANNELS = 1;

    // Create an audio source and publish it so the room stays alive and participants hear audio
    const audioSource = new voice.AudioSource(SAMPLE_RATE, CHANNELS);
    const localTrack = new voice.LocalAudioTrack(audioSource, "eleven-tts-track");
    await ctx.room.localParticipant.publishTrack(localTrack);

    // Initialize ElevenLabs TTS (standalone)
    const tts = new ElevenLabs.TTS({
      model: "eleven_multilingual_v2",
      // Optionally set a specific voice ID:
      // voice: { id: "your_voice_id" },
    });

    // Helper to forward audio frames from the TTS stream into the LiveKit audio source
    const forwardAudio = async (audioIterable: AsyncIterable<any>) => {
      try {
        for await (const chunk of audioIterable) {
          // The plugin yields audio chunks containing a frame in the plugin's expected format.
          // Capture the frame into the audio source so it is published to the room.
          await audioSource.captureFrame(chunk.audio.frame);
        }
      } catch (err) {
        console.error("forwardAudio error:", err);
      }
    };

    // Function to speak a text string (creates and runs a TTS stream)
    const speakText = async (text: string) => {
      const ttsStream = tts.stream();
      const audioIterable = ttsStream.run();

      // Forward audio asynchronously (non-blocking)
      ctx.task(forwardAudio(audioIterable));

      // Send the text verbatim and end input
      await ttsStream.pushText(text);
      await ttsStream.endInput();
    };

    // Keep the room alive by staying connected.
    // Immediately play a static message once connected:
    await speakText("Hello — this room is kept alive by a dummy participant. This is a static ElevenLabs text-to-speech message.");

    // Optionally keep running and accept further triggers via data messages:
    ctx.room.on("data_received", async (packet) => {
      try {
        const topic = (packet as any).topic ?? undefined;
        // If clients send data messages with topic "tts", the payload is used as text
        if (topic === "tts") {
          const payload = packet.data; // Buffer
          const text = payload.toString("utf8");
          if (text && text.trim().length > 0) {
            await speakText(text);
          }
        }
      } catch (err) {
        console.error("data_received handler error:", err);
      }
    });

    // The worker remains connected; ctx lifecycle controls shutdown.
  },
};

AudioSource

ElevenLabs.TTS.stream()

.run()

audioSource.captureFrame(...)

eleven_tts_5min_agent.ts

import { WorkerOptions, JobContext } from "@livekit/agents";
import { voice } from "@livekit/agents";
import { ElevenLabs } from "@livekit/agents-plugin-elevenlabs";

const ROOM_LIFETIME_MS = 5 * 60 * 1000; // 5 minutes

export const worker: WorkerOptions = {
  entry: async (ctx: JobContext) => {
    // Connect to the room (ctx.connect() uses job config)
    await ctx.connect();

    // Audio source settings
    const SAMPLE_RATE = 24000;
    const CHANNELS = 1;

    // Create audio source and publish track so the room stays alive
    const audioSource = new voice.AudioSource(SAMPLE_RATE, CHANNELS);
    const localTrack = new voice.LocalAudioTrack(audioSource, "eleven-tts-track");
    await ctx.room.localParticipant.publishTrack(localTrack);

    // Initialize ElevenLabs TTS
    const tts = new ElevenLabs.TTS({
      model: "eleven_multilingual_v2",
      // voice: { id: "your_voice_id" },
    });

    // Forward audio frames into the audio source
    const forwardAudio = async (audioIterable: AsyncIterable<any>) => {
      try {
        for await (const chunk of audioIterable) {
          await audioSource.captureFrame(chunk.audio.frame);
        }
      } catch (err) {
        console.error("forwardAudio error:", err);
      }
    };

    // Track whether we're still allowed to speak (stop after timeout)
    let active = true;

    // Speak text helper
    const speakText = async (text: string) => {
      if (!active) return;
      const ttsStream = tts.stream();
      const audioIterable = ttsStream.run();
      ctx.task(forwardAudio(audioIterable));
      await ttsStream.pushText(text);
      await ttsStream.endInput();
    };

    // Play static message immediately
    await speakText("Hello — this room will remain active for five minutes while this dummy participant is connected.");

    // Optionally accept data messages to trigger additional TTS while active
    ctx.room.on("data_received", async (packet) => {
      try {
        const topic = (packet as any).topic ?? undefined;
        if (!active) return;
        if (topic === "tts") {
          const payload = packet.data;
          const inputText = payload.toString("utf8");
          if (inputText && inputText.trim().length > 0) {
            await speakText(inputText);
          }
        }
      } catch (err) {
        console.error("data_received handler error:", err);
      }
    });

    // Schedule shutdown after ROOM_LIFETIME_MS
    setTimeout(async () => {
      try {
        active = false; // stop handling further speak requests
        // Unpublish the track and disconnect gracefully
        try {
          await ctx.room.localParticipant.unpublishTrack(localTrack);
        } catch (e) {
          console.warn("unpublishTrack error:", e);
        }
        // Allow small delay to flush any last frames
        await new Promise((res) => setTimeout(res, 500));
        await ctx.disconnect();
      } catch (err) {
        console.error("Error during graceful shutdown:", err);
      }
    }, ROOM_LIFETIME_MS);

    // Keep worker alive for job lifecycle; ctx manages termination.
  },
};

active = false