Update server.js

server.js

@@ -35,6 +35,13 @@ const withBenchmarking = (request) => {
   request.start = Date.now();
 };
 
+const getClientIP = (req) => {
+  return req.headers['x-forwarded-for']?.split(',')[0]?.trim() || 
+         req.headers['x-real-ip'] || 
+         req.socket?.remoteAddress || 
+         null;
+};
+
 const logger = (res, req) => {
   console.log(req.method, res.status, req.url, Date.now() - req.start, 'ms');
 };
@@ -45,9 +52,10 @@ const router = AutoRouter({
   finally: [corsify, logger],
 });
 
-router.get('/', () => json({ message: 'API Service Running!' }));
-router.get('/ping', () => json({ message: 'pong' }));
-router.get(config.API_PREFIX + 'v1/models', () =>
+router.get('/', (req) => json({ message: 'API Service Running!' }));
+router.get('/ping', (req) => json({ message: 'pong' }));
+
+router.get(config.API_PREFIX + 'v1/models', (req) =>
   json({
     object: 'list',
     data: [
@@ -67,21 +75,24 @@ async function handleCompletion(request) {
     const { model: inputModel, messages, stream: returnStream } = await request.json();
     const model = convertModel(inputModel);
     const content = messagesPrepare(messages);
-    return createCompletion(model, content, returnStream);
+    const clientIp = getClientIP(request);
+
+    return createCompletion(model, content, returnStream, clientIp);
   } catch (err) {
     console.error('Handle Completion Error:', err);
     return error(500, err.message);
   }
 }
 
-async function createCompletion(model, content, returnStream, retryCount = 0) {
+async function createCompletion(model, content, returnStream, clientIp, retryCount = 0) {
   try {
-    const token = await requestToken();
+    const token = await requestToken(clientIp);
     const response = await fetch('https://duckduckgo.com/duckchat/v1/chat', {
       method: 'POST',
       headers: {
         ...config.FAKE_HEADERS,
         'x-vqd-4': token,
+        ...(clientIp ? { 'x-forwarded-for': clientIp } : {}),
       },
       body: JSON.stringify({
         model,
@@ -103,7 +114,7 @@ async function createCompletion(model, content, returnStream, retryCount = 0) {
     if (retryCount < config.MAX_RETRY_COUNT && (err.message.includes('Rate limit') || err.message.includes('418'))) {
       console.log('Retrying... count', ++retryCount);
       await new Promise((resolve) => setTimeout(resolve, config.RETRY_DELAY));
-      return createCompletion(model, content, returnStream, retryCount);
+      return createCompletion(model, content, returnStream, clientIp, retryCount);
     }
     throw err;
   }
@@ -172,72 +183,79 @@ function messagesPrepare(messages) {
     .join('\n');
 }
 
-async function requestToken() {
+async function requestToken(clientIp) {
   try {
     const response = await fetch('https://duckduckgo.com/duckchat/v1/status', {
       method: 'GET',
-      headers: config.FAKE_HEADERS,
+      headers: {
+        ...config.FAKE_HEADERS,
+        ...(clientIp ? { 'x-forwarded-for': clientIp } : {}),
+      },
     });
-    const token = response.headers.get('x-vqd-4');
-    if (!token) {
-      console.error('No x-vqd-4 token found in response headers');
-      throw new Error('Failed to retrieve x-vqd-4 token');
+    if (!response.ok) {
+      throw new Error('Request Token failed!');
     }
-    console.log('Token retrieved:', token);
-    return token;
+    const data = await response.json();
+    return data?.vqd;
   } catch (err) {
-    console.error('Request token error:', err);
+    console.error('Request Token Error:', err);
     throw err;
   }
 }
 
-function convertModel(inputModel) {
-  const modelMap = {
-    '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',
-    'o3-mini': 'o3-mini', // Fallback to default if unsupported
-  };
-  const selectedModel = modelMap[inputModel.toLowerCase()] || 'gpt-4o-mini';
-  console.log(`Converted model: ${inputModel} -> ${selectedModel}`);
-  return selectedModel;
+function convertModel(model) {
+  return model; // Adjust if needed
 }
 
-function newChatCompletionChunkWithModel(text, model) {
+function newChatCompletionWithModel(content, model) {
   return {
-    id: 'chatcmpl-' + Math.random().toString(36).slice(2),
-    object: 'chat.completion.chunk',
+    id: 'chatcmpl-' + Date.now(),
+    object: 'chat.completion',
     created: Math.floor(Date.now() / 1000),
     model,
-    choices: [{ index: 0, delta: { content: text }, finish_reason: null }],
+    choices: [
+      {
+        index: 0,
+        message: { role: 'assistant', content },
+        finish_reason: 'stop',
+      },
+    ],
   };
 }
 
-function newStopChunkWithModel(reason, model) {
+function newChatCompletionChunkWithModel(content, model) {
   return {
-    id: 'chatcmpl-' + Math.random().toString(36).slice(2),
+    id: 'chatcmpl-' + Date.now(),
     object: 'chat.completion.chunk',
     created: Math.floor(Date.now() / 1000),
     model,
-    choices: [{ index: 0, finish_reason: reason }],
+    choices: [
+      {
+        delta: { content },
+        index: 0,
+        finish_reason: null,
+      },
+    ],
   };
 }
 
-function newChatCompletionWithModel(text, model) {
+function newStopChunkWithModel(reason, model) {
   return {
-    id: 'chatcmpl-' + Math.random().toString(36).slice(2),
-    object: 'chat.completion',
+    id: 'chatcmpl-' + Date.now(),
+    object: 'chat.completion.chunk',
     created: Math.floor(Date.now() / 1000),
     model,
-    usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
-    choices: [{ message: { content: text, role: 'assistant' }, index: 0 }],
+    choices: [
+      {
+        delta: {},
+        index: 0,
+        finish_reason: reason,
+      },
+    ],
   };
 }
 
-(async () => {
-  if (typeof addEventListener === 'function') return;
-  const ittyServer = createServerAdapter(router.fetch);
-  console.log(`Listening on http://0.0.0.0:${config.PORT}`);
-  const httpServer = createServer(ittyServer);
-  httpServer.listen(config.PORT, '0.0.0.0');
-})();
+// Create Server
+createServer(createServerAdapter(router.fetch)).listen(config.PORT, () => {
+  console.log('Server running at http://localhost:' + config.PORT);
+});