livekit-server-sdk

@livekit/components-react

livekit-client

google.realtime.RealtimeModel

egress_ended

google.realtime.RealtimeModel

GOOGLE_APPLICATION_CREDENTIALS

import { NextApiRequest, NextApiResponse } from 'next';
import { AccessToken, VideoGrant } from 'livekit-server-sdk';

export default function handler(req: NextApiRequest, res: NextApiResponse) {
  const identity = req.query.identity as string || `user-${Math.random().toString(36).slice(2,8)}`;
  const roomName = req.query.room as string || 'interview-room';
  const apiKey = process.env.NEXT_PUBLIC_LIVEKIT_API_KEY!;
  const apiSecret = process.env.NEXT_PUBLIC_LIVEKIT_API_SECRET!;

  const at = new AccessToken(apiKey, apiSecret, { identity });
  const grant: VideoGrant = { roomJoin: true, room: roomName, canPublish: true, canSubscribe: true };
  at.addGrant(grant);
  at.ttl = '10m';

  res.status(200).json({ token: at.toJwt(), wsUrl: process.env.NEXT_PUBLIC_LIVEKIT_URL });
}

'use client';
import React, { useEffect, useState } from 'react';
import { connect, Room } from 'livekit-client';

export default function RoomComponent({ token, serverUrl }: { token: string; serverUrl: string; }) {
  const [room, setRoom] = useState<Room | null>(null);

  useEffect(() => {
    let r: Room;
    (async () => {
      r = await connect(serverUrl, token, { autoSubscribe: true });
      setRoom(r);
      const pc = await navigator.mediaDevices.getUserMedia({ audio: true });
      await r.localParticipant.publishTrack(pc.getAudioTracks()[0]);
      // DataChannel example:
      r.dataChannels.open('app');
      r.dataChannels.on('message', (data, participant) => {
        // handle incoming JSON messages
      });
    })();

    return () => { r?.disconnect(); };
  }, [token, serverUrl]);

  return <div>{room ? <p>Connected</p> : <p>Connecting…</p>}</div>;
}

import { createClient } from '@supabase/supabase-js';
export const supabase = createClient(process.env.NEXT_PUBLIC_SUPABASE_URL!, process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!);

import { RoomServiceClient } from 'livekit-server-sdk';
export function createRoomClient() {
  return new RoomServiceClient(process.env.LIVEKIT_URL!, process.env.LIVEKIT_API_KEY!, process.env.LIVEKIT_API_SECRET!);
}

import { createClient } from '@supabase/supabase-js';
export const supabase = createClient(process.env.SUPABASE_URL!, process.env.SUPABASE_SERVICE_ROLE_KEY!);

import { AgentSession } from '@livekit/agents';
import * as google from '@livekit/agents-plugin-google';
import IORedis from 'ioredis';
import { supabase } from './supabaseClient';

const redis = new IORedis(process.env.REDIS_URL);

export async function startAgent() {
  const session = new AgentSession({
    llm: new google.realtime.RealtimeModel({
      model: 'gemini-2.5-flash-native-audio-preview-09-2025', // pick model available to you
      voice: 'Puck',
      instructions: 'You are a professional interviewer. Ask the candidate questions and wait for answers.',
      apiKey: process.env.GOOGLE_API_KEY,
    }),
    stt: 'google/speech-to-text',
    tts: 'google/text-to-speech',
  });

  session.on('turn_end', async (ev) => {
    const roomId = ev.room;
    const partial = await session.getTranscript(); // pseudo-method; use session APIs to fetch transcript
    await redis.set(`interview:${roomId}:partial`, JSON.stringify(partial));
  });

  session.on('session_end', async (ev) => {
    const roomId = ev.room;
    const full = await session.getFinalTranscript(); // pseudo-method
    await supabase.from('interviews').insert({ room_id: roomId, transcript: full });
  });

  // start listening for rooms / connect session to LiveKit; actual hook depends on Agents framework entry points
}

import 'dotenv/config';
import { startAgent } from './agent';
startAgent().catch(err => { console.error(err); process.exit(1); });

// app/api/token/route.ts (Next.js App Router)
import { NextRequest, NextResponse } from 'next/server';
import { AccessToken, VideoGrant } from 'livekit-server-sdk';

