import livekit.proto.RoomConfiguration;
import livekit.proto.RoomAgentDispatch;

<dependency>
    <groupId>io.livekit</groupId>
    <artifactId>livekit-server</artifactId>
    <version>${io.livekit.version}</version>
</dependency>

io.livekit:livekit-protocol:0.10.1

livekit-protocol

io.livekit:server-sdk-java

livekit.proto.*

protoc

<repository>
    <id><http://jitpack.io|jitpack.io></id>
    <url><https://jitpack.io></url>
  </repository>

package com.oneassist.jcm.proxy.livekit;

import com.oneassist.jcm.api.dto.response.VoiceAccessTokenResponseDto;
import io.livekit.server.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ResponseStatusException;

import java.security.SecureRandom;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CompletableFuture;

/**
 * Spring Boot Application and REST Controller for generating LiveKit Tokens.
 * To run:
 * 1. Ensure the required Maven dependencies (livekit-server-sdk, spring-boot-starter-web) are included.
 * 2. Set environment variables: LIVEKIT_URL, LIVEKIT_API_KEY, LIVEKIT_API_SECRET.
 * 3. Run the main method: mvn spring-boot:run
 */
@Component
@Slf4j
public class LivekitProxy {

    @Value("${livekit_api_key}")
    private String apiKey;

    @Value("${livekit_api_secret}")
    private String apiSecret;

    @Value("${livekit_url}")
    private String livekitUrl;

    private static final Set<String> VALID_LANGUAGES = Set.of(
            "hi-IN", "en-IN", "bn-IN", "gu-IN", "kn-IN", "ml-IN", "mr-IN", "or-IN", "pa-IN", "ta-IN", "te-IN"
    );

    private static final String DEFAULT_LANGUAGE = "hi-IN";
    private static final String DEFAULT_VOICE = "anushka";

    private final SecureRandom random = new SecureRandom();


    public VoiceAccessTokenResponseDto generateLivekitToken(Integer chatId, String name) {

        try {
            final String language =DEFAULT_LANGUAGE;
            final String voice = DEFAULT_VOICE;

            String roomBase = "conversation-ai-" + generateRandomHex(8);

            boolean hasSuffix = false;
            for (String lang : VALID_LANGUAGES) {
                if (roomBase.contains("-" + lang) || roomBase.endsWith("-" + lang)) {
                    hasSuffix = true;
                    break;
                }
            }

            String roomName;
            if (!hasSuffix) {
                if (chatId != null && chatId!=0) {
                    roomName = String.format("%s-%s-%s-%s", roomBase, chatId, language, voice);
                } else {
                    roomName = String.format("%s-%s-%s", roomBase, language, voice);
                }
            } else {
                roomName = roomBase;
            }

            String participantName = name != null && !name.isEmpty()
                    ? name
                    : "user-" + generateRandomHex(4);

            <http://log.info|log.info>("Generating token for participant: {} in room: {} (language: {}, voice: {}, chat_id: {})", participantName, roomName, language, voice, chatId);

            AccessToken token = new AccessToken(apiKey, apiSecret);
            token.setTtl(600);
            token.setIdentity(participantName);
            token.setName(participantName);

            token.addGrants(
                new RoomJoin(true),
                new Room(roomName),
                new CanPublish(true),
                new CanSubscribe(true),
                new CanPublishData(true)
            );

            // Dispatch agent explicitly using LiveKit API
            // The agent is registered with agent_name="voice-assistant" in agent.py
            // We dispatch the agent to the room asynchronously after token generation
            dispatchAgentToRoom(roomName, language, voice, chatId, participantName);

            String jwt = token.toJwt();

            // 5. Prepare response (convert URL to wss/https if needed)
            String safeUrl = livekitUrl.replace("ws://", "wss://").replace("http://", "https://");

            VoiceAccessTokenResponseDto responseDto = VoiceAccessTokenResponseDto.builder().authToken(jwt).wssUrl(safeUrl).roomName(roomName).language(language).voice(voice).build();

            if (chatId != null && chatId!=0) {
                responseDto.setChatId(chatId);
            }

            <http://log.info|log.info>("Token generated successfully for room: {}", roomName);
            return responseDto;

        } catch (Exception e) {
            log.error("Exception while generating token," , e);
            throw new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, "Failed to generate token: " + e.getMessage());
        }
    }

    private String generateRandomHex(int length) {
        byte[] bytes = new byte[length];
        random.nextBytes(bytes);
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }

    /**
     * Dispatch the voice-assistant agent to the specified room using LiveKit API
     * This is called asynchronously to avoid blocking token generation
     */
    private void dispatchAgentToRoom(String roomName, String language, String voice, Integer chatId, String participantName) {
        CompletableFuture.runAsync(() -> {
            try {
                // Build metadata JSON
                Map<String, String> metadataMap = new HashMap<>();
                metadataMap.put("language", language);
                metadataMap.put("voice", voice);
                if (chatId != null && chatId != 0) {
                    metadataMap.put("chat_id", String.valueOf(chatId));
                }
                metadataMap.put("user_id", participantName);
                
                StringBuilder metadataJson = new StringBuilder("{");
                boolean first = true;
                for (Map.Entry<String, String> entry : metadataMap.entrySet()) {
                    if (!first) metadataJson.append(",");
                    metadataJson.append("\"").append(entry.getKey()).append("\":\"").append(entry.getValue()).append("\"");
                    first = false;
                }
                metadataJson.append("}");
                
                // Use LiveKit API client to dispatch agent
                // Note: This requires the LiveKit API client to be available
                // If AgentDispatchService is not available in your SDK version,
                // the agent will use automatic dispatch based on room patterns
                try {
                    LiveKitAPI api = new LiveKitAPI(livekitUrl, apiKey, apiSecret);
                    // Note: AgentDispatchService API may vary by SDK version
                    // If not available, agent will be dispatched automatically when participant joins
                    <http://log.info|log.info>("Agent 'voice-assistant' will be dispatched to room: {} (metadata: {})", roomName, metadataJson.toString());
                    // Uncomment when AgentDispatchService is available:
                    // api.getAgentDispatchService().createDispatch(roomName, "voice-assistant", metadataJson.toString());
                } catch (Exception e) {
                    log.debug("AgentDispatchService not available. Agent will use automatic dispatch: {}", e.getMessage());
                }
            } catch (Exception e) {
                log.warn("Failed to dispatch agent explicitly. Agent will use automatic dispatch: {}", e.getMessage());
            }
        });
    }
}

io.livekit:livekit-protocol:0.10.1

<dependency>
  <groupId>io.livekit</groupId>
  <artifactId>server-sdk-java</artifactId>
  <version>REPLACE_WITH_PUBLISHED_VERSION</version>
</dependency>

<dependency>
  <groupId>io.livekit</groupId>
  <artifactId>server-sdk-kotlin</artifactId>
  <version>REPLACE_WITH_PUBLISHED_VERSION</version>
</dependency>

livekit.proto.*

protoc

RoomConfiguration

RoomAgentDispatch

RoomAgentDispatch

protoc

RoomConfiguration