Discord Integration

https://discord.com/api/oauth2/authorize?client_id=YOUR_CLIENT_ID&permissions=36703296&scope=bot%20applications.commands

cd services/discord-bot
cp .env .env.local

# Discord Configuration
DISCORD_TOKEN='your-bot-token-here'
DISCORD_BOT_CLIENT_ID='your-application-id-here'

# AIRI Server Connection
AIRI_URL='ws://localhost:6121/ws'
AIRI_TOKEN='abcd'

# OpenAI Configuration
OPENAI_API_KEY='sk-...'
OPENAI_MODEL='gpt-4o'
OPENAI_API_BASE_URL='https://api.openai.com/v1'

# ElevenLabs Configuration (for TTS)
ELEVENLABS_API_KEY='your-elevenlabs-key'
ELEVENLABS_API_BASE_URL='https://api.elevenlabs.io/v1'

pnpm install

pnpm run -F @proj-airi/discord-bot start

Discord bot ready! User: YourBotName#1234

@AIRI what's the weather like today?

import { Client as AiriClient } from '@proj-airi/server-sdk'
import { Client, GatewayIntentBits } from 'discord.js'

export class DiscordAdapter {
  private airiClient: AiriClient
  private discordClient: Client

  constructor(config: DiscordAdapterConfig) {
    // Initialize Discord client
    this.discordClient = new Client({
      intents: [
        GatewayIntentBits.Guilds,
        GatewayIntentBits.GuildVoiceStates,
        GatewayIntentBits.GuildMessages,
        GatewayIntentBits.MessageContent,
        GatewayIntentBits.DirectMessages,
      ],
    })

    // Initialize AIRI client
    this.airiClient = new AiriClient({
      name: 'discord',
      possibleEvents: [
        'input:text',
        'input:text:voice',
        'input:voice',
        'module:configure',
        'output:gen-ai:chat:message',
      ],
      token: config.airiToken,
      url: config.airiUrl,
    })
  }
}

// Handle text messages
this.discordClient.on(Events.MessageCreate, async (message) => {
  if (message.author.bot) return
  
  const isMentioned = message.mentions.has(this.discordClient.user)
  const isDM = !message.guild
  
  if (isMentioned || isDM) {
    const content = message.content
      .replace(/<@!?\d+>/g, '')
      .trim()
    
    // Send to AIRI
    this.airiClient.send({
      type: 'input:text',
      data: {
        text: content,
        discord: {
          channelId: message.channelId,
          guildId: message.guildId,
          guildMember: {
            id: message.author.id,
            displayName: message.member?.displayName,
          },
        },
      },
    })
  }
})

// Handle output from AIRI system
this.airiClient.onEvent('output:gen-ai:chat:message', async (event) => {
  const message = event.data.message
  const discordContext = event.data['gen-ai:chat'].input.data.discord
  
  if (message?.content && discordContext?.channelId) {
    const channel = await this.discordClient.channels.fetch(
      discordContext.channelId
    )
    
    if (channel?.isTextBased()) {
      // Split long messages if needed
      if (message.content.length <= 2000) {
        await channel.send(message.content)
      } else {
        // Handle chunking for messages over 2000 chars
        // ...
      }
    }
  }
})

import { joinVoiceChannel, createAudioPlayer } from '@discordjs/voice'

async joinChannel(interaction, channel) {
  const connection = joinVoiceChannel({
    channelId: channel.id,
    guildId: channel.guild.id,
    adapterCreator: channel.guild.voiceAdapterCreator,
    selfDeaf: false,
    selfMute: false,
  })

  // Wait for connection to be ready
  await Promise.race([
    entersState(connection, VoiceConnectionStatus.Ready, 20_000),
    entersState(connection, VoiceConnectionStatus.Signalling, 20_000),
  ])

  // Listen to voice data
  connection.receiver.speaking.on('start', (userId) => {
    this.monitorMember(userId, channel.id)
  })
}

this.airiClient.onEvent('module:configure', async (event) => {
  const { token, enabled } = event.data.config
  
  if (enabled === false) {
    await this.discordClient.destroy()
    return
  }
  
  if (token && this.discordToken !== token) {
    this.discordToken = token
    await this.discordClient.login(this.discordToken)
  }
})