export async function GET(req: NextRequest) {
  const url = new URL(req.url);
  const identity = url.searchParams.get('identity') || `user-${Math.random().toString(36).slice(2,8)}`;
  const room = url.searchParams.get('room') || 'interview-room';

  const apiKey = process.env.LIVEKIT_API_KEY!;
  const apiSecret = process.env.LIVEKIT_API_SECRET!;
  const wsUrl = process.env.NEXT_PUBLIC_LIVEKIT_URL!;

  const at = new AccessToken(apiKey, apiSecret, { identity });
  const grant: VideoGrant = { roomJoin: true, room, canPublish: true, canSubscribe: true };
  at.addGrant(grant);
  at.ttl = '10m';

  return NextResponse.json({ token: at.toJwt(), wsUrl });
}

'use client';
import React, { useEffect, useState } from 'react';
import { connect, Room } from 'livekit-client';

export default function RoomClient({ roomName = 'interview-room' }: { roomName?: string }) {
  const [status, setStatus] = useState('idle');

  useEffect(() => {
    let room: Room | undefined;
    (async () => {
      setStatus('fetching-token');
      const res = await fetch(`/api/token?room=${roomName}`);
      const { token, wsUrl } = await res.json();
      setStatus('connecting');
      room = await connect(wsUrl, token, { autoSubscribe: true });
      setStatus('connected');

      // publish mic
      try {
        const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
        await room.localParticipant.publishTrack(stream.getAudioTracks()[0]);
      } catch (e) {
        console.error('mic error', e);
      }

      // example data channel usage
      room.dataChannels.open('app');
      room.dataChannels.on('message', (data, participant) => {
        try {
          const json = JSON.parse(new TextDecoder().decode(data as ArrayBuffer));
          console.log('data message', json);
        } catch {
          console.log('message', data);
        }
      });
    })();

    return () => { room?.disconnect(); };
  }, [roomName]);

  return <div>LiveKit: {status}</div>;
}

import { createClient } from '@supabase/supabase-js';
export const supabase = createClient(process.env.NEXT_PUBLIC_SUPABASE_URL!, process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!);

import RoomClient from './RoomClient';
export default function Page() {
  return (
    <main>
      <h1>Interview Room</h1>
      <RoomClient roomName="interview-room" />
    </main>
  );
}

{
  "name": "agent",
  "private": true,
  "scripts": {
    "dev": "ts-node-dev --respawn --transpile-only src/index.ts"
  }
}

import { createClient } from '@supabase/supabase-js';
export const supabase = createClient(process.env.SUPABASE_URL!, process.env.SUPABASE_SERVICE_ROLE_KEY!);

import 'dotenv/config';
import { AgentSession } from '@livekit/agents';
import * as google from '@livekit/agents-plugin-google';
import IORedis from 'ioredis';
import { supabase } from './supabaseClient';

const redis = new IORedis(process.env.REDIS_URL);

async function start() {
  const session = new AgentSession({
    llm: new google.realtime.RealtimeModel({
      model: 'gemini-2.5-flash-native-audio-preview-09-2025',
      voice: 'Puck',
      instructions: 'You are a professional interviewer. Ask clear technical questions and wait for responses.',
      apiKey: process.env.GOOGLE_API_KEY,
    }),
    stt: 'google/speech-to-text',
    tts: 'google/text-to-speech',
  });

  // Hook onto session events (pseudo-API names; adapt if needed)
  session.on('turn_end', async (ev: any) => {
    const { room } = ev;
    const partial = await session.getTranscript?.() || null;
    await redis.set(`interview:${room}:partial`, JSON.stringify(partial));
  });

  session.on('session_end', async (ev: any) => {
    const { room } = ev;
    const final = await session.getFinalTranscript?.() || null;
    await supabase.from('interviews').insert({ room_id: room, transcript: final });
    await redis.del(`interview:${room}:partial`);
  });

  // Start listening / connect agent to LiveKit rooms automatically if using Agents framework runner
  await session.listen(); // if available in your installed @livekit/agents version
  console.log('Agent started');
}

start().catch((err) => { console.error(err); process.exit(1); });

session.listen()

interview:{roomId}:partial

interview:{roomId}:turn

import { createClient } from '@supabase/supabase-js';
export const supabase = createClient(process.env.SUPABASE_URL!, process.env.SUPABASE_SERVICE_ROLE_KEY!);

import IORedis from 'ioredis';
export const redis = new IORedis(process.env.REDIS_URL);

import { AgentSession } from '@livekit/agents';
import * as google from '@livekit/agents-plugin-google';
import { supabase } from './supabaseClient';
import { redis } from './redisClient';

