LiveKit Agents

import { fileURLToPath } from "node:url";
import { cli, defineAgent, ServerOptions, voice } from "@livekit/agents";
import * as openai from "@livekit/agents-plugin-openai";
import { initLogger } from "braintrust";

const logger = initLogger({ projectName: "my-livekit-project" }); // Replace with your project name

export default defineAgent({
  entry: async (ctx) => {
    const session = new voice.AgentSession({
      stt: new openai.STT({ model: "gpt-4o-mini-transcribe", useRealtime: true }),
      llm: new openai.LLM({ model: "gpt-5-mini" }),
      tts: new openai.TTS({ model: "gpt-4o-mini-tts", voice: "alloy" }),
    });

    ctx.addShutdownCallback(async () => {
      await logger.flush();
    });

    await session.start({
      agent: new voice.Agent({
        instructions: "You are a helpful voice AI assistant.",
      }),
      room: ctx.room,
    });
  },
});

cli.runApp(new ServerOptions({ agent: fileURLToPath(import.meta.url) }));

import { configureInstrumentation } from "braintrust/instrumentation";

configureInstrumentation({
  integrations: {
    livekit: {
      audio: {
        codec: { name: "opus", options: { bitrate: 32_000 } },
        container: { name: "ogg" },
      },
    },
  },
});

import { configureInstrumentation } from "braintrust/instrumentation";

configureInstrumentation({ streamingAttachmentBufferBytes: 1024 * 1024 });

import "dotenv/config.js";
import { fileURLToPath } from "url";
import { BraintrustSpanProcessor, setupOtelCompat } from "@braintrust/otel";
import {
  cli,
  defineAgent,
  type JobContext,
  ServerOptions,
  telemetry,
  voice,
} from "@livekit/agents";
import * as openai from "@livekit/agents-plugin-openai";
import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
import { Resource } from "@opentelemetry/resources";
import {
  ATTR_SERVICE_NAME,
  ATTR_SERVICE_VERSION,
} from "@opentelemetry/semantic-conventions";

function setupBraintrustTelemetry() {
  setupOtelCompat();

  const spanProcessor = new BraintrustSpanProcessor({
    apiKey: process.env.BRAINTRUST_API_KEY,
    apiUrl: process.env.BRAINTRUST_API_URL,
    parent: process.env.BRAINTRUST_PARENT,
    filterAISpans: false,
  });

  const provider = new NodeTracerProvider({
    resource: new Resource({
      [ATTR_SERVICE_NAME]: "livekit-agent",
      [ATTR_SERVICE_VERSION]: "1.0.0",
    }),
  });

  provider.addSpanProcessor(spanProcessor);
  provider.register();

  telemetry.setTracerProvider(provider, {
    metadata: {
      component: "livekit-agent",
    },
  });
}

export default defineAgent({
  entry: async (ctx: JobContext): Promise<void> => {
    setupBraintrustTelemetry();

    const session = new voice.AgentSession({
      llm: new openai.realtime.RealtimeModel({
        voice: "coral",
        temperature: 0.8,
      }),
    });

    await session.start({
      agent: new voice.Agent({
        instructions: `You are a helpful and friendly voice AI assistant`,
      }),
      room: ctx.room,
    });

    const greetParticipant = async () => {
      session.say("Hello! I'm your voice assistant. How can I help you today?");
    };

    let greeted = ctx.room.remoteParticipants.size > 0;
    if (greeted) greetParticipant();

    ctx.room.once("participantConnected", () => {
      if (!greeted) {
        greeted = true;
        greetParticipant();
      }
    });

    function waitForRoomDisconnect(room: typeof ctx.room) {
      return new Promise<void>((resolve) => {
        room.once("disconnected", () => resolve());
      });
    }

    await waitForRoomDisconnect(ctx.room);
  },
});

cli.runApp(
  new ServerOptions({
    agent: fileURLToPath(import.meta.url),
  })
);