// Example: node server using LiveKit server SDK
// npm install @livekit/server-sdk  (example package name; adjust if different)

const {AgentDispatchServiceClient, CreateDispatchRequest} = require('@livekit/server-sdk');
const grpc = require('@grpc/grpc-js'); // if SDK uses grpc under the hood

// Configure
const LIVEKIT_URL = 'your-livekit-server:443'; // host with port (no scheme)
const API_KEY = process.env.LIVEKIT_API_KEY;
const API_SECRET = process.env.LIVEKIT_API_SECRET;

// Create client (SDK may provide helper; using raw gRPC client pattern shown)
const metadata = new grpc.Metadata();
metadata.set('authorization', `Basic ${Buffer.from(`${API_KEY}:${API_SECRET}`).toString('base64')}`);

// If the SDK exposes a client wrapper, use that. Example generically:
const client = new AgentDispatchServiceClient(LIVEKIT_URL, grpc.credentials.createSsl());

async function createDispatch(agentName, roomName, metadataFields = {}) {
  return new Promise((resolve, reject) => {
    const req = new CreateDispatchRequest();
    req.setRoom(roomName);
    req.setAgentName(agentName);

    // Attach metadata as JSON string or structured fields per API
    if (Object.keys(metadataFields).length) {
      req.setMetadata(JSON.stringify(metadataFields));
    }

    client.createDispatch(req, metadata, (err, resp) => {
      if (err) return reject(err);
      resolve(resp);
    });
  });
}

// Example usage:
createDispatch('my-agent', 'my-room', {initiatedBy: 'unity-client'})
  .then(res => console.log('Dispatch created:', res))
  .catch(err => console.error('Dispatch error:', err));

// Example using REST POST (if LiveKit exposes HTTP endpoint for dispatch).
// Replace with the correct LiveKit dispatch endpoint path for your deployment.

const fetch = require('node-fetch');

async function createDispatchREST(agentName, roomName, metadataFields = {}) {
  const url = `<https://your-livekit-host/api/dispatch`;> // adjust path to real endpoint
  const body = {
    room: roomName,
    agent_name: agentName,
    metadata: metadataFields
  };

  const resp = await fetch(url, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      // Basic auth using API key:secret — keep secret on server
      'Authorization': 'Basic ' + Buffer.from(`${process.env.LIVEKIT_API_KEY}:${process.env.LIVEKIT_API_SECRET}`).toString('base64'),
    },
    body: JSON.stringify(body),
  });

  if (!resp.ok) {
    const text = await resp.text();
    throw new Error(`Dispatch failed: ${resp.status} ${text}`);
  }
  return resp.json();
}

// Example usage:
createDispatchREST('my-agent', 'my-room', {initiatedBy: 'unity-client'})
  .then(res => console.log('Dispatch REST created:', res))
  .catch(err => console.error(err));

npm install @livekit/server-sdk express

// server.js
const express = require('express');
const bodyParser = require('body-parser');
const { AgentDispatchServiceClient } = require('@livekit/server-sdk');
const grpc = require('@grpc/grpc-js');

const app = express();
app.use(bodyParser.json());

// Configure from env
const LIVEKIT_HOST = process.env.LIVEKIT_HOST || 'your-livekit-host:443'; // host[:port]
const LIVEKIT_API_KEY = process.env.LIVEKIT_API_KEY;
const LIVEKIT_API_SECRET = process.env.LIVEKIT_API_SECRET;

if (!LIVEKIT_API_KEY || !LIVEKIT_API_SECRET) {
  console.error('Set LIVEKIT_API_KEY and LIVEKIT_API_SECRET in environment');
  process.exit(1);
}

// Build basic auth metadata for gRPC calls
function authMetadata() {
  const meta = new grpc.Metadata();
  const token = Buffer.from(`${LIVEKIT_API_KEY}:${LIVEKIT_API_SECRET}`).toString('base64');
  meta.set('authorization', `Basic ${token}`);
  return meta;
}

// Create gRPC client for AgentDispatchService
const client = new AgentDispatchServiceClient(
  LIVEKIT_HOST,
  grpc.credentials.createSsl()
);

// POST /dispatch
// Body: { room: string, agent_name: string, metadata?: object }
<http://app.post|app.post>('/dispatch', async (req, res) => {
  try {
    const { room, agent_name, metadata } = req.body;

    if (!room || !agent_name) {
      return res.status(400).json({ error: 'room and agent_name are required' });
    }

    // Build the CreateDispatchRequest using the SDK's request shape.
    // The exact request class helpers vary by SDK version; if the SDK exposes
    // a builder, use it. Here we construct the raw request object expected by gRPC.
    const createDispatchReq = {
      room: room,
      agent_name: agent_name,
      // AgentDispatchRequest metadata field expects a string or Struct depending on proto;
      // encode metadata as JSON string in the `metadata` field so the agent can parse it.
      metadata: metadata ? JSON.stringify(metadata) : undefined,
    };

    // Call CreateDispatch
    const metadataHeaders = authMetadata();
    client.createDispatch(createDispatchReq, metadataHeaders, (err, response) => {
      if (err) {
        console.error('CreateDispatch error:', err);
        return res.status(500).json({ error: err.message || 'dispatch_error' });
      }

      // Response contains dispatch details (agent session id, status, etc).
      // Return relevant safe fields to the Unity client.
      return res.json({
        success: true,
        dispatch: response, // you may filter fields here before returning
      });
    });
  } catch (e) {
    console.error('Dispatch endpoint error:', e);
    res.status(500).json({ error: 'internal_server_error' });
  }
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Dispatch server listening on ${PORT}`);
});

metadata

using System;
using System.Collections;
using System.Text;
using UnityEngine;
using UnityEngine.Networking;

[Serializable]
public class DispatchRequest {
    public string room;
    public string agent_name;
    public object metadata; // can be any serializable object (dictionary, anon object)
}

[Serializable]
public class DispatchResponse {
    public bool success;
    public string error;
    // If your server returns dispatch info, map fields here.
    // Example: public string dispatch_id;
    // Or include a generic object for the dispatch payload:
    public object dispatch;
}

public class AgentDispatchClient : MonoBehaviour {
    // Set this to your server endpoint
    [SerializeField] private string dispatchEndpoint = "<https://your-server.example.com/dispatch>";

    // Example call from Unity (coroutine)
    public void RequestAgentDispatch(string room, string agentName, object metadata = null, string bearerToken = null) {
        var req = new DispatchRequest {
            room = room,
            agent_name = agentName,
            metadata = metadata
        };

        StartCoroutine(PostDispatchRequestCoroutine(req, bearerToken));
    }

    private IEnumerator PostDispatchRequestCoroutine(DispatchRequest requestPayload, string bearerToken) {
        string json = JsonUtility.ToJson(requestPayload);

        using (UnityWebRequest www = new UnityWebRequest(dispatchEndpoint, "POST")) {
            byte[] bodyRaw = Encoding.UTF8.GetBytes(json);
            www.uploadHandler = new UploadHandlerRaw(bodyRaw);
            www.downloadHandler = new DownloadHandlerBuffer();
            www.SetRequestHeader("Content-Type", "application/json");

            // If you use bearer token auth from Unity to your server, set it here.
            if (!string.IsNullOrEmpty(bearerToken)) {
                www.SetRequestHeader("Authorization", $"Bearer {bearerToken}");
            }

            yield return www.SendWebRequest();

#if UNITY_2020_1_OR_NEWER
            bool isNetworkError = www.result == UnityWebRequest.Result.ConnectionError;
            bool isHttpError = www.result == UnityWebRequest.Result.ProtocolError;
#else
            bool isNetworkError = www.isNetworkError;
            bool isHttpError = www.isHttpError;
#endif

            if (isNetworkError || isHttpError) {
                Debug.LogError($"Dispatch request failed: {www.error} (status: {www.responseCode})");
                // You can surface this to UI or retry logic
                yield break;
            }

            string respText = www.downloadHandler.text;
            Debug.Log("Dispatch response: " + respText);

            // Parse response (use JsonUtility or a JSON library like Newtonsoft if response is complex)
            try {
                DispatchResponse resp = JsonUtility.FromJson<DispatchResponse>(respText);
                if (resp == null) {
                    Debug.LogWarning("Dispatch response could not be parsed as DispatchResponse.");
                    // Optionally use a JSON library here for dynamic parsing
                } else if (resp.success) {
                    Debug.Log("Agent dispatch requested successfully.");
                    // Handle dispatch info in resp.dispatch if needed
                } else {
                    Debug.LogWarning($"Dispatch failed: {resp.error}");
                }
            } catch (Exception ex) {
                Debug.LogError("Failed to parse dispatch response: " + ex.Message);
            }
        }
    }
}

metadata