export async function startAgent() {
  const session = new AgentSession({
    llm: new google.realtime.RealtimeModel({
      model: 'gemini-2.5-flash-native-audio-preview-09-2025',
      voice: 'Puck',
      apiKey: process.env.GOOGLE_API_KEY,
      instructions: 'You are a professional interviewer.',
    }),
    stt: 'google/speech-to-text',
    tts: 'google/text-to-speech',
  });

  session.on('turn_end', async (ev: any) => {
    const room = ev.room;
    const partial = await session.getTranscript?.() || null;
    await redis.set(`interview:${room}:partial`, JSON.stringify(partial));
  });

  session.on('session_end', async (ev: any) => {
    const room = ev.room;
    const final = await session.getFinalTranscript?.() || null;
    await supabase.from('interviews').insert({ room_id: room, transcript: final });
    await redis.del(`interview:${room}:partial`);
  });

  // start listening/attach to LiveKit rooms — use agent framework runner or session.listen() if available
  await session.listen?.();
  console.log('Agent started');
}

import 'dotenv/config';
import { startAgent } from './agent';
startAgent().catch(e => { console.error(e); process.exit(1); });

"scripts": {
  "dev": "next dev",
  "build": "next build",
  "start": "next start",
  "agent:dev": "ts-node-dev --respawn --transpile-only agent/index.ts"
}

import 'dotenv/config';
import { startAgentProcess } from './agent';

async function main() {
  try {
    await startAgentProcess();
    console.log('Agent process started');
  } catch (err) {
    console.error('Agent failed to start', err);
    process.exit(1);
  }
}

main();

import { createClient } from '@supabase/supabase-js';

const SUPABASE_URL = process.env.SUPABASE_URL!;
const SUPABASE_SERVICE_ROLE_KEY = process.env.SUPABASE_SERVICE_ROLE_KEY!;

export const supabase = createClient(SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY);

import Redis from 'ioredis';

const redis = new Redis(process.env.REDIS_URL || '<redis://localhost:6379>');

redis.on('connect', () => console.log('Redis connected'));
redis.on('error', (e) => console.error('Redis error', e));

export { redis };

import { AgentSession } from '@livekit/agents';
import * as google from '@livekit/agents-plugin-google';
import { supabase } from './supabaseClient';
import { redis } from './redisClient';

/**
 * Simple Interview Agent runner that:
 * - uses Gemini Live (via @livekit/agents-plugin-google)
 * - saves ephemeral context to Redis
 * - persists responses and session metadata to Supabase
 *
 * Note: adapt event names and methods to the exact @livekit/agents version if necessary.
 */

export async function startAgentProcess() {
  const session = new AgentSession({
    llm: new google.realtime.RealtimeModel({
      model: 'gemini-2.0-flash-exp',
      voice: 'Puck',
      temperature: 0.7,
      instructions: `You are an AI interviewer. Ask one question at a time, wait for the candidate's complete answer, ask brief follow-ups if needed, be professional and encouraging.`,
      apiKey: process.env.GOOGLE_API_KEY,
    }),
    stt: 'google/speech-to-text',
    tts: 'google/text-to-speech',
  });

  // When agent commits speech (agent spoke)
  session.on('agent_speech_committed', async (ev: any) => {
    try {
      const room = ev.room ?? ev.roomName ?? ev.roomId;
      const text = ev.transcript ?? ev.text ?? null;
      if (!room || !text) return;
      const key = `interview:${room}:responses`;
      await redis.lpush(key, JSON.stringify({ type: 'agent', text, ts: Date.now() }));
      await redis.expire(key, 3600);
    } catch (e) { console.error('agent_speech_committed handler error', e); }
  });

  // When candidate/user speech is committed (user finished speaking)
  session.on('user_speech_committed', async (ev: any) => {
    try {
      const room = ev.room ?? ev.roomName ?? ev.roomId;
      const text = ev.transcript ?? ev.text ?? null;
      if (!room || !text) return;

      // push to Redis
      const key = `interview:${room}:responses`;
      await redis.lpush(key, JSON.stringify({ type: 'candidate', text, ts: Date.now() }));
      await redis.expire(key, 3600);

      // persist to Supabase (simple schema)
      await supabase.from('interview_responses').insert({
        room_id: room,
        response: text,
        created_at: new Date().toISOString(),
      });

      // optional: basic follow-up logic (word count)
      const wordCount = text.trim().split(/\s+/).length;
      if (wordCount < 8) {
        await session.say('Thanks — could you elaborate a bit more on that?');
      } else {
        // move to next question (simple placeholder)
        await session.say('Great. Next question: Tell me about a challenging project you worked on.');
      }
    } catch (e) { console.error('user_speech_committed handler error', e); }
  });

  // session end or cleanup hook (event name may vary)
  session.on('session_end', async (ev: any) => {
    try {
      const room = ev.room ?? ev.roomName ?? ev.roomId;
      if (!room) return;
      const key = `interview:${room}:responses`;
      const items = await redis.lrange(key, 0, -1);
      const transcript = items.map((i) => JSON.parse(i)).reverse().map((r: any) => `${r.type}: ${r.text}`).join('\n');
      await supabase.from('interviews').insert({
        room_id: room,
        transcript,
        created_at: new Date().toISOString(),
      });
      await redis.del(key);
    } catch (e) { console.error('session_end handler error', e); }
  });

  // Start listening for rooms/requests. The actual startup depends on @livekit/agents runner usage.
  // If your version supports session.listen() or a runner, call it. Otherwise the package's CLI might be used.
  if (typeof (session as any).listen === 'function') {
    await (session as any).listen();
    console.log('AgentSession listening');
  } else {
    console.log('AgentSession ready (no listen method detected). Ensure your @livekit/agents usage starts sessions appropriately.');
  }
}

