Update server.js

server.js

@@ -1,8 +1,7 @@
 import express from 'express';
 import cors from 'cors';
 import rateLimit from 'express-rate-limit';
-import { Readable, Transform } from 'stream';
-import crypto from 'crypto';
+import { DuckDuckGoChat, Models } from 'duckduckgo-chat-interface';
 
 const app = express();
 const PORT = 7860;
@@ -25,174 +24,99 @@ app.use((req, res, next) => {
 app.use(express.json({ limit: '50mb' }));
 app.use(express.urlencoded({ limit: '50mb', extended: true }));
 
-// 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"
-    ];
-    return agents[Math.floor(Math.random() * agents.length)];
-}
-
-// 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"
-};
-
-// --- RATE LIMITING ---
+// --- RATE LIMITING LOCAL ---
 const limiter = rateLimit({
     windowMs: 60 * 1000, 
     max: 50, 
     keyGenerator: (req) => req.ip, 
-    message: { error: { message: "Too many requests local.", code: 429 } },
+    message: { error: { message: "Too many requests.", code: 429 } },
     standardHeaders: false, 
     legacyHeaders: false,
 });
 
 app.get('/health', (req, res) => {
-    res.json({ status: "online", proxy: "DuckDuckGo AI" }); 
+    res.json({ status: "online", proxy: "DuckDuckGo Library", node_module: "duckduckgo-chat-interface" }); 
 });
 
-// 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 });
+    res.json({
+        object: "list",
+        data: [
+            { id: "gpt-4o-mini", object: "model", type: "text", owned_by: "duckduckgo" },
+            { id: "claude-3-haiku", object: "model", type: "text", owned_by: "duckduckgo" },
+            { id: "llama-3.1-70b", object: "model", type: "text", owned_by: "duckduckgo" },
+            { id: "mixtral-8x7b", object: "model", type: "text", owned_by: "duckduckgo" }
+        ]
+    });
 });
 
 app.post('/v1/chat/completions', limiter, async (req, res) => {
-    const startTime = Date.now();
-    const clientIp = req.ip || req.headers['x-forwarded-for'] || req.socket.remoteAddress;
-    
-    // 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 
-            }
-        });
+        const { model = "gpt-4o-mini", messages, stream } = req.body;
         
-        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 }});
-        }
-
-        // 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": "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 }});
-        }
+        // 1. Mapear tu string de modelo al Enum que usa la librería
+        let chatModel = Models.GPT4Mini;
+        if (model.includes("claude")) chatModel = Models.Claude3Haiku;
+        if (model.includes("llama")) chatModel = Models.Llama3_3_70B;
+        if (model.includes("mistral") || model.includes("mixtral")) chatModel = Models.MistralSmall;
+
+        // 2. Inicializar la sesión de DuckDuckGo
+        const chat = new DuckDuckGoChat(chatModel);
+        await chat.initialize();
+        
+        // Extraemos solo el mensaje del usuario (DuckDuckGo no soporta bien historiales complejos por API sin manejo avanzado)
+        // Concatenamos el historial para darle contexto al modelo si hay varios mensajes.
+        const fullPrompt = messages.map(m => `${m.role}: ${m.content}`).join('\n\n');
 
-        // 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");
-            
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done) break;
-                
-                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 */ }
-                    }
-                }
-            }
-            
+        // 3A. Modo Texto Completo (No Streaming)
+        if (!stream) {
+            const response = await chat.sendMessage(fullPrompt);
             return res.json({
-                id: 'chatcmpl-' + crypto.randomUUID(),
+                id: 'chatcmpl-' + Date.now(),
                 object: 'chat.completion',
                 created: Math.floor(Date.now() / 1000),
-                model: requestedModel,
-                choices: [{ message: { role: 'assistant', content: fullText }, finish_reason: 'stop' }]
+                model: model,
+                choices: [{ message: { role: 'assistant', content: response }, finish_reason: 'stop' }]
             });
         }
 
-        // PASO 3B: Manejar Petición STREAMING (Traducir sobre la marcha DDG -> OpenAI)
+        // 3B. Modo Streaming (Traducción en tiempo real a 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();
-            }
+        await chat.sendMessageStream(fullPrompt, (chunk) => {
+            const data = {
+                id: 'chatcmpl-' + Date.now(),
+                object: 'chat.completion.chunk',
+                created: Math.floor(Date.now() / 1000),
+                model: model,
+                choices: [{ delta: { content: chunk } }]
+            };
+            res.write(`data: ${JSON.stringify(data)}\n\n`);
         });
 
-        const stream = Readable.fromWeb(chatRes.body);
-        stream.pipe(ddgToOpenAI).pipe(res);
+        res.write('data: [DONE]\n\n');
+        res.end();
 
     } catch (err) {
-        console.error("[ERROR]", err.message);
+        console.error("[DDG LIBRARY ERROR]", err);
+        const statusCode = err.message.includes('503') ? 503 : 500;
+        
         if (!res.headersSent) {
-            res.status(500).json({ error: { message: "Error interno del servidor", details: err.message, code: 500 }});
+            res.status(statusCode).json({ 
+                error: { 
+                    message: "Error de proveedor. Si recibes 503 constantemente, Cloudflare está bloqueando la IP de Hugging Face.", 
+                    details: err.message,
+                    code: statusCode 
+                } 
+            });
         }
     }
 });
 
 app.listen(PORT, '0.0.0.0', () => {
-    console.log(`[SYS] DuckDuckGo AI Proxy Activo. Modelos: GPT-4o-mini, Claude-3-Haiku, Llama-3.1-70b. Puerto: ${PORT}`);
+    console.log(`[SYS] DuckDuckGo Library Node.js Server Ready. Puerto: ${PORT}`);
 });