plugins/gptold.js

import express from 'express';
import { OpenaiRes } from '../lib/scrapper.js';
import { audioContent } from '../lib/all.js';
import { NvidiaTogether } from '../lib/@randydev/together/llama.js';
import { CohereAI } from '../lib/@randydev/together/cohere.js';
import { ModeratorAntiEvalVersionV3 } from "../moderator.js";
import { 
  SYSTEMJAWA, 
  SYSTEMSUNDA,
  SYSTEMMIA,
  SYSTEMAIGEN,
  SYSTEMAIGENV2,
  PowerFullModerator,
  SENSIFIFNOCODE,
  ALLQURAN_SHOLAWAT,
  LIRIKLAGU,
  QUOTESLUCU,
  QUOTESSEDIH,
  PythonToJS,
  JsToPython,
  curlCommandCode,
  AkenoX19Hybrid,
  AkenoX19HybridEnglish,
  ModeratorAntiEval,
  ModeratorAntiEvalVersionV2,
  SystemHumanizeRyzenth
} from '../models.js';
import { 
  AlibabaTogether,
  AlibabaTurboTogether,
  CloudFlareQwenTogether,
  DeepseekQwenTogether,
  Qwen323NewResponse,
} from '../lib/@randydev/together/qwen-ai.js';

import { CloudFlareMistralTogether } from '../lib/@randydev/together/cloudflare-ai.js';
import { DeepSeekR1 } from '../lib/@randydev/together/blackbox.js';
import { authenticateApiKey, authenticateApiKeyPremium, apiLimiter } from '../middleware/midware.js';
const GptRoutes = express.Router();

import fs from "fs";
import got from "got";