import { NextRequest, NextResponse } from 'next/server';
import { AccessToken, VideoGrant } from 'livekit-server-sdk';

export async function GET(req: NextRequest) {
  try {
    const url = new URL(req.url);
    const identity = url.searchParams.get('identity') || `user-${Math.random().toString(36).slice(2,8)}`;
    const room = url.searchParams.get('room') || 'interview-room';

    const apiKey = process.env.LIVEKIT_API_KEY!;
    const apiSecret = process.env.LIVEKIT_API_SECRET!;
    const wsUrl = process.env.NEXT_PUBLIC_LIVEKIT_URL!;

    const at = new AccessToken(apiKey, apiSecret, { identity });
    const grant: VideoGrant = { roomJoin: true, room, canPublish: true, canSubscribe: true };
    at.addGrant(grant);
    at.ttl = '10m';
    return NextResponse.json({ token: at.toJwt(), wsUrl });
  } catch (err) {
    console.error('token route error', err);
    return NextResponse.json({ error: 'token generation failed' }, { status: 500 });
  }
}

'use client';
import React, { useEffect, useState } from 'react';
import { connect, Room } from 'livekit-client';

export default function RoomClient({ roomName = 'interview-room' }: { roomName?: string }) {
  const [status, setStatus] = useState('idle');

  useEffect(() => {
    let room: Room | undefined;
    (async () => {
      setStatus('fetching token');
      const res = await fetch(`/api/token?room=${roomName}`);
      const json = await res.json();
      const { token, wsUrl } = json;
      setStatus('connecting');
      room = await connect(wsUrl, token, { autoSubscribe: true });
      setStatus('connected');

      try {
        const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
        await room.localParticipant.publishTrack(stream.getAudioTracks()[0]);
      } catch (e) {
        console.error('microphone error', e);
      }

      room.dataChannels.open('app');
      room.dataChannels.on('message', (data, participant) => {
        try {
          const text = typeof data === 'string' ? data : new TextDecoder().decode(data as ArrayBuffer);
          console.log('data channel message', text);
        } catch { console.log('raw data', data); }
      });
    })();

    return () => { room?.disconnect(); };
  }, [roomName]);

  return <div>Interview Room — status: {status}</div>;
}

import { createClient } from '@supabase/supabase-js';
export const supabase = createClient(process.env.NEXT_PUBLIC_SUPABASE_URL!, process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!);

create table if not exists interviews (
  id uuid primary key default gen_random_uuid(),
  room_id text,
  transcript text,
  created_at timestamptz default now()
);

create table if not exists interview_responses (
  id uuid primary key default gen_random_uuid(),
  room_id text,
  response text,
  created_at timestamptz default now()
);

as any

