Update server.js

server.js

@@ -6,12 +6,17 @@ import { Readable } from 'stream';
 const app = express();
 const PORT = 7860;
 
-// Configuración para que funcione el límite de IPs en Hugging Face Spaces
 app.set('trust proxy', 1);
-
 app.use(cors());
 app.use(express.json());
 
+// --- FUNCIÓN DE LOGS (RESPETANDO PRIVACIDAD) ---
+// Solo se llama cuando algo falla, omitiendo IPs y mensajes (prompts).
+function logError(providerId, reason) {
+    const timestamp = new Date().toISOString();
+    console.error(`[${timestamp}] [ERROR] Proveedor: ${providerId} | Motivo: ${reason}`);
+}
+
 // --- CONFIGURACIÓN DE PROVEEDORES ---
 const PROVIDERS = [
     { 
@@ -19,18 +24,17 @@ const PROVIDERS = [
         url: "https://api.llm7.io/v1/chat/completions" 
     },
     { 
-        // Nuevo proveedor: Pollinations AI
         id: "pollinations", 
         url: "https://text.pollinations.ai/openai", 
-        modelsUrl: "https://text.pollinations.ai/models" // Ruta específica para extraer modelos
+        modelsUrl: "https://text.pollinations.ai/models",
+        imageUrl: "https://text.pollinations.ai/openai" // Soporte compatible
     },
     { 
-        // Nuevo proveedor gratuito y sin key
         id: "airforce", 
-        url: "https://api.airforce/v1/chat/completions" 
+        url: "https://api.airforce/v1/chat/completions",
+        imageUrl: "https://api.airforce/v1/images/generations" // Soporte de imágenes
     },
     { 
-        // Tu espejo seguro
         id: "ventarys-mirror", 
         url: "https://ventarys-mirror-1.hf.space/v1/chat/completions", 
         proxySecret: "sk-52650650a50f0v10vg150vs0v" 
@@ -55,8 +59,6 @@ function isModelAllowed(modelId, modelObj = null) {
 
 let currentLoad = { "llm7": 0, "pollinations": 0, "airforce": 0, "ventarys-mirror": 0 };
 
-// --- LÍMITE DE TASA (Para producción en ventarys.net) ---
-// Te lo subí a 25 peticiones por minuto para que tus usuarios no se topen con el error 429
 const limiter = rateLimit({
     windowMs: 60 * 1000, 
     max: 25, 
@@ -75,11 +77,9 @@ app.get('/health', (req, res) => {
     });
 });
 
-// --- EXTRACCIÓN Y FILTRO DE MODELOS MULTIPROVEEDOR ---
 app.get('/v1/models', async (req, res) => {
     try {
         const fetchPromises = PROVIDERS.map(async (provider) => {
-            // Usa la URL específica de modelos si existe, si no, deduce la estándar
             const modelsUrl = provider.modelsUrl || provider.url.replace("/chat/completions", "/models");
             const fetchHeaders = { "Content-Type": "application/json" };
             
@@ -87,13 +87,14 @@ app.get('/v1/models', async (req, res) => {
             if (provider.proxySecret) fetchHeaders["X-Proxy-Secret"] = provider.proxySecret;
 
             const resp = await fetch(modelsUrl, { method: "GET", headers: fetchHeaders });
-            if (!resp.ok) throw new Error(`HTTP Error ${resp.status}`);
+            if (!resp.ok) {
+                logError(provider.id, `Fallo al recuperar modelos (HTTP ${resp.status})`);
+                throw new Error(`HTTP Error ${resp.status}`);
+            }
             
             const json = await resp.json();
             let modelsArray = [];
 
-            // Traductor automático: Algunas APIs devuelven un array directo (Pollinations), 
-            // otras devuelven un objeto con la propiedad "data" (OpenAI Standard)
             if (Array.isArray(json)) {
                 modelsArray = json; 
             } else if (json && Array.isArray(json.data)) {
@@ -105,7 +106,7 @@ app.get('/v1/models', async (req, res) => {
                     .filter(model => isModelAllowed(model.id || model.name, model))
                     .map(model => ({
                         ...model,
-                        id: model.id || model.name, // Asegura que tu frontend siempre vea un "id"
+                        id: model.id || model.name,
                         owned_by: provider.id 
                     }));
             }
@@ -120,6 +121,7 @@ app.get('/v1/models', async (req, res) => {
 
         res.json({ object: "list", data: allModels });
     } catch (error) {
+        logError("ProxyMain", "Error crítico al agrupar la lista de modelos.");
         res.status(500).json({ error: "No se pudieron recuperar los modelos." });
     }
 });
@@ -129,8 +131,8 @@ app.post(['/v1/chat/completions', '/v1/images/generations'], limiter, async (req
     const isImage = req.path === '/v1/images/generations';
     const requestedModel = req.body.model;
 
-    // Filtro de Seguridad de Tiers
     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 (Premium/Pro).`, 
@@ -143,7 +145,6 @@ app.post(['/v1/chat/completions', '/v1/images/generations'], limiter, async (req
     const startTime = Date.now();
     let selectedProvider = null;
 
-    // Sala de Espera / Balanceo
     while (Date.now() - startTime < QUEUE_TIMEOUT) {
         let shuffled = [...availableProviders].sort(() => Math.random() - 0.5);
         for (let provider of shuffled) {
@@ -158,10 +159,10 @@ app.post(['/v1/chat/completions', '/v1/images/generations'], limiter, async (req
     }
 
     if (!selectedProvider) {
+        logError("ProxyMain", "Saturación - Todas las APIs están ocupadas (Cola llena)");
         return res.status(503).json({ error: { message: "Todas las APIs están ocupadas. Por favor, reintenta.", code: 503 } });
     }
 
-    // Función segura para liberar el Slot
     let isReleased = false;
     const releaseSlot = () => {
         if (!isReleased) {
@@ -183,13 +184,58 @@ app.post(['/v1/chat/completions', '/v1/images/generations'], limiter, async (req
             body: JSON.stringify(req.body)
         });
 
+        // Registrar si la API del proveedor devuelve un error (sin registrar el prompt)
+        if (!response.ok) {
+            logError(selectedProvider.id, `Respuesta HTTP ${response.status} - ${response.statusText}`);
+        }
+
+        // --- MANEJO DE IMÁGENES (Conversión a Base64) ---
         if (isImage) {
-            const responseData = await response.text();
-            releaseSlot();
-            return res.status(response.status).type('application/json').send(responseData);
+            const contentType = response.headers.get("content-type") || "";
+
+            // Caso 1: Devuelve un JSON estándar (Posiblemente con URL en lugar de b64_json)
+            if (contentType.includes("application/json")) {
+                const jsonResp = await response.json();
+                
+                if (jsonResp.data && Array.isArray(jsonResp.data)) {
+                    for (let item of jsonResp.data) {
+                        // Si la API nos devolvió una URL en vez de base64, la convertimos nosotros
+                        if (item.url && !item.b64_json) {
+                            try {
+                                const imgRes = await fetch(item.url);
+                                const arrayBuffer = await imgRes.arrayBuffer();
+                                item.b64_json = Buffer.from(arrayBuffer).toString('base64');
+                                delete item.url; // Quitamos la URL para dejar tu app limpia
+                            } catch (e) {
+                                logError(selectedProvider.id, `Fallo al convertir la URL de imagen a Base64: ${e.message}`);
+                            }
+                        }
+                    }
+                }
+                releaseSlot();
+                return res.status(response.status).json(jsonResp);
+            } 
+            // Caso 2: Devuelve la imagen cruda (Ej: Pollinations genera binarios directos a veces)
+            else if (contentType.includes("image/")) {
+                const arrayBuffer = await response.arrayBuffer();
+                const b64 = Buffer.from(arrayBuffer).toString('base64');
+                releaseSlot();
+                
+                // Lo empaquetamos como si fuera un JSON estándar de OpenAI
+                return res.status(200).json({
+                    created: Math.floor(Date.now() / 1000),
+                    data: [{ b64_json: b64 }]
+                });
+            } 
+            // Caso 3: Fallo catastrófico u otro texto
+            else {
+                const textResp = await response.text();
+                releaseSlot();
+                return res.status(response.status).type(contentType).send(textResp);
+            }
         } 
         
-        // Manejo de Streaming para Chat
+        // --- MANEJO DE CHAT (Streaming) ---
         res.writeHead(response.status, {
             'Content-Type': response.headers.get('content-type') || 'text/event-stream',
             'Cache-Control': 'no-cache',
@@ -201,7 +247,10 @@ app.post(['/v1/chat/completions', '/v1/images/generations'], limiter, async (req
             stream.pipe(res);
             
             stream.on('end', releaseSlot);
-            stream.on('error', releaseSlot);
+            stream.on('error', (err) => {
+                logError(selectedProvider.id, `Stream roto a mitad de la respuesta: ${err.message}`);
+                releaseSlot();
+            });
             req.on('close', releaseSlot); 
         } else {
             releaseSlot();
@@ -210,10 +259,11 @@ app.post(['/v1/chat/completions', '/v1/images/generations'], limiter, async (req
 
     } catch (err) {
         releaseSlot();
-        res.status(500).json({ error: `Error de conexión con la API de ${selectedProvider.id}.` });
+        logError(selectedProvider.id, `Fallo de red o Timeout conectando al proveedor: ${err.message}`);
+        res.status(500).json({ error: `Error de conexión interna.` });
     }
 });
 
 app.listen(PORT, '0.0.0.0', () => {
-    console.log(`🚀 API Main Proxy (Node.js) corriendo en el puerto ${PORT}`);
+    console.log(`🚀 API Proxy (Node.js) corriendo seguro en el puerto ${PORT}`);
 });