Update server.js

server.js

@@ -13,7 +13,7 @@ app.use(cors());
 app.use(express.json({ limit: '50mb' }));
 app.use(express.urlencoded({ limit: '50mb', extended: true }));
 
-// --- FUNCIÓN DE LOGS (RESPETANDO PRIVACIDAD) ---
+// --- FUNCIÓN DE LOGS ---
 function logError(providerId, reason) {
     const timestamp = new Date().toISOString();
     console.error(`[${timestamp}] [ERROR] Proveedor: ${providerId} | Motivo: ${reason}`);
@@ -46,19 +46,6 @@ const PROVIDERS = [
 const MAX_PER_PROVIDER = 3; 
 const QUEUE_TIMEOUT = 25000; 
 
-const BLOCKED_TIERS = ["pro", "premium", "ultra", "vip", "plus", "enterprise", "max"];
-
-function isModelAllowed(modelId, modelObj = null) {
-    if (!modelId) return true; 
-    const lowerId = modelId.toLowerCase();
-    if (modelObj && modelObj.tier) {
-        const tier = modelObj.tier.toLowerCase();
-        if (tier === "pro" || tier === "premium" || tier === "vip") return false;
-        if (tier === "free" || tier === "standard") return true;
-    }
-    return !BLOCKED_TIERS.some(keyword => lowerId.includes(keyword));
-}
-
 let currentLoad = { "llm7": 0, "pollinations": 0, "airforce": 0, "ventarys-mirror": 0 };
 
 const limiter = rateLimit({
@@ -69,30 +56,34 @@ const limiter = rateLimit({
     legacyHeaders: false,
 });
 
-// --- RUTAS INFORMATIVAS ---
-app.get('/health', (req, res) => {
-    res.json({ 
-        status: "online", 
-        type: "hf-node-proxy",
-        providers: PROVIDERS.map(p => p.id),
-        current_load: currentLoad 
-    });
-});
+// --- AYUDANTES PARA FILTRAR MODELOS ---
+const IMAGE_KEYWORDS = ["flux", "dall", "midjourney", "sdxl", "stable-diffusion", "image", "vision"];
+const AUDIO_KEYWORDS = ["suno", "udio", "music", "audio", "song", "voice", "tts"];
 
-app.get('/v1/models', async (req, res) => {
-    try {
-        const fetchPromises = PROVIDERS.map(async (provider) => {
-            const modelsUrl = provider.modelsUrl || provider.url.replace("/chat/completions", "/models");
-            const fetchHeaders = { "Content-Type": "application/json" };
-            
-            if (provider.apiKey) fetchHeaders["Authorization"] = `Bearer ${provider.apiKey}`;
-            if (provider.proxySecret) fetchHeaders["X-Proxy-Secret"] = provider.proxySecret;
+function isImageModel(id) {
+    if (!id) return false;
+    const lowerId = id.toLowerCase();
+    return IMAGE_KEYWORDS.some(kw => lowerId.includes(kw));
+}
+
+function isAudioModel(id, type) {
+    if (type === 'audio' || type === 'music') return true;
+    if (!id) return false;
+    const lowerId = id.toLowerCase();
+    return AUDIO_KEYWORDS.some(kw => lowerId.includes(kw));
+}
 
+async function fetchAllModels() {
+    const fetchPromises = PROVIDERS.map(async (provider) => {
+        const modelsUrl = provider.modelsUrl || provider.url.replace("/chat/completions", "/models");
+        const fetchHeaders = { "Content-Type": "application/json" };
+        
+        if (provider.apiKey) fetchHeaders["Authorization"] = `Bearer ${provider.apiKey}`;
+        if (provider.proxySecret) fetchHeaders["X-Proxy-Secret"] = provider.proxySecret;
+
+        try {
             const resp = await fetch(modelsUrl, { method: "GET", headers: fetchHeaders });
-            if (!resp.ok) {
-                logError(provider.id, `Fallo al recuperar modelos (HTTP ${resp.status})`);
-                return [];
-            }
+            if (!resp.ok) return [];
             
             const json = await resp.json();
             let modelsArray = [];
@@ -102,7 +93,8 @@ app.get('/v1/models', async (req, res) => {
 
             if (modelsArray.length > 0) {
                 return modelsArray
-                    .filter(model => isModelAllowed(model.id || model.name, model))
+                    // Eliminamos los modelos de música de raíz para que no ensucien ninguna lista
+                    .filter(model => !isAudioModel(model.id || model.name, model.type))
                     .map(model => ({
                         ...model,
                         id: model.id || model.name,
@@ -110,23 +102,71 @@ app.get('/v1/models', async (req, res) => {
                     }));
             }
             return [];
+        } catch (error) {
+            return [];
+        }
+    });
+
+    const results = await Promise.allSettled(fetchPromises);
+    let allModels = [];
+    results.forEach(result => {
+        if (result.status === "fulfilled") allModels = allModels.concat(result.value);
+    });
+    return allModels;
+}
+
+// --- RUTAS INFORMATIVAS ---
+app.get('/health', (req, res) => {
+    res.json({ 
+        status: "online", 
+        type: "hf-node-proxy",
+        providers: PROVIDERS.map(p => p.id),
+        current_load: currentLoad 
+    });
+});
+
+// Endpoint para modelos de TEXTO
+app.get('/v1/models', async (req, res) => {
+    try {
+        const allModels = await fetchAllModels();
+        // Filtrar modelos asegurando que NO sean de imágenes
+        const textModels = allModels.filter(m => !isImageModel(m.id) && m.type !== 'image').map(m => {
+            m.type = 'text'; // Forzar etiqueta
+            return m;
         });
 
-        const results = await Promise.allSettled(fetchPromises);
-        let allModels = [];
-        results.forEach(result => {
-            if (result.status === "fulfilled") allModels = allModels.concat(result.value);
+        res.json({ object: "list", data: textModels });
+    } catch (error) {
+        logError("ProxyMain", "Error recuperando modelos de texto.");
+        res.status(500).json({ error: "No se pudieron recuperar los modelos." });
+    }
+});
+
+// Endpoint para modelos de IMAGEN
+app.get('/v1/images/models', async (req, res) => {
+    try {
+        const allModels = await fetchAllModels();
+        // Filtrar modelos asegurando que SÍ sean de imágenes
+        let imageModels = allModels.filter(m => isImageModel(m.id) || m.type === 'image').map(m => {
+            m.type = 'image'; // Forzar etiqueta
+            return m;
         });
 
-        // Garantizar que la App siempre reconozca modelos de imágenes base
-        allModels.push(
-            { id: "flux", object: "model", type: "image", owned_by: "system" },
-            { id: "dall-e-3", object: "model", type: "image", owned_by: "system" }
-        );
+        // Garantizar que la App siempre reconozca los modelos base aunque la API origen no los liste
+        const baseImages = [
+            { id: "flux", object: "model", type: "image", owned_by: "system", tier: "standard" },
+            { id: "dall-e-3", object: "model", type: "image", owned_by: "system", tier: "standard" }
+        ];
 
-        res.json({ object: "list", data: allModels });
+        baseImages.forEach(baseMod => {
+            if (!imageModels.find(m => m.id.toLowerCase() === baseMod.id)) {
+                imageModels.push(baseMod);
+            }
+        });
+
+        res.json({ object: "list", data: imageModels });
     } catch (error) {
-        logError("ProxyMain", "Error crítico al agrupar la lista de modelos.");
+        logError("ProxyMain", "Error recuperando modelos de imagen.");
         res.status(500).json({ error: "No se pudieron recuperar los modelos." });
     }
 });
@@ -134,22 +174,12 @@ app.get('/v1/models', async (req, res) => {
 // --- RUTA PRINCIPAL DE GENERACIÓN ---
 app.post(['/v1/chat/completions', '/v1/images/generations'], limiter, async (req, res) => {
     const isImage = req.path === '/v1/images/generations';
-    const requestedModel = req.body.model;
-
-    if (requestedModel && !isModelAllowed(requestedModel)) {
-        logError("ProxyMain", `Bloqueado intento de uso de modelo premium: ${requestedModel}`);
-        return res.status(403).json({
-            error: { 
-                message: `Acceso denegado: El modelo '${requestedModel}' es de pago.`, 
-                type: "model_not_allowed", code: 403 
-            }
-        });
-    }
-
     const availableProviders = isImage ? PROVIDERS.filter(p => p.imageUrl) : PROVIDERS;
+    
     const startTime = Date.now();
     let selectedProvider = null;
 
+    // Sistema de cola inteligente
     while (Date.now() - startTime < QUEUE_TIMEOUT) {
         let shuffled = [...availableProviders].sort(() => Math.random() - 0.5);
         for (let provider of shuffled) {
@@ -185,12 +215,22 @@ app.post(['/v1/chat/completions', '/v1/images/generations'], limiter, async (req
         if (selectedProvider.apiKey) fetchHeaders["Authorization"] = `Bearer ${selectedProvider.apiKey}`;
         if (selectedProvider.proxySecret) fetchHeaders["X-Proxy-Secret"] = selectedProvider.proxySecret;
 
-        // Adaptador para Pollinations Imágenes (Usa URL GET en lugar de un Payload POST)
+        // Adaptador especializado para Pollinations Imágenes (Formato nativo GET)
         if (isImage && selectedProvider.id === "pollinations") {
             const prompt = req.body.prompt || "A random image";
             const seed = Math.floor(Math.random() * 10000000);
-            // Redirige al enpoint puro para obtener la imagen
-            targetUrl = `${targetUrl}/${encodeURIComponent(prompt)}?seed=${seed}&nologo=true`;
+            
+            // Extraer resolución del body (por defecto cuadrado si no se provee)
+            let width = 1024, height = 1024;
+            if (req.body.size) {
+                const parts = req.body.size.split('x');
+                if (parts.length === 2) { width = parseInt(parts[0]); height = parseInt(parts[1]); }
+            }
+            
+            // Ajustar el modelo si el usuario pidió uno en específico
+            const pollModel = req.body.model && req.body.model.includes('flux') ? 'flux' : 'dall-e-3';
+
+            targetUrl = `${targetUrl}/${encodeURIComponent(prompt)}?seed=${seed}&width=${width}&height=${height}&model=${pollModel}&nologo=true`;
             reqMethod = "GET";
             reqBody = undefined;
             delete fetchHeaders["Content-Type"];
@@ -206,16 +246,16 @@ app.post(['/v1/chat/completions', '/v1/images/generations'], limiter, async (req
             logError(selectedProvider.id, `Respuesta HTTP ${response.status} - ${response.statusText}`);
         }
 
-        // --- MANEJO DE IMÁGENES (Conversión a Base64) ---
+        // --- MANEJO EXCLUSIVO DE IMÁGENES (Estandarización a Base64 - Estilo Aqua AI) ---
         if (isImage) {
             const contentType = response.headers.get("content-type") || "";
 
             if (contentType.includes("application/json")) {
                 const jsonResp = await response.json();
                 
+                // Si la API remota nos responde con JSON, extraemos las URL para transformarlas a Base64
                 if (jsonResp.data && Array.isArray(jsonResp.data)) {
                     for (let item of jsonResp.data) {
-                        // Si nos devuelve URL en vez de base64, lo descargamos y convertimos para la app
                         if (item.url && !item.b64_json) {
                             try {
                                 const imgRes = await fetch(item.url);
@@ -231,26 +271,27 @@ app.post(['/v1/chat/completions', '/v1/images/generations'], limiter, async (req
                 releaseSlot();
                 return res.status(response.status).json(jsonResp);
             } 
-            // Manejo de la respuesta nativa de imágenes (Pollinations)
             else if (contentType.includes("image/")) {
+                // Si la API nos devuelve el binario directo (Ej. Pollinations)
                 const arrayBuffer = await response.arrayBuffer();
                 const b64 = Buffer.from(arrayBuffer).toString('base64');
                 releaseSlot();
                 
-                // Lo empaquetamos exactamente como tu frontend (OpenAI standard) lo espera
+                // Estandarizar respuesta para tu frontend (Aqua AI / OpenAI compatible)
                 return res.status(200).json({
                     created: Math.floor(Date.now() / 1000),
                     data: [{ b64_json: b64 }]
                 });
             } 
             else {
+                // Caída libre para errores o comportamientos inesperados de los proveedores
                 const textResp = await response.text();
                 releaseSlot();
                 return res.status(response.status).type(contentType).send(textResp);
             }
         } 
         
-        // --- MANEJO DE CHAT TEXTO (Streaming) ---
+        // --- MANEJO EXCLUSIVO DE TEXTO (Streaming) ---
         res.writeHead(response.status, {
             'Content-Type': response.headers.get('content-type') || 'text/event-stream',
             'Cache-Control': 'no-cache',