{
  "name": "smart_resume",
  "version": "0.1.0",
  "private": true,
  "scripts": {
    "dev": "next dev",
    "build": "prisma generate && next build",
    "start": "next start",
    "lint": "eslint",
    "postinstall": "prisma generate",
    "agent:dev": "ts-node-dev --respawn --transpile-only agent/index.ts"
  },
  "dependencies": {
    "@ai-sdk/google": "^2.0.29",
    "@livekit/agents": "^1.0.27",
    "@livekit/agents-plugin-google": "^1.0.27",
    "@livekit/components-react": "^2.9.17",
    "@openai/agents": "^0.3.0",
    "@prisma/client": "^6.19.0",
    "@qdrant/js-client-rest": "^1.15.1",
    "@supabase/ssr": "^0.7.0",
    "@supabase/supabase-js": "^2.81.1",
    "@upstash/redis": "^1.35.6",
    "ai": "^5.0.89",
    "date-fns": "^4.1.0",
    "dotenv": "^17.2.3",
    "livekit-client": "^2.16.1",
    "livekit-server-sdk": "^2.15.0",
    "lucide-react": "^0.553.0",
    "next": "^15.5.7",
    "openai": "^6.8.1",
    "pdf-lib": "^1.17.1",
    "pdf-parse": "^2.4.5",
    "prisma": "^6.19.0",
    "react": "^19.2.1",
    "react-dom": "^19.2.1",
    "react-markdown": "^10.1.0",
    "recharts": "^3.4.1",
    "redis": "^5.9.0",
    "zod": "^3.25.76"
  },
  "devDependencies": {
    "@tailwindcss/postcss": "^4",
    "@types/node": "^20",
    "@types/react": "^19",
    "@types/react-dom": "^19",
    "eslint": "^9",
    "eslint-config-next": "16.0.1",
    "tailwindcss": "^4",
    "typescript": "^5"
  }
}

Room

voice.AgentSession

// app/api/token/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { AccessToken, VideoGrant } from 'livekit-server-sdk';

export async function GET(req: NextRequest) {
  try {
    const url = new URL(req.url);
    const identity = url.searchParams.get('identity') || `user-${Math.random().toString(36).slice(2,8)}`;
    const room = url.searchParams.get('room') || 'interview-room';

    const apiKey = process.env.LIVEKIT_API_KEY!;
    const apiSecret = process.env.LIVEKIT_API_SECRET!;
    const wsUrl = process.env.NEXT_PUBLIC_LIVEKIT_URL!;

    const at = new AccessToken(apiKey, apiSecret, { identity });
    const grant: VideoGrant = { roomJoin: true, room, canPublish: true, canSubscribe: true };
    at.addGrant(grant);
    at.ttl = '10m';

    return NextResponse.json({ token: at.toJwt(), wsUrl });
  } catch (err) {
    console.error('token route error', err);
    return NextResponse.json({ error: 'token generation failed' }, { status: 500 });
  }
}

'use client';
import React, { useEffect, useRef, useState } from 'react';
import { Room } from 'livekit-client';

export default function RoomClient({ roomName = 'interview-room' }: { roomName?: string }) {
  const roomRef = useRef<Room | null>(null);
  const [status, setStatus] = useState('idle');

  useEffect(() => {
    let cancelled = false;
    (async () => {
      try {
        setStatus('fetching token');
        const res = await fetch(`/api/token?room=${roomName}`);
        const json = await res.json();
        const { token, wsUrl } = json;
        if (cancelled) return;

        setStatus('creating room');
        const room = new Room();
        roomRef.current = room;

        // connect is instance method
        await room.connect(wsUrl, token);
        setStatus('connected');

        // publish microphone
        try {
          const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
          const track = stream.getAudioTracks()[0];
          await room.localParticipant.publishTrack(track);
        } catch (e) {
          console.warn('microphone publish failed', e);
        }

        // data channel example
        room.dataChannels.open('app');
        room.dataChannels.on('message', (data) => {
          const text = typeof data === 'string' ? data : new TextDecoder().decode(data as ArrayBuffer);
          console.log('data message', text);
        });
      } catch (e) {
        console.error(e);
        setStatus('error');
      }
    })();

    return () => {
      cancelled = true;
      roomRef.current?.disconnect();
    };
  }, [roomName]);

  return <div>Interview Room — status: {status}</div>;
}

// agent/index.ts
import 'dotenv/config';
import { defineAgent, JobContext } from '@livekit/agents';
import * as google from '@livekit/agents-plugin-google';
import { supabase } from './supabaseClient';
import { redis } from './redisClient';