/**
 * @swagger
 * /api/v1/ai/openai/whisper-large-v3-turbo:
 *   get:
 *     summary: Openai Whisper large turbo
 *     tags: [AI]
 *     parameters:
 *       - in: query
 *         name: url
 *         required: true
 *         description: url mp3
 *         schema:
 *           type: string
 *       - in: query
 *         name: language
 *         required: false
 *         description: The language of the audio being transcribed or translated.
 *         schema:
 *           type: string
 *       - in: query
 *         name: task
 *         required: false
 *         description: Supported tasks are 'translate' or 'transcribe'.
 *         schema:
 *           type: string
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get("/api/v1/ai/openai/whisper-large-v3-turbo", authenticateApiKey, apiLimiter, async (req, res) => {
    const API_BASE_URL = `https://api.cloudflare.com/client/v4/accounts/${process.env['ACCOUNT_ID']}/ai/run/@cf/openai/whisper-large-v3-turbo`;
    const headers = {
        "Authorization": `Bearer ${process.env['CLOUDFLARE_API_KEY']}`,
        "Content-Type": "application/json"
    };
    const url = req.query.url;
    const language = req.query.language || "en";
    const task = req.query.task || "transcribe";

    if (!url) {
        return res.status(500).json({ error: "url required" });
    }

    const path = await audioContent(url);
    if (!path) {
        return res.status(500).json({ error: "Failed to download audio file" });
    }

    try {
        const audioBytes = fs.readFileSync(path);
        const audioBase64 = Buffer.from(audioBytes).toString("base64");

        const inputData = {
          audio: audioBase64,
          language: language,
          task: task
        };

        const response = await got.post(API_BASE_URL, {
            headers,
            json: inputData,
        }).json();
        return res.json(response);
    } catch (error) {
        console.error("Error making API request:", error.message);
        return res.status(500).json({ error: null });
    } finally {
        if (fs.existsSync(path)) {
            fs.unlinkSync(path);
        }
    }
});

/**
 * @swagger
 * /api/v1/ai/deepseek/deepseek-r1-distill-qwen-32b:
 *   get:
 *     summary: deepseek r1 distill-qwen-32b
 *     tags: [AI]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: query
 *         name: system_prompt
 *         required: false
 *         description: Custom system prompt
 *         schema:
 *           type: string 
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/deepseek/deepseek-r1-distill-qwen-32b', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        const system_prompt = req.query.system_prompt || "Your name is AkenoX AI A kind and friendly AI assistant that answers in a short and concise answer. Give short step-by-step reasoning if required.";

        const results = await DeepseekQwenTogether(query, {
          system_prompt: system_prompt
        });
        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});

/**
 * @swagger
 * /api/v1/ai/deepseek/deepseek-R1:
 *   get:
 *     summary: Deepseek R1
 *     tags: [AI]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/deepseek/deepseek-R1', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        const results = await DeepSeekR1(query);
        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});

/**
 * @swagger
 * /api/v1/ai/mistral/mistral-7b-instruct-v0.1:
 *   get:
 *     summary: Mistral AI
 *     tags: [AI]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: query
 *         name: system_prompt
 *         required: false
 *         description: Custom system prompt
 *         schema:
 *           type: string
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/mistral/mistral-7b-instruct-v0.1', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        const system_prompt = req.query.system_prompt || "Your name is AkenoX AI A kind and friendly AI assistant that answers in a short and concise answer. Give short step-by-step reasoning if required.";

        const results = await CloudFlareMistralTogether(query, {
          system_prompt: system_prompt
        });
        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});

/**
 * @swagger
 * /api/v1/ai/akenox/lu-melayu:
 *   get:
 *     summary: custom Malay AI
 *     tags: [AI]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/akenox/lu-melayu', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        const results = await CloudFlareQwenTogether(query, {
          system_prompt: SYSTEMJAWA
        });
        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});

/**
 * @swagger
 * /api/v1/ai/akenox/nocodefou:
 *   get:
 *     summary: Custom NoCodeFou AI
 *     tags: [AI]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/akenox/nocodefou', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        if (!query) {
            return res.status(500).json({ error: "query required" });
        }
        const results = await AlibabaTogether(query, {
          system_prompt: SENSIFIFNOCODE
        });
        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});

/**
 * @swagger
 * /api/v1/ai/akenox/AkenoX-1.9-Hybrid-Englsih:
 *   get:
 *     summary: Custom AkenoX-1.9-Hybrid Englsih AI
 *     tags: [AI]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/akenox/AkenoX-1.9-Hybrid-Englsih', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        if (!query) {
            return res.status(500).json({ error: "query required" });
        }
        const results = await AlibabaTogether(query, {
          system_prompt: AkenoX19HybridEnglish
        });
        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});

/**
 * @swagger
 * /api/v1/ai/r/Ryzenth-Humanize-05-06-2025:
 *   get:
 *     summary: Custom Ryzenth Humanize AI
 *     tags: [AI]
 *     parameters:
 *       - in: query
 *         name: text
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: query
 *         name: author_id
 *         required: true
 *         description: Custom Nickname
 *         schema:
 *           type: string
 *           example: "<string or UUID, e.g. 'anonymous' or 'user_1234'>"
 *       - in: query
 *         name: writing_style
 *         required: true
 *         description: Custom writing style
 *         schema:
 *           type: string
 *           example: "<blog-like | spoken | journalistic | narrative | etc.>"
 *       - in: query
 *         name: timestamp
 *         required: true
 *         description: Custom timestamp
 *         schema:
 *           type: string
 *           example: "<ISO language code, e.g. 'en'>"
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/r/Ryzenth-Humanize-05-06-2025', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.text;
        const author_id = req.query.author_id;
        const writing_style = req.query.writing_style;
        const timestamp = req.query.timestamp;
        if (!query && !author_id && !timestamp && !writing_style) {
            return res.status(500).json({ error: "all required" });
        }
        const results = await AlibabaTogether(query, {
          system_prompt: SystemHumanizeRyzenth(author_id, writing_style, timestamp)
        });
        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});


/**
 * @swagger
 * /api/v1/ai/akenox/AkenoX-1.9-Hybrid:
 *   get:
 *     summary: Custom AkenoX-1.9-Hybrid AI
 *     tags: [AI]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/akenox/AkenoX-1.9-Hybrid', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        if (!query) {
            return res.status(500).json({ error: "query required" });
        }
        const results = await AlibabaTogether(query, {
          system_prompt: AkenoX19Hybrid
        });
        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});

/**
 * @swagger
 * /api/v1/ai/akenox/mia-khalifah:
 *   get:
 *     summary: Custom Mia Khalifah AI
 *     tags: [AI]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/akenox/mia-khalifah', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        if (!query) {
            return res.status(500).json({ error: "query required" });
        }
        const results = await AlibabaTogether(query, {
          system_prompt: SYSTEMMIA
        });
        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});

/**
 * @swagger
 * /api/v1/ai/akenox/curl-command-code:
 *   get:
 *     summary: Custom Curl Command Converter Python & Javascript AI
 *     tags: [AI]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/akenox/curl-command-code', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        if (!query) {
            return res.status(500).json({ error: "query required" });
        }
        const results = await CloudFlareQwenTogether(query, {
          system_prompt: curlCommandCode
        });
        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});

/**
 * @swagger
 * /api/v1/ai/akenox/python-to-js-api:
 *   get:
 *     summary: Custom Python to JS Requests Converter AI
 *     tags: [AI]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/akenox/python-to-js-api', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        if (!query) {
            return res.status(500).json({ error: "query required" });
        }
        const results = await CloudFlareQwenTogether(query, {
          system_prompt: PythonToJS
        });
        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});

/**
 * @swagger
 * /api/v1/ai/akenox/js-to-python-api:
 *   get:
 *     summary: Custom JS to Python Requests Converter AI
 *     tags: [AI]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/akenox/js-to-python-api', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        if (!query) {
            return res.status(500).json({ error: "query required" });
        }
        const results = await CloudFlareQwenTogether(query, {
          system_prompt: JsToPython
        });
        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});

/**
 * @swagger
 * /api/v1/ai/akenox/quotes-sad:
 *   get:
 *     summary: Custom Quotes Sad AI
 *     tags: [AI]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/akenox/quotes-sad', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        if (!query) {
            return res.status(500).json({ error: "query required" });
        }
        const results = await CloudFlareQwenTogether(query, {
          system_prompt: QUOTESSEDIH
        });
        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});

/**
 * @swagger
 * /api/v1/ai/akenox/quotes-lucu:
 *   get:
 *     summary: Custom Quotes Lucu AI
 *     tags: [AI]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/akenox/quotes-lucu', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        if (!query) {
            return res.status(500).json({ error: "query required" });
        }
        const results = await CloudFlareQwenTogether(query, {
          system_prompt: QUOTESLUCU
        });
        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});

/**
 * @swagger
 * /api/v1/ai/akenox/lirik-end:
 *   get:
 *     summary: Custom Lirik Lagu End AI
 *     tags: [AI]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/akenox/lirik-end', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        if (!query) {
            return res.status(500).json({ error: "query required" });
        }
        const results = await CloudFlareQwenTogether(query, {
          system_prompt: LIRIKLAGU
        });
        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});

/**
 * @swagger
 * /api/v1/ai/akenox/al-sholawat:
 *   get:
 *     summary: Custom Al-Sholawat AI
 *     tags: [AI]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/akenox/al-sholawat', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        if (!query) {
            return res.status(500).json({ error: "query required" });
        }
        const results = await CloudFlareQwenTogether(query, {
          system_prompt: ALLQURAN_SHOLAWAT
        });
        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});

/**
 * @swagger
 * /api/v1/ai/akenox/aigen-v1:
 *   get:
 *     summary: Custom AI Gen V1
 *     tags: [AI Moderator]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/akenox/aigen-v1', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        if (!query) {
            return res.status(500).json({ error: "query required" });
        }
        const results = await AlibabaTogether(query, {
          system_prompt: SYSTEMAIGEN
        });
        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});

/**
 * @swagger
 * /api/v1/ai/akenox/aigen-v2:
 *   get:
 *     summary: Custom AI Gen V2
 *     tags: [AI Moderator]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: query
 *         name: isJson
 *         required: true
 *         description: Format JSON
 *         schema:
 *           type: boolean
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/akenox/aigen-v2', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        const isJson = req.query.isJson || false;
        if (!query) {
            return res.status(500).json({ error: "query required" });
        }
        if (isJson) {
          const results_json = await AlibabaTogether(query, {
            system_prompt: SYSTEMAIGENV2
          });
          const check_result = JSON.parse(results_json);
          return res.json({ check_result });
        }
        const results = await AlibabaTogether(query, {
          system_prompt: SYSTEMAIGENV2
        });
        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});

/**
 * @swagger
 * /api/v1/ai/akenox/antievalai-v3:
 *   get:
 *     summary: Custom Moderator Anti Eval V3 AI
 *     tags: [AI Moderator]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/akenox/antievalai-v3', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        if (!query) {
            return res.status(500).json({ error: "query required" });
        }
        const results = await AlibabaTogether(query, {
          system_prompt: ModeratorAntiEvalVersionV3
        });
        const check_result = JSON.parse(results)
        res.json({ check_result });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});

/**
 * @swagger
 * /api/v1/ai/akenox/antievalai-v2:
 *   get:
 *     summary: Custom Moderator Anti Eval V2 AI
 *     tags: [AI Moderator]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/akenox/antievalai-v2', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        if (!query) {
            return res.status(500).json({ error: "query required" });
        }
        const results = await AlibabaTogether(query, {
          system_prompt: ModeratorAntiEvalVersionV2
        });
        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});

/**
 * @swagger
 * /api/v1/ai/akenox/antievalai-v1:
 *   get:
 *     summary: Custom Moderator Anti Eval V1 AI
 *     tags: [AI Moderator]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/akenox/antievalai-v1', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        if (!query) {
            return res.status(500).json({ error: "query required" });
        }
        const results = await CloudFlareQwenTogether(query, {
          system_prompt: ModeratorAntiEval
        });
        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});

/**
 * @swagger
 * /api/v1/ai/akenox/moderator:
 *   get:
 *     summary: Custom Moderator AI
 *     tags: [AI Moderator]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: query
 *         name: username
 *         required: true
 *         description: Owner's Username
 *         schema:
 *           type: string
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/akenox/moderator', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        const username = req.query.username;
        if (!username) {
            return res.status(500).json({ error: "username required" });
        }
        if (!query) {
            return res.status(500).json({ error: "query required" });
        }
        const systemResult = PowerFullModerator(username);
        const results = await CloudFlareQwenTogether(query, {
          system_prompt: systemResult
        });
        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});


/**
 * @swagger
 * /api/v1/ai/qwen/qwen1.5-1.8b-chat:
 *   get:
 *     summary: Qwen AI
 *     tags: [AI]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: query
 *         name: system_prompt
 *         required: false
 *         description: Custom system prompt
 *         schema:
 *           type: string
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/qwen/qwen1.5-1.8b-chat', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        const system_prompt = req.query.system_prompt || "Your name is AkenoX AI A kind and friendly AI assistant that answers in a short and concise answer. Give short step-by-step reasoning if required.";

        const results = await CloudFlareQwenTogether(query, {
          system_prompt: system_prompt
        });
        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});

/**
 * @swagger
 * /api/v1/ai/akenox/lu-sunda:
 *   get:
 *     summary: Custom Sunda AI
 *     tags: [AI]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/akenox/lu-sunda', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        const results = await AlibabaTogether(query, {
          system_prompt: SYSTEMSUNDA
        });

        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});

/**
 * @swagger
 * /api/v1/ai/alibaba/qwen-turbo-latest:
 *   get:
 *     summary: Alibaba Qwen Turbo Latest AI
 *     tags: [AI]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: query
 *         name: system_prompt
 *         required: false
 *         description: Custom system prompt
 *         schema:
 *           type: string
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/alibaba/qwen-turbo-latest', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        const system_prompt = req.query.system_prompt || "Your name is AkenoX AI A kind and friendly AI assistant that answers in a short and concise answer. Give short step-by-step reasoning if required.";

        const results = await AlibabaTurboTogether(query, {
          system_prompt: system_prompt
        });

        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});

/**
 * @swagger
 * /api/v1/ai/alibaba/qwen-plus:
 *   get:
 *     summary: Alibaba Qwen AI
 *     tags: [AI]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: query
 *         name: system_prompt
 *         required: false
 *         description: Custom system prompt
 *         schema:
 *           type: string
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/alibaba/qwen-plus', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        const system_prompt = req.query.system_prompt || "Your name is AkenoX AI A kind and friendly AI assistant that answers in a short and concise answer. Give short step-by-step reasoning if required.";

        const results = await AlibabaTogether(query, {
          system_prompt: system_prompt
        });

        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});

/**
 * @swagger
 * /api/v1/ai/cohere/command-plus:
 *   get:
 *     summary: Cohere AI
 *     tags: [AI]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: User's input query
 *         schema:
 *           type: string
 *       - in: query
 *         name: system_prompt
 *         required: false
 *         description: Custom system prompt
 *         schema:
 *           type: string
 *       - in: query
 *         name: chatHistory
 *         required: false
 *         description: Previous chat history in JSON format
 *         schema:
 *           type: string
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/cohere/command-plus', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        const chatHistory = req.query.chatHistory ? JSON.parse(req.query.chatHistory) : [];
        const system_prompt = req.query.system_prompt || "Your name is AkenoX AI A kind and friendly AI assistant that answers in a short and concise answer. Give short step-by-step reasoning if required.";

        const results = await CohereAI(query, {
          system_prompt: system_prompt,
          chatHistory: chatHistory
        });

        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});

/**
 * @swagger
 * /api/v1/ai/nvidia/llama-31-70b:
 *   get:
 *     summary: Nvidia LLama AI
 *     tags: [AI]
 *     parameters:
 *       - in: query
 *         name: query
 *         required: true
 *         description: null
 *         schema:
 *           type: string
 *       - in: query
 *         name: system_prompt
 *         required: false
 *         description: null
 *         schema:
 *           type: string
 *       - in: header
 *         name: x-api-key
 *         required: true
 *         description: API key for authentication
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Success
 */
GptRoutes.get('/api/v1/ai/nvidia/llama-31-70b', authenticateApiKeyPremium, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        let system_prompt = "Your name is AkenoX AI A kind and friendly AI assistant that answers in\na short and concise answer. Give short step-by-step reasoning if required.\n";
        system_prompt = req.query.system_prompt ? req.query.system_prompt : system_prompt;
        const results = await NvidiaTogether(query, {
          system_prompt: system_prompt
        });
        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
});

/* GptRoutes.get('/api/v1/ai/openai/gpt-4o', authenticateApiKey, apiLimiter, async (req, res) => {
    try {
        const query = req.query.query;
        const results = await OpenaiRes(query);
        res.json({ results });
    } catch (error) {
        res.status(401).json({ error: error.message });
    }
}); */

export { GptRoutes };