AI Bots: Messenger and Games Integration Architecture

# main.py
is_active_channel = string_channel_id in active_channels
is_allowed_dm = allow_dm and is_dm_channel
contains_trigger_word = any(word in message.content for word in trigger_words)
is_bot_mentioned = bot.user.mentioned_in(message) and smart_mention

if is_active_channel or is_allowed_dm or contains_trigger_word or is_bot_mentioned:
    # Process via AI

# utilities/config_loader.py
def load_instructions(instruction):
    for file_name in os.listdir("instructions"):
        if file_name.endswith('.txt'):
            with open(f"instructions/{file_name}", 'r', encoding='utf-8') as file:
                instruction[file_name.split('.')[0]] = file.read()

async def generate_image_prodia(prompt, model, sampler, seed, neg):
    # 1. Create job via API
    # 2. Poll status until 'succeeded'
    # 3. Load binary data into io.BytesIO
    # 4. Return file-like object for Discord

# docker-compose.yml
services:
  bot:
    build: .
    restart: unless-stopped
    env_file: .env
    command: >
      sh -c "if [ -n \"$REPL_OWNER\" ]; then
               python utilities/replit_flask_runner.py & python main.py;
             else
               python main.py;
             fi"

# compose.yml
services:
  celestia:
    image: ponfertato/discord-ai:main
    env_file: celestia.env
    labels:
      com.centurylinklabs.watchtower.enable: "false"
      traefik.enable: "false"

  luna:
    image: ponfertato/discord-ai:main
    env_file: luna.env

# bot_utilities/ai_utils.py
from openai import AsyncOpenAI

openai_client = AsyncOpenAI(
    api_key=os.getenv('CHIMERA_GPT_KEY'),
    base_url="https://api.naga.ac/v1"  # Custom proxy endpoint
)

async def generate_response(instructions, search, history):
    messages = [
        {"role": "system", "name": "instructions", "content": instructions},
        *history,
        {"role": "system", "name": "search_results", "content": search_results},
    ]
    response = await openai_client.chat.completions.create(
        model=os.getenv('GPT_MODEL'),
        messages=messages
    )
    return response.choices[0].message.content

def fetch_chat_models():
    headers = {'Authorization': f'Bearer {CHIMERA_GPT_KEY}'}
    response = requests.get('https://api.naga.ac/v1/models', headers=headers)
    if response.status_code == 200:
        return [
            model['id'] for model in response.json().get('data')
            if "chat" in model['endpoints'][0]
        ]
    return []

// src/services/browser/index.ts
export class BrowserService {
  static async launch() {
    return await puppeteer.launch({
      executablePath: CONFIG.CHROMIUM_PATH,
      headless: false,
      args: [
        "--no-sandbox",
        "--disable-setuid-sandbox",
        "--disable-dev-shm-usage",
        `--user-agent=${CONFIG.BROWSER.USER_AGENT}`,
      ],
    });
  }
}

// src/modules/cloudflare/bypass.ts
export class CloudflareBypasser {
  async bypass(): Promise<boolean> {
    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
      if (await this.isCloudflareChallengePresent()) {
        await this.solveChallenge();
        await sleep(CHECK_INTERVAL);
        continue;
      }
      return true;
    }
    return false;
  }
}

// src/modules/plugins/manager.ts
async handleMessage(message: ChatMessage): Promise<boolean> {
  const sortedHandlers = [...this.handlers].sort((a, b) =>
    b.getPriority() - a.getPriority()
  );
  for (const handler of sortedHandlers) {
    if (await handler.shouldHandle(message)) {
      this.lastHandler = handler.constructor.name;
      const result = await handler.handle(message);
      if (result) return true;
    }
  }
  return false;
}

// src/modules/chat/generator.ts
private buildPrompt(text: string, context: string): string {
  return [
    `${CONFIG.PERSONALITY_NAME} Context-Aware Response Rules:`,
    `Response MUST:`,
    `1. Be 1-2 casual phrases (110-140 chars)`,
    `2. Use spoken language with flow errors`,
    `3. Reflect environment context: ${context}`,
    `4. Add ONE relevant emoji at end (replaces punctuation)`,
    `5. Format: single line without markdown`,
  ].join('\n');
}

src/
├── Config/      # Config validation, .env loading
├── Core/        # Bot, WebhookHandler, StatusPage - core
├── AI/          # Interface + implementations: OpenAIProvider, OllamaProvider
└── Exceptions/  # Typed errors

// src/AI/AIInterface.php
interface AIInterface {
    public function generateResponse(string $prompt, array $context): string;
}

// src/AI/OpenAIProvider.php
class OpenAIProvider implements AIInterface {
    public function generateResponse(string $prompt, array $context): string {
        $client = new OpenAI(getenv('OPENAI_API_KEY'));
        $response = $client->chat()->create([
            'model' => getenv('OPENAI_MODEL'),
            'messages' => [
                ['role' => 'system', 'content' => getenv('AI_SYSTEM_PROMPT')],
                ['role' => 'user', 'content' => $prompt]
            ]
        ]);
        return $response->choices[0]->message->content;
    }
}

// src/Core/WebhookHandler.php
public function handle(array $update): void {
    if (isset($update['message'])) {
        $chatId = $update['message']['chat']['id'];
        $text = $update['message']['text'] ?? '';

        if (!$this->rateLimiter->allow($chatId)) {
            return; // Ignore spam
        }

        $response = $this->aiProvider->generateResponse($text, []);
        $this->bot->sendMessage($chatId, $response);
    }
}

# docker-compose.yml
services:
  telegram-ai-replier:
    build: .
    volumes:
      - ./data/db.json:/app/data/db.json
      - ./data/rate_limit.json:/app/data/rate_limit.json
    ports:
      - "8008:80"