export default defineAgent({
  entry: async (ctx: JobContext) => {
    // connect context room if not already connected by runner
    // create AgentSession from the room context
    const AgentSession = (ctx.room as any).AgentSession || (await import('@livekit/agents')).voice?.AgentSession;
    if (!AgentSession) throw new Error('AgentSession not available on context.room');

    const session = new AgentSession({
      llm: new google.realtime.RealtimeModel({
        model: 'gemini-2.5-flash-native-audio-preview-09-2025',
        voice: 'Puck',
        temperature: 0.7,
        instructions: 'You are an AI interviewer. Ask one question at a time, wait for full answers.',
        apiKey: process.env.GOOGLE_API_KEY,
      }),
      stt: 'google/speech-to-text',
      tts: 'google/text-to-speech',
    });

    // basic handlers
    session.on?.('user_speech_committed', async (ev: any) => {
      const room = ev.room ?? ev.roomName ?? ctx.room.name;
      const text = ev.transcript ?? ev.text ?? '';
      if (!text) return;
      await redis.lpush(`interview:${room}:responses`, JSON.stringify({ type: 'candidate', text, ts: Date.now() }));
      await redis.expire(`interview:${room}:responses`, 3600);
      await supabase.from('interview_responses').insert({ room_id: room, response: text, created_at: new Date().toISOString() });
      const words = text.trim().split(/\s+/).length;
      if (words < 8) await session.say('Could you elaborate a bit more on that?');
      else await session.say('Thanks — next question: Describe a challenging project you worked on.');
    });

    session.on?.('agent_speech_committed', async (ev: any) => {
      const room = ev.room ?? ev.roomName ?? ctx.room.name;
      const text = ev.transcript ?? ev.text ?? '';
      if (!text) return;
      await redis.lpush(`interview:${room}:responses`, JSON.stringify({ type: 'agent', text, ts: Date.now() }));
      await redis.expire(`interview:${room}:responses`, 3600);
    });

    session.on?.('session_end', async (ev: any) => {
      const room = ev.room ?? ev.roomName ?? ctx.room.name;
      const items = await redis.lrange(`interview:${room}:responses`, 0, -1);
      const transcript = items.reverse().map(i => JSON.parse(i)).map((r: any) => `${r.type}: ${r.text}`).join('\n');
      await supabase.from('interviews').insert({ room_id: room, transcript, created_at: new Date().toISOString() });
      await redis.del(`interview:${room}:responses`);
    });

    await session.start?.({ room: ctx.room });
  },
});

// agent/supabaseClient.ts
import { createClient } from '@supabase/supabase-js';
export const supabase = createClient(process.env.SUPABASE_URL!, process.env.SUPABASE_SERVICE_ROLE_KEY!);

// agent/redisClient.ts
import Redis from 'ioredis';
export const redis = new Redis(process.env.REDIS_URL || '<redis://localhost:6379>');
redis.on('connect', () => console.log('Redis connected'));
redis.on('error', (e) => console.error('Redis error', e));

smart_resume@0.1.0 agent:dev /Users/prathammungekar/Git Repo/smart_resume

ts-node-dev --respawn --transpile-only livekitagent/index.ts

ts-node-dev

➜  smart_resume git:(main) ✗ pnpm run agent:dev

> smart_resume@0.1.0 agent:dev /Users/prathammungekar/Git Repo/smart_resume
> ts-node-dev -r tsconfig-paths/register --respawn --transpile-only livekitagent/index.ts

[INFO] 16:36:00 ts-node-dev ver. 2.0.0 (using ts-node ver. 10.9.2, typescript ver. 5.9.3)
Error: Cannot find module '/Users/prathammungekar/Git Repo/smart_resume/livekitagent/agent.js' imported from /Users/prathammungekar/Git Repo/smart_resume/livekitagent/index.ts
    at finalizeResolution (node:internal/modules/esm/resolve:274:11)
    at moduleResolve (node:internal/modules/esm/resolve:864:10)
    at defaultResolve (node:internal/modules/esm/resolve:990:11)
    at ModuleLoader.#cachedDefaultResolve (node:internal/modules/esm/loader:757:20)
    at ModuleLoader.#resolveAndMaybeBlockOnLoaderThread (node:internal/modules/esm/loader:793:38)
    at ModuleLoader.resolveSync (node:internal/modules/esm/loader:816:52)
    at ModuleLoader.#cachedResolveSync (node:internal/modules/esm/loader:776:25)
    at ModuleLoader.getModuleJobForRequire (node:internal/modules/esm/loader:474:50)
    at ModuleJobSync.#link (node:internal/modules/esm/module_job:447:34)
    at new ModuleJobSync (node:internal/modules/esm/module_job:420:17)
[ERROR] 16:36:00 Error: Cannot find module '/Users/prathammungekar/Git Repo/smart_resume/livekitagent/agent.js' imported from /Users/prathammungekar/Git Repo/smart_resume/livekitagent/index.ts

.ts

--esm

import { startAgent } from './agent.js';

{
  "compilerOptions": {
    "module": "CommonJS",
    "moduleResolution": "node",
    "esModuleInterop": true,
    "allowSyntheticDefaultImports": true,
    "resolveJsonModule": true,
    "outDir": "dist"
  }
}

--esm

import { startAgent } from './agent';

--esm

.js

--esm

--esm

--esm

<https://vertex-ai-1879pkoh.livekit.cloud/settings/regions>

<https://vertex-ai-1879pkoh.livekit.cloud/rtc/validate?access_token=>

kid

exp

grants

roomJoin: true

room

import 'dotenv/config';
import { NextRequest, NextResponse } from 'next/server';
import { AccessToken, VideoGrant } from 'livekit-server-sdk';

export async function GET(req: NextRequest) {
  try {
    const url = new URL(req.url);
    const identity = url.searchParams.get('identity') || `user-${Math.random().toString(36).slice(2,8)}`;
    const room = url.searchParams.get('room') || 'interview-room';

    const apiKey = process.env.LIVEKIT_API_KEY!;
    const apiSecret = process.env.LIVEKIT_API_SECRET!;
    const wsUrl = process.env.LIVEKIT_URL!;
    console.log("🚀 ~ GET ~ wsUrl:", wsUrl,apiKey, apiSecret)

    const at = new AccessToken(apiKey, apiSecret, { identity });
    const grant: VideoGrant = { roomJoin: true, room, canPublish: true, canSubscribe: true };
    at.addGrant(grant);
    at.ttl = '10m';

    console.log("🚀 ~ GET ~ at:", at)
    return NextResponse.json({ token: at.toJwt(), wsUrl });
  } catch (err) {
    console.error('token route error', err);
    return NextResponse.json({ error: 'token generation failed' }, { status: 500 });
  }
}

wsUrl

token

import 'dotenv/config';
import { NextRequest, NextResponse } from 'next/server';
import { AccessToken, VideoGrant } from 'livekit-server-sdk';

export async function GET(req: NextRequest) {
  try {
    const url = new URL(req.url);
    const identity = url.searchParams.get('identity') || `user-${Math.random().toString(36).slice(2,8)}`;
    const room = url.searchParams.get('room') || 'interview-room';

    const apiKey = process.env.LIVEKIT_API_KEY;
    const apiSecret = process.env.LIVEKIT_API_SECRET;
    const wsUrl = process.env.LIVEKIT_URL;

    if (!apiKey || !apiSecret || !wsUrl) {
      console.error('Missing LiveKit env vars', { apiKey: !!apiKey, apiSecret: !!apiSecret, wsUrl: !!wsUrl });
      return NextResponse.json({ error: 'server configuration error' }, { status: 500 });
    }

    const at = new AccessToken(apiKey, apiSecret, { identity });
    const grant: VideoGrant = { roomJoin: true, room, canPublish: true, canSubscribe: true };
    at.addGrant(grant);
    at.ttl = 600; // seconds

    const jwt = at.toJwt();
    if (!jwt) {
      console.error('AccessToken.toJwt() returned falsy');
      return NextResponse.json({ error: 'token generation failed' }, { status: 500 });
    }

    return NextResponse.json({ token: jwt, wsUrl });
  } catch (err) {
    console.error('token route error', err);
    return NextResponse.json({ error: 'token generation failed' }, { status: 500 });
  }
}

token

wsUrl

token

~ GET ~ at: AccessToken {
  apiKey: 'API6ioefkASKxwA',
  apiSecret: 'HiJgjL2ekf6l9ynzd5rIMm5dhiuiF4oP2PVp2Zp7coG',
  grants: {
    video: {
      roomJoin: true,
      room: 'interview-room',
      canPublish: true,
      canSubscribe: true
    }
  },
  identity: 'user-8ig6rc',
  ttl: 600
}