Update server.js

server.js

@@ -1,14 +1,13 @@
 import express from 'express';
 import cors from 'cors';
 import rateLimit from 'express-rate-limit';
-import { Readable } from 'stream';
+import { Readable, Transform } from 'stream';
 import crypto from 'crypto';
 
 const app = express();
 const PORT = 7860;
 
-// --- 1. CONFIGURACIÓN DE SEGURIDAD PARANOICA ---
-// CRÍTICO: trust proxy en 1 es vital para leer la IP real del usuario a través de Cloudflare/HF
+// --- CONFIGURACIÓN DE SEGURIDAD ---
 app.set('trust proxy', 1);
 app.disable('x-powered-by'); 
 app.use(cors());
@@ -18,7 +17,7 @@ app.use((req, res, next) => {
     res.setHeader('X-Frame-Options', 'DENY');
     res.setHeader('X-XSS-Protection', '1; mode=block');
     res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains; preload');
-    res.setHeader('Referrer-Policy', 'no-referrer'); // Oculta que vienen de Ventarys AI
+    res.setHeader('Referrer-Policy', 'no-referrer'); 
     res.setHeader('Content-Security-Policy', "default-src 'none'; frame-ancestors 'none';");
     next();
 });
@@ -26,333 +25,174 @@ app.use((req, res, next) => {
 app.use(express.json({ limit: '50mb' }));
 app.use(express.urlencoded({ limit: '50mb', extended: true }));
 
-function logError(providerId, reason) {
-    console.error(`[SYSTEM] Provider Error: ${providerId} | ${reason}`);
-}
-
-// Falsificación de huella digital del navegador
+// Falsificación de huella digital
 function getRandomUserAgent() {
     const agents = [
         "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
         "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15",
-        "Mozilla/5.0 (X11; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/119.0",
-        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36 Edg/119.0.0.0"
+        "Mozilla/5.0 (X11; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/119.0"
     ];
     return agents[Math.floor(Math.random() * agents.length)];
 }
 
-// --- PROVEEDORES PÚBLICOS ---
-const PROVIDERS = [
-    { 
-        id: "pollinations-ai", 
-        url: "https://text.pollinations.ai/openai/v1/chat/completions",
-        modelsUrl: "https://text.pollinations.ai/openai/models"
-    },
-    { 
-        id: "kepler-cloud", 
-        url: "https://oai.endpoints.kepler.ai.cloud.ovh.net/v1/chat/completions" 
-    },
-    {
-        // Proveedor público alternativo "Airforce" (reemplaza a churchless)
-        id: "airforce-api",
-        url: "https://api.airforce/v1/chat/completions",
-        modelsUrl: "https://api.airforce/v1/models"
-    }
-];
+// Modelos soportados por DuckDuckGo AI
+const DDG_MODELS = {
+    "gpt-4o-mini": "gpt-4o-mini",
+    "claude-3-haiku": "claude-3-haiku-20240307",
+    "llama-3.1-70b": "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo",
+    "mixtral-8x7b": "mistralai/Mixtral-8x7B-Instruct-v0.1"
+};
 
-// CRÍTICO: Subimos el límite a 500 para permitir alta concurrencia.
-// Ahora el proxy dejará pasar todo el tráfico y el proveedor final aplicará el rate limit por IP.
-const MAX_PER_PROVIDER = 500; 
-const QUEUE_TIMEOUT = 45000; 
-let currentLoad = { "pollinations-ai": 0, "kepler-cloud": 0, "airforce-api": 0 };
-
-// --- RATE LIMITING LOCAL ---
+// --- RATE LIMITING ---
 const limiter = rateLimit({
     windowMs: 60 * 1000, 
-    max: 50, // 50 peticiones por IP localmente para evitar que alguien tire TU servidor
+    max: 50, 
     keyGenerator: (req) => req.ip, 
-    message: { error: { message: "Too many requests.", code: 429 } },
+    message: { error: { message: "Too many requests local.", code: 429 } },
     standardHeaders: false, 
     legacyHeaders: false,
 });
 
-const IMAGE_KEYWORDS = ["flux", "dall", "midjourney", "sdxl", "stable-diffusion", "image", "vision"];
-const AUDIO_KEYWORDS = ["suno", "udio", "music", "audio", "song", "voice", "tts", "whisper"];
-
-function isImageModel(model) {
-    if (!model) return false;
-    if (model.type === 'image' || model.supports_images === true) return true;
-    return IMAGE_KEYWORDS.some(kw => (model.id || model.name || "").toLowerCase().includes(kw));
-}
-
-function isAudioModel(model) {
-    if (model.type === 'audio' || model.type === 'music') return true;
-    return AUDIO_KEYWORDS.some(kw => (model.id || model.name || "").toLowerCase().includes(kw));
-}
-
-async function fetchAllModels() {
-    const fetchPromises = PROVIDERS.map(async (provider) => {
-        const modelsUrl = provider.modelsUrl || provider.url.replace("/chat/completions", "/models");
-        
-        try {
-            const resp = await fetch(modelsUrl, { 
-                method: "GET", 
-                headers: { 
-                    "Content-Type": "application/json",
-                    "User-Agent": getRandomUserAgent() 
-                } 
-            });
-            if (!resp.ok) return [];
-            
-            const json = await resp.json();
-            let modelsArray = Array.isArray(json) ? json : (json && Array.isArray(json.data) ? json.data : []);
-            
-            if (modelsArray.length > 0) {
-                // FILTRO: Excluir modelos de audio
-                let filteredModels = modelsArray.filter(model => !isAudioModel(model));
-
-                // 🔥 FILTRO ESPECÍFICO PARA KEPLER-CLOUD (SOLO FREE) 🔥
-                if (provider.id === "kepler-cloud") {
-                    filteredModels = filteredModels.filter(model => {
-                        const mId = (model.id || model.name || "").toLowerCase();
-                        // Filtra si el ID incluye la palabra "free" o si tiene un flag de coste cero
-                        return mId.includes("free") || model.is_free === true || model.pricing?.prompt === "0";
-                    });
-                }
-
-                return filteredModels.map(model => ({ ...model, id: model.id || model.name, owned_by: provider.id }));
-            }
-            return [];
-        } catch (error) {
-            return [];
-        }
-    });
-    
-    const results = await Promise.allSettled(fetchPromises);
-    let allModels = [];
-    results.forEach(result => {
-        if (result.status === "fulfilled") allModels = allModels.concat(result.value);
-    });
-    
-    // Fallback de seguridad si todas las APIs fallan al cargar modelos
-    if (allModels.length === 0) {
-        allModels = [
-            { id: "gpt-4o", object: "model", type: "text", owned_by: "pollinations-ai" },
-            { id: "claude-3-5-sonnet", object: "model", type: "text", owned_by: "pollinations-ai" },
-            { id: "gemini-1.5-pro", object: "model", type: "text", owned_by: "airforce-api" },
-            { id: "gemini-1.5-flash", object: "model", type: "text", owned_by: "airforce-api" }
-        ];
-    }
-    return allModels;
-}
-
 app.get('/health', (req, res) => {
-    res.json({ status: "online" }); 
+    res.json({ status: "online", proxy: "DuckDuckGo AI" }); 
 });
 
-app.get('/v1/models', async (req, res) => {
-    try {
-        const allModels = await fetchAllModels();
-        const textModels = allModels
-            .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." });
-    }
+// Endpoint de modelos (Formato OpenAI)
+app.get('/v1/models', (req, res) => {
+    const models = Object.keys(DDG_MODELS).map(id => ({
+        id: id,
+        object: "model",
+        type: "text",
+        owned_by: "duckduckgo"
+    }));
+    res.json({ object: "list", data: models });
 });
 
-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];
-    
+app.post('/v1/chat/completions', limiter, async (req, res) => {
     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;
+    // Configuración del modelo y mensajes
+    const requestedModel = req.body.model || "gpt-4o-mini";
+    const duckModel = DDG_MODELS[requestedModel] || "gpt-4o-mini";
+    const messages = req.body.messages || [];
+    const isStream = req.body.stream === true;
+
+    try {
+        // PASO 1: Obtener el token (VQD) necesario para chatear
+        const statusRes = await fetch("https://duckduckgo.com/duckchat/v1/status", {
+            headers: { 
+                "x-vqd-accept": "1", 
+                "User-Agent": getRandomUserAgent(),
+                "x-forwarded-for": clientIp 
             }
-        }
+        });
         
-        if (!selectedProvider) {
-            await new Promise(r => setTimeout(r, 1500));
-            continue;
+        const vqdToken = statusRes.headers.get("x-vqd-4");
+        if (!vqdToken) {
+            return res.status(503).json({ error: { message: "Error al negociar token con DuckDuckGo", code: 503 }});
         }
-        
-        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 = { 
+
+        // PASO 2: Enviar el prompt a DuckDuckGo
+        const chatRes = await fetch("https://duckduckgo.com/duckchat/v1/chat", {
+            method: "POST",
+            headers: {
                 "Content-Type": "application/json",
+                "x-vqd-4": vqdToken,
                 "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
-            };
-            
-            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'); 
+                "Accept": "text/event-stream",
+                "x-forwarded-for": clientIp
+            },
+            body: JSON.stringify({
+                model: duckModel,
+                messages: messages
+            })
+        });
+
+        if (!chatRes.ok) {
+            const errorText = await chatRes.text();
+            return res.status(chatRes.status).json({ error: { message: `DuckDuckGo Error: ${errorText}`, code: chatRes.status }});
+        }
+
+        // PASO 3A: Manejar Petición NO STREAM (Esperar y juntar todo el texto)
+        if (!isStream) {
+            let fullText = "";
+            const reader = chatRes.body.getReader();
+            const decoder = new TextDecoder("utf-8");
             
-            if (isImage) {
-                const contentType = responseHeaders.get("content-type") || "";
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
                 
-                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
-                        });
+                const chunkStr = decoder.decode(value, { stream: true });
+                const lines = chunkStr.split('\n');
+                for (let line of lines) {
+                    if (line.startsWith('data: ') && line !== 'data: [DONE]') {
+                        try {
+                            const data = JSON.parse(line.slice(6));
+                            if (data.message) fullText += data.message;
+                        } catch (e) { /* Ignorar chunks rotos */ }
                     }
-                    
-                    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'
+            return res.json({
+                id: 'chatcmpl-' + crypto.randomUUID(),
+                object: 'chat.completion',
+                created: Math.floor(Date.now() / 1000),
+                model: requestedModel,
+                choices: [{ message: { role: 'assistant', content: fullText }, finish_reason: 'stop' }]
             });
-            
-            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();
+        }
+
+        // PASO 3B: Manejar Petición STREAMING (Traducir sobre la marcha DDG -> OpenAI)
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive'
+        });
+
+        let buffer = '';
+        const ddgToOpenAI = new Transform({
+            transform(chunk, encoding, callback) {
+                buffer += chunk.toString();
+                const lines = buffer.split('\n');
+                buffer = lines.pop(); // Guarda el fragmento incompleto para el próximo chunk
+
+                for (const line of lines) {
+                    if (line.startsWith('data: ') && line !== 'data: [DONE]') {
+                        try {
+                            const data = JSON.parse(line.slice(6));
+                            if (data.message) {
+                                const openaiChunk = {
+                                    id: 'chatcmpl-' + crypto.randomUUID(),
+                                    object: 'chat.completion.chunk',
+                                    created: Math.floor(Date.now() / 1000),
+                                    model: requestedModel,
+                                    choices: [{ delta: { content: data.message } }]
+                                };
+                                this.push(`data: ${JSON.stringify(openaiChunk)}\n\n`);
+                            }
+                        } catch (e) { /* Ignorar errores de parseo parcial */ }
+                    } else if (line === 'data: [DONE]') {
+                        this.push('data: [DONE]\n\n');
+                    }
+                }
+                callback();
             }
-            
-            responseSent = true;
-            return; 
-            
-        } catch (err) {
-            releaseSlot();
-            availableProviders = availableProviders.filter(p => p.id !== selectedProvider.id);
+        });
+
+        const stream = Readable.fromWeb(chatRes.body);
+        stream.pipe(ddgToOpenAI).pipe(res);
+
+    } catch (err) {
+        console.error("[ERROR]", err.message);
+        if (!res.headersSent) {
+            res.status(500).json({ error: { message: "Error interno del servidor", details: err.message, code: 500 }});
         }
     }
-    
-    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}`);
+    console.log(`[SYS] DuckDuckGo AI Proxy Activo. Modelos: GPT-4o-mini, Claude-3-Haiku, Llama-3.1-70b. Puerto: ${PORT}`);
 });