Update server.js

server.js

@@ -141,4 +141,210 @@ app.get('/v1/models', async (req, res) => {
     try {
         const allModels = await fetchAllModels();
         const textModels = allModels
-            .filter(m => !isImageModel(m)
+            .filter(m => !isImageModel(m) && m.supports_chat !== false)
+            .map(m => { m.type = 'text'; return m; });
+        res.json({ object: "list", data: textModels });
+    } catch (error) {
+        res.status(500).json({ error: "No models available." });
+    }
+});
+
+app.get('/v1/images/models', async (req, res) => {
+    try {
+        const allModels = await fetchAllModels();
+        let imageModels = allModels
+            .filter(m => isImageModel(m))
+            .map(m => { m.type = 'image'; return m; });
+            
+        const baseImages = [
+            { id: "flux", object: "model", type: "image", owned_by: "system" },
+            { id: "dall-e-3", object: "model", type: "image", owned_by: "system" }
+        ];
+        
+        baseImages.forEach(baseMod => {
+            if (!imageModels.find(m => m.id.toLowerCase() === baseMod.id)) imageModels.push(baseMod);
+        });
+        
+        res.json({ object: "list", data: imageModels });
+    } catch (error) {
+        res.status(500).json({ error: "No models available." });
+    }
+});
+
+app.post(['/v1/chat/completions', '/v1/images/generations'], limiter, async (req, res) => {
+    const isImage = req.path === '/v1/images/generations';
+    let availableProviders = isImage ? PROVIDERS.filter(p => p.imageUrl) : [...PROVIDERS];
+    if (isImage && availableProviders.length === 0) availableProviders = [...PROVIDERS];
+    
+    const startTime = Date.now();
+    let responseSent = false;
+    
+    // Extraemos la IP del cliente para reenviarla
+    const clientIp = req.ip || req.headers['x-forwarded-for'] || req.socket.remoteAddress;
+    
+    let payload = JSON.stringify(req.body); 
+    req.body = null; 
+    
+    while (availableProviders.length > 0 && Date.now() - startTime < QUEUE_TIMEOUT) {
+        let selectedProvider = null;
+        let shuffled = [...availableProviders].sort(() => Math.random() - 0.5);
+        
+        for (let provider of shuffled) {
+            if (currentLoad[provider.id] < MAX_PER_PROVIDER) {
+                selectedProvider = provider;
+                currentLoad[provider.id]++;
+                break;
+            }
+        }
+        
+        if (!selectedProvider) {
+            await new Promise(r => setTimeout(r, 1500));
+            continue;
+        }
+        
+        let isReleased = false;
+        const releaseSlot = () => {
+            if (!isReleased) {
+                currentLoad[selectedProvider.id] = Math.max(0, currentLoad[selectedProvider.id] - 1);
+                isReleased = true;
+            }
+        };
+        
+        try {
+            let targetUrl = isImage && selectedProvider.imageUrl ? selectedProvider.imageUrl : selectedProvider.url;
+            
+            // --- OFUSCACIÓN + DELEGACIÓN DE IP ---
+            const fetchHeaders = { 
+                "Content-Type": "application/json",
+                "User-Agent": getRandomUserAgent(),
+                "Accept": "*/*",
+                "Connection": "keep-alive",
+                "X-Forwarded-For": clientIp, // El proveedor rate-limitea esta IP
+                "X-Real-IP": clientIp        // El proveedor rate-limitea esta IP
+            };
+
+            // 🔥 INYECCIÓN DE DUMMY KEY PARA VOIDS-API 🔥
+            if (selectedProvider.id === "voids-api") {
+                fetchHeaders["Authorization"] = "Bearer sk-dummy-voids-key-12345";
+            }
+            
+            const response = await fetch(targetUrl, {
+                method: "POST",
+                headers: fetchHeaders,
+                body: payload
+            });
+            
+            if (!response.ok) {
+                releaseSlot();
+                availableProviders = availableProviders.filter(p => p.id !== selectedProvider.id);
+                continue; 
+            }
+            
+            const responseHeaders = new Headers(response.headers);
+            responseHeaders.delete('set-cookie');
+            responseHeaders.delete('server');
+            responseHeaders.delete('x-powered-by');
+            responseHeaders.delete('cf-ray');
+            responseHeaders.delete('access-control-allow-origin'); 
+            
+            if (isImage) {
+                const contentType = responseHeaders.get("content-type") || "";
+                
+                if (contentType.includes("application/json")) {
+                    const jsonResp = await response.json();
+                    let dataArray = jsonResp.data;
+                    if (!dataArray && jsonResp.url) dataArray = [{ url: jsonResp.url }];
+                    
+                    if (dataArray && Array.isArray(dataArray)) {
+                        for (let item of dataArray) {
+                            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;
+                                } catch (e) {}
+                            }
+                        }
+                        releaseSlot();
+                        responseSent = true;
+                        payload = null; 
+                        
+                        return res.status(response.status).json({
+                            created: Math.floor(Date.now() / 1000),
+                            data: dataArray
+                        });
+                    }
+                    
+                    releaseSlot();
+                    responseSent = true;
+                    payload = null;
+                    return res.status(response.status).json(jsonResp);
+                } 
+                else if (contentType.includes("image/")) {
+                    const arrayBuffer = await response.arrayBuffer();
+                    const b64 = Buffer.from(arrayBuffer).toString('base64');
+                    releaseSlot();
+                    responseSent = true;
+                    payload = null;
+                    return res.status(200).json({
+                        created: Math.floor(Date.now() / 1000),
+                        data: [{ b64_json: b64 }]
+                    });
+                } 
+                else {
+                    const textResp = await response.text();
+                    releaseSlot();
+                    responseSent = true;
+                    payload = null;
+                    return res.status(response.status).type(contentType).send(textResp);
+                }
+            } 
+            
+            res.writeHead(response.status, {
+                'Content-Type': responseHeaders.get('content-type') || 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive'
+            });
+            
+            if (response.body) {
+                const stream = Readable.fromWeb(response.body);
+                stream.pipe(res);
+                
+                stream.on('end', () => {
+                    releaseSlot();
+                    payload = null; 
+                });
+                stream.on('error', () => {
+                    releaseSlot();
+                    payload = null;
+                });
+                req.on('close', () => {
+                    releaseSlot();
+                    payload = null;
+                }); 
+            } else {
+                releaseSlot();
+                payload = null;
+                res.end();
+            }
+            
+            responseSent = true;
+            return; 
+            
+        } catch (err) {
+            releaseSlot();
+            availableProviders = availableProviders.filter(p => p.id !== selectedProvider.id);
+        }
+    }
+    
+    payload = null;
+    
+    if (!responseSent) {
+        return res.status(503).json({ error: { message: "Servicio no disponible.", code: 503 } });
+    }
+});
+
+app.listen(PORT, '0.0.0.0', () => {
+    console.log(`[SYS] Nivel de cifrado: Tor (Delegando IP). Concurrencia máxima: 500/prov. Puerto: ${PORT}`);
+});