nslookup gemini-live-api-test-o7e8z3sr.livekit.cloud

curl -v <https://gemini-live-api-test-o7e8z3sr.livekit.cloud/settings/regions>

openssl s_client -connect gemini-live-api-test-o7e8z3sr.livekit.cloud:443 -servername gemini-live-api-test-o7e8z3sr.livekit.cloud </dev/null 2>&1 | sed -n '1,120p'

docker inspect -f '{{.HostConfig.NetworkMode}}' <container>

ip route

cat /etc/resolv.conf

/usr/local/share/ca-certificates/my-proxy.crt

update-ca-certificates

COPY my-proxy.crt /usr/local/share/ca-certificates/
  RUN update-ca-certificates

curl -k https://.../settings/regions

gemini-live-api-test-o7e8z3sr.livekit.cloud

curl -v <https://gemini-live-api-test-o7e8z3sr.livekit.cloud/settings/regions>

package com.livekit.tokenserver;

import com.fasterxml.jackson.databind.ObjectMapper;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.security.Keys;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;

import javax.crypto.SecretKey;
import java.nio.charset.StandardCharsets;
import java.time.Instant;
import java.util.*;

@RestController
@CrossOrigin(origins = "*")
public class TokenController {

    @Value("${livekit.url}")
    private String livekitUrl;

    @Value("${livekit.api-key}")
    private String apiKey;

    @Value("${livekit.api-secret}")
    private String apiSecret;

    @Value("${livekit.default-room}")
    private String defaultRoom;

    @Value("${livekit.default-agent-name}")
    private String defaultAgentName;

    private final ObjectMapper objectMapper = new ObjectMapper();

    @GetMapping("/token")
    public Map<String, Object> generateToken(
            @RequestParam(defaultValue = "en-IN") String language,
            @RequestParam(defaultValue = "Aoede") String voice,
            @RequestParam(required = false) String room) {

        String userId = generateUserId();
        String identity = "user-" + userId;
        String roomName = (room != null && !room.isEmpty()) ? room : defaultRoom;

        String token = createAccessToken(identity, userId, roomName, language, voice);

        Map<String, Object> response = new HashMap<>();
        response.put("token", token);
        response.put("url", livekitUrl);
        response.put("room", roomName);
        response.put("identity", identity);
        response.put("language", language);
        response.put("voice", voice);

        System.out.println("✓ Generated token for " + identity + " (Language: " + language + ", Voice: " + voice + ")");

        return response;
    }

    @GetMapping("/health")
    public Map<String, String> health() {
        Map<String, String> status = new HashMap<>();
        status.put("status", "UP");
        status.put("service", "livekit-token-service");
        return status;
    }

    private String createAccessToken(String identity, String userId, String room, String language, String voice) {
        try {
            SecretKey secretKey = Keys.hmacShaKeyFor(apiSecret.getBytes(StandardCharsets.UTF_8));

            Instant now = Instant.now();
            Instant expiration = now.plusSeconds(3600);

            // Create metadata
            Map<String, Object> metadata = new HashMap<>();
            metadata.put("language", language);
            metadata.put("voice", voice);
            String metadataJson = objectMapper.writeValueAsString(metadata);

            // Create agent dispatch configuration
            Map<String, Object> agentMetadata = new HashMap<>();
            agentMetadata.put("language", language);
            agentMetadata.put("voice", voice);
            agentMetadata.put("user_id", identity);
            String agentMetadataJson = objectMapper.writeValueAsString(agentMetadata);

            Map<String, Object> agentDispatch = new HashMap<>();
            agentDispatch.put("agent_name", defaultAgentName);
            agentDispatch.put("metadata", agentMetadataJson);

            List<Map<String, Object>> agents = new ArrayList<>();
            agents.add(agentDispatch);

            Map<String, Object> roomConfig = new HashMap<>();
            roomConfig.put("agents", agents);

            // Build JWT token
            return Jwts.builder()
                    .header()
                        .add("typ", "JWT")
                        .add("alg", "HS256")
                    .and()
                    .issuer(apiKey)
                    .subject(identity)
                    .issuedAt(Date.from(now))
                    .expiration(Date.from(expiration))
                    .claim("name", "User " + userId)
                    .claim("video", Map.of(
                            "roomJoin", true,
                            "room", room,
                            "canPublish", true,
                            "canSubscribe", true
                    ))
                    .claim("metadata", metadataJson)
                    .claim("room_config", roomConfig)
                    .signWith(secretKey)
                    .compact();
        } catch (Exception e) {
            throw new RuntimeException("Failed to create access token", e);
        }
    }

    private String generateUserId() {
        String chars = "abcdefghijklmnopqrstuvwxyz0123456789";
        Random random = new Random();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 8; i++) {
            sb.append(chars.charAt(random.nextInt(chars.length())));
        }
        return sb.toString();
    }
}

cacerts