LiveKit Integration

import asyncio
from livekit import Room, RoomEvent
from livekit_agenthuman import AgentHumanPlugin

async def main():
    # Create and configure room
    room = Room()
    
    # Set up event handlers
    @room.on(RoomEvent.PARTICIPANT_CONNECTED)
    def on_participant_connected(participant):
        print(f"Participant joined: {participant.identity}")
    
    @room.on(RoomEvent.TRACK_SUBSCRIBED)
    def on_track_subscribed(track, publication, participant):
        print(f"Subscribed to {participant.identity}'s {track.kind} track")
    
    # Connect to LiveKit room
    await room.connect(
        url="wss://your-livekit-server.com",
        token="your-livekit-token"
    )
    print(f"Connected to room: {room.name}")
    
    # Add avatar plugin
    avatar_plugin = AgentHumanPlugin(
        api_key="ah_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxx",
        avatar_id="avat_01H3Z8G9YR3K2N5M6P7Q8W4T",
        display_name="AI Assistant",
        aspect_ratio="16:9"
    )
    
    await room.add_plugin(avatar_plugin)
    print("Avatar plugin added - avatar will join room shortly")
    
    # Keep room alive
    try:
        await asyncio.sleep(3600)  # Run for 1 hour
    except KeyboardInterrupt:
        print("Shutting down...")
    finally:
        await avatar_plugin.disconnect()
        await room.disconnect()

if __name__ == "__main__":
    asyncio.run(main())

import { useEffect, useState } from 'react';
import { Room, RoomEvent } from 'livekit-client';
import { AgentHumanPlugin } from '@livekit/agenthuman';

function AvatarRoom() {
  const [room, setRoom] = useState<Room | null>(null);
  const [avatarConnected, setAvatarConnected] = useState(false);
  
  useEffect(() => {
    const connectRoom = async () => {
      // Create room
      const newRoom = new Room();
      
      // Handle events
      newRoom.on(RoomEvent.ParticipantConnected, (participant) => {
        console.log('Participant joined:', participant.identity);
        if (participant.identity.includes('Avatar')) {
          setAvatarConnected(true);
        }
      });
      
      // Connect to LiveKit
      await newRoom.connect(
        'wss://your-livekit-server.com',
        'your-livekit-token'
      );
      
      // Add avatar plugin
      const plugin = new AgentHumanPlugin({
        apiKey: 'ah_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxx',
        avatarId: 'avat_01H3Z8G9YR3K2N5M6P7Q8W4T',
        displayName: 'AI Assistant'
      });
      
      await newRoom.addPlugin(plugin);
      setRoom(newRoom);
    };
    
    connectRoom();
    
    // Cleanup
    return () => {
      room?.disconnect();
    };
  }, []);
  
  return (
    <div>
      <h2>LiveKit Room with AI Avatar</h2>
      <p>Status: {avatarConnected ? 'Avatar Connected' : 'Waiting for avatar...'}</p>
      {/* Add LiveKit video components here */}
    </div>
  );
}

# Manual plugin control
await plugin.connect()      # Connect avatar
await plugin.disconnect()   # Disconnect avatar
await plugin.send_audio(audio_data)  # Send specific audio

from livekit import api

# Create LiveKit API client
livekit_api = api.LiveKitAPI(
    url="wss://your-livekit-server.com",
    api_key="your-api-key",
    api_secret="your-api-secret"
)

# Create room
room_info = await livekit_api.room.create_room(
    name="avatar-demo-room",
    empty_timeout=300,  # 5 minutes
    max_participants=10
)

# Generate token for participant
token = await livekit_api.create_token(
    room_name=room_info.name,
    participant_identity="user-123",
    participant_name="John Doe"
)

print(f"Room URL: {room_info.name}")
print(f"Token: {token}")

const room = new Room();

await room.connect(
  'wss://your-livekit-server.com',
  token,  // Token from server
  {
    autoSubscribe: true,
    dynacast: true
  }
);

# Proper setup and teardown
async def run_avatar_session():
    plugin = AgentHumanPlugin(...)
    room = Room()
    
    try:
        await room.connect(...)
        await room.add_plugin(plugin)
        
        # Do work
        await asyncio.sleep(3600)
        
    finally:
        # Always cleanup
        await plugin.disconnect()
        await room.disconnect()

plugin.on('error', async (error) => {
  console.error('Plugin error:', error);
  
  if (error.message.includes('Session not found')) {
    // Reconnect plugin
    await plugin.reconnect();
  }
});

# Add multiple avatars to same room
avatar1 = AgentHumanPlugin(
    api_key="...",
    avatar_id="avat_01H3Z8G9YR3K2N5M6P7Q8W4T",
    display_name="Avatar 1"
)

avatar2 = AgentHumanPlugin(
    api_key="...",
    avatar_id="avat_02H3Z8G9YR3K2N5M6P7Q8W4T",
    display_name="Avatar 2"
)

await room.add_plugin(avatar1)
await room.add_plugin(avatar2)

# Verify LiveKit connection first
await room.connect(url, token)
print(f"Room connected: {room.is_connected()}")

# Then add plugin
await room.add_plugin(plugin)

@room.on(RoomEvent.PARTICIPANT_CONNECTED)
def on_participant_connected(participant):
    print(f"Participant: {participant.identity}")
    # Avatar should appear here

# Ensure auto-subscribe is enabled
await room.connect(url, token, RoomOptions(auto_subscribe=True))

# Or manually subscribe to tracks
@room.on(RoomEvent.TRACK_PUBLISHED)
async def on_track_published(publication, participant):
    await publication.set_subscribed(True)