Update server.js

server.js

@@ -8,10 +8,12 @@ const PORT = 7860;
 
 app.set('trust proxy', 1);
 app.use(cors());
-app.use(express.json());
+
+// CRÍTICO: Aumentar límite a 50mb para soportar imágenes en Base64 (Visión / Multimodal)
+app.use(express.json({ limit: '50mb' }));
+app.use(express.urlencoded({ limit: '50mb', extended: true }));
 
 // --- 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}`);
@@ -27,7 +29,7 @@ const PROVIDERS = [
         id: "pollinations", 
         url: "https://text.pollinations.ai/openai", 
         modelsUrl: "https://text.pollinations.ai/models",
-        imageUrl: "https://text.pollinations.ai/openai" // Soporte compatible
+        imageUrl: "https://image.pollinations.ai/prompt" // Endpoint nativo de imágenes
     },
     { 
         id: "airforce", 
@@ -89,17 +91,14 @@ app.get('/v1/models', async (req, res) => {
             const resp = await fetch(modelsUrl, { method: "GET", headers: fetchHeaders });
             if (!resp.ok) {
                 logError(provider.id, `Fallo al recuperar modelos (HTTP ${resp.status})`);
-                throw new Error(`HTTP Error ${resp.status}`);
+                return [];
             }
             
             const json = await resp.json();
             let modelsArray = [];
 
-            if (Array.isArray(json)) {
-                modelsArray = json; 
-            } else if (json && Array.isArray(json.data)) {
-                modelsArray = json.data; 
-            }
+            if (Array.isArray(json)) modelsArray = json; 
+            else if (json && Array.isArray(json.data)) modelsArray = json.data; 
 
             if (modelsArray.length > 0) {
                 return modelsArray
@@ -119,6 +118,12 @@ app.get('/v1/models', async (req, res) => {
             if (result.status === "fulfilled") allModels = allModels.concat(result.value);
         });
 
+        // 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" }
+        );
+
         res.json({ object: "list", data: allModels });
     } catch (error) {
         logError("ProxyMain", "Error crítico al agrupar la lista de modelos.");
@@ -135,7 +140,7 @@ app.post(['/v1/chat/completions', '/v1/images/generations'], limiter, async (req
         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).`, 
+                message: `Acceso denegado: El modelo '${requestedModel}' es de pago.`, 
                 type: "model_not_allowed", code: 403 
             }
         });
@@ -159,7 +164,7 @@ 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)");
+        logError("ProxyMain", "Saturación - Todas las APIs están ocupadas");
         return res.status(503).json({ error: { message: "Todas las APIs están ocupadas. Por favor, reintenta.", code: 503 } });
     }
 
@@ -172,19 +177,31 @@ app.post(['/v1/chat/completions', '/v1/images/generations'], limiter, async (req
     };
 
     try {
-        const targetUrl = isImage ? selectedProvider.imageUrl : selectedProvider.url;
+        let targetUrl = isImage ? selectedProvider.imageUrl : selectedProvider.url;
+        let reqMethod = "POST";
+        let reqBody = JSON.stringify(req.body);
         const fetchHeaders = { "Content-Type": "application/json" };
         
         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)
+        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`;
+            reqMethod = "GET";
+            reqBody = undefined;
+            delete fetchHeaders["Content-Type"];
+        }
+
         const response = await fetch(targetUrl, {
-            method: "POST",
+            method: reqMethod,
             headers: fetchHeaders,
-            body: JSON.stringify(req.body)
+            body: reqBody
         });
 
-        // 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}`);
         }
@@ -193,21 +210,20 @@ app.post(['/v1/chat/completions', '/v1/images/generations'], limiter, async (req
         if (isImage) {
             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
+                        // 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);
                                 const arrayBuffer = await imgRes.arrayBuffer();
                                 item.b64_json = Buffer.from(arrayBuffer).toString('base64');
-                                delete item.url; // Quitamos la URL para dejar tu app limpia
+                                delete item.url;
                             } catch (e) {
-                                logError(selectedProvider.id, `Fallo al convertir la URL de imagen a Base64: ${e.message}`);
+                                logError(selectedProvider.id, `Fallo convirtiendo URL a Base64: ${e.message}`);
                             }
                         }
                     }
@@ -215,19 +231,18 @@ app.post(['/v1/chat/completions', '/v1/images/generations'], limiter, async (req
                 releaseSlot();
                 return res.status(response.status).json(jsonResp);
             } 
-            // Caso 2: Devuelve la imagen cruda (Ej: Pollinations genera binarios directos a veces)
+            // Manejo de la respuesta nativa de imágenes (Pollinations)
             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
+                // Lo empaquetamos exactamente como tu frontend (OpenAI standard) lo espera
                 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();
@@ -235,7 +250,7 @@ app.post(['/v1/chat/completions', '/v1/images/generations'], limiter, async (req
             }
         } 
         
-        // --- MANEJO DE CHAT (Streaming) ---
+        // --- MANEJO DE CHAT TEXTO (Streaming) ---
         res.writeHead(response.status, {
             'Content-Type': response.headers.get('content-type') || 'text/event-stream',
             'Cache-Control': 'no-cache',
@@ -248,7 +263,7 @@ app.post(['/v1/chat/completions', '/v1/images/generations'], limiter, async (req
             
             stream.on('end', releaseSlot);
             stream.on('error', (err) => {
-                logError(selectedProvider.id, `Stream roto a mitad de la respuesta: ${err.message}`);
+                logError(selectedProvider.id, `Stream roto a mitad de respuesta: ${err.message}`);
                 releaseSlot();
             });
             req.on('close', releaseSlot); 
@@ -259,8 +274,8 @@ app.post(['/v1/chat/completions', '/v1/images/generations'], limiter, async (req
 
     } catch (err) {
         releaseSlot();
-        logError(selectedProvider.id, `Fallo de red o Timeout conectando al proveedor: ${err.message}`);
-        res.status(500).json({ error: `Error de conexión interna.` });
+        logError(selectedProvider ? selectedProvider.id : "Proxy", `Fallo o Timeout conectando al proveedor: ${err.message}`);
+        res.status(500).json({ error: { message: "Error de conexión interna."} });
     }
 });