Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-mini-2024-07-18· OpenAIAi2 WildChat-4.8M (AI2)

const { gpt, gptweb } = require("./API/gpt"); const { dalle } =…

  1. User

    User: const { gpt, gptweb } = require("./API/gpt"); const { dalle } = require("./API/dalle"); const { gpt4o } = require("./API/gpt4o"); const { gpt3 } = require("./API/gpt3.5"); const { prompts } = require("./API/gpt-prompts"); const { blackbox } = require("./API/blackbox"); const { qwen } = require("./API/qwen"); const { gemini } = require("./API/gemini");

    const WebSocket = require('ws');

    const Bottleneck = require('bottleneck');

    // Объект для хранения действий и состояния каждого клиента const clientActions = {}; // Объект для хранения ограничителей по каждому клиенту const limiters = {};

    const wss = new WebSocket.Server({ port: 3000 });

    wss.on('connection', (ws, req) => { const urlParams = new URLSearchParams(req.url.split('?')[1]); const userId = urlParams.get('token'); // Получаем UUID из URL let isProcessing = false; // Флаг для отслеживания обработки текущего сообщения console.log('Client connected with user ID:', userId);

    // Инициализируем состояние клиента, если его еще нет
    if (!clientActions[userId]) {
      clientActions[userId] = {
        actions: [], // Массив для хранения действий
        connected: true, // Статус подключения
      };
      
      // Создаем экземпляр Bottleneck для каждого клиента
      limiters[userId] = new Bottleneck({
          maxConcurrent: 1, // Максимальное количество одновременных задач
          minTime: 1000 // Минимальное время между запросами в миллисекундах
      });
    }
    
    ws.on('message', (message) => {
    	// Проверяем, является ли сообщение экземпляром Buffer
    	if (Buffer.isBuffer(message))
    		message = message.toString(); 
    	
    	try {
    		// Преобразуем строку JSON обратно в объект
    		message = JSON.parse(message); 
    		
    		//Получаем историю чата из запроса
    		messages = message.messages;
    		
    		// Проверяем, идет ли уже обработка
            if (isProcessing) {
                const response = { code: 2, message: "Пожалуйста, подождите, ваш предыдущий запрос еще обрабатывается." };
                if (ws.readyState === WebSocket.OPEN) {
                    ws.send(JSON.stringify(response));
                }
                return; // Останавливаем выполнение
            }
    
            // Устанавливаем флаг на время обработки
            isProcessing = true;
    		
    		// Используем Bottleneck для управления количеством запросов
            limiters[userId].schedule(() => {
    			// Отправка запроса на сервер чата
                return call(messages, ws).finally(() => {
                    isProcessing = false; // Сбрасываем флаг при завершении
                }); 
            }).catch(error => {
                console.error('Rate limit exceeded, message ignored:', error);
                const response = { code: 2, message: "Превышен лимит запросов. Пожалуйста, попробуйте позже." };
    			
    			if (ws.readyState === WebSocket.OPEN) {
    				ws.send(JSON.stringify(response));
    			}
    			isProcessing = false; // Сбрасываем флаг, если есть ошибка
            });
    		
    	} catch (error) {
    			console.error('Error parsing JSON:', error);
    			const response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
    			console.log(response);
    			
    			if (ws.readyState === WebSocket.OPEN) {
    				ws.send(JSON.stringify(response));
    			}
    			isProcessing = false; // Сбрасываем флаг для обработки ошибки JSONParsing
    	}
    	
    });
    
    ws.on('close', () => {
    	clientActions[userId].connected = false; // Обновление статуса подключения
    	delete clientActions[userId]; // Удаление состояния клиента
    	delete limiters[userId]; // Удаление ограничителя для данного клиента
        console.log('Client disconnected');
    });
    

    });

    async function call(userMessage, ws) { try { let fullResponse = ""; // Переменная для результата

    	console.log('Запрос клиента:', userMessage); 
    	//throw new Error("Намеренная ошибка для тестирования catch");
        gpt4o({
            messages: userMessage,
            markdown: false
        }, (result) => {
            if (!result.finish) {
                // Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления)
                fullResponse = result.message || "";
    			//console.log(result);
            } else {
                // Если завершено, выводим полный ответ
    			let response = { code: 1, message: fullResponse};
    			console.log('Ответ чата: ', response);
    			// Отправка ответа клиенту
    			if (ws.readyState === WebSocket.OPEN) {
    				ws.send(JSON.stringify(response));
    			} else {
    				console.warn(`Trying to send message to a closed WebSocket connection.`);
    			}
            }
        });
    } catch (error) {
        console.error('Error:', error);
    	let response = { code: 2, message: "Произогла ошибка. Попробуйте еще раз."};
    	if (ws.readyState === WebSocket.OPEN) {
    		ws.send(JSON.stringify(response));
    	} else {
    		console.warn(`Trying to send message to a closed WebSocket connection.`);
    	}
    }
    

    }

    console.log('WebSocket сервер запущен через порт 3000');

    Оцени код Assistant: код для реализации веб-сокет-сервера кажется довольно хорошо структурированным и тщательно продуманным. Вот несколько положительных моментов и некоторые критические замечания, которые могут помочь улучшить его:

    Положительные моменты:

    1. Структурирование кода: Вы организовали свой код в функциях и используете модули для работы с API. Это делает его более читаемым и модульным.

    2. Обработка WebSocket-соединений: Код позволяет нескольким клиентам подключаться и обрабатывать их сообщения параллельно, что является хорошей практикой.

    3. Использование Bottleneck: Вы используете Bottleneck для ограничения количества одновременно обрабатываемых запросов от каждого клиента, что помогает предотвратить перегрузку сервера.

    4. Обработка ошибок и состояний: Вы хорошо обрабатываете сценарии, такие как отключение клиентов и ошибки при передаче данных, что повышает стабильность приложения.

    5. Флаги состояния: Использование переменной isProcessing для отслеживания состояния обработки делает код более прозрачным и предотвращает повторную отправку во время выполнения.

    Возможные улучшения:

    1. Состояние обработки на уровне клиента: Вместо флага isProcessing на уровне сервера для каждого клиента, вы можете управлять состоянием обработки на уровне каждого сообщения. Это позволит избежать проблем, если клиент решит отправить несколько сообщений одновременно (например, при быстрой последовательности нажатий клавиш).

    2. Лучшие сообщения об ошибках: Ваша система обработки ошибок могла бы предоставить более подробные сообщения при возникновении исключений, чтобы легче было их диагностировать.

    3. Оптимизация обработки сообщений: Когда вы отправляете сообщения клиенту, используйте одно сообщение об ошибке для всех типов ошибок, чтобы не повторять код.

    4. Чистка кода: Убедитесь, что вы убрали закомментированный код, если он не нужен. Это помогает поддерживать код в чистоте.

    5. Логирование: Было бы полезно добавить более информативное логирование, чтобы отслеживать любые ошибки или неожиданные состояния, особенно в функции call.

    6. Обработка WebSocket-событий: Можно рассмотреть возможность добавления обработки событий error для WebSocket, чтобы отслеживать проблемы с соединением.

    Примеры улучшений:

    • Вы могли бы улучшить код ошибки следующим образом:
    const response = { 
        code: 2, 
        message: error.message || "Произошла ошибка. Попробуйте еще раз."
    };
    
    • Использовать отдельные обработчики для различных ошибок:
    ws.on('error', (error) => {
        console.error('WebSocket error:', error);
    });
    

    В общем, ваш код уже выглядит очень хорошо, и с небольшими улучшениями он может стать еще более эффективным и устойчивым к ошибкам. Отличная работа! User: Состояние обработки на уровне клиента: Вместо флага isProcessing на уровне сервера для каждого клиента, вы можете управлять состоянием обработки на уровне каждого сообщения. Это позволит избежать проблем, если клиент решит отправить несколько сообщений одновременно (например, при быстрой последовательности нажатий клавиш).

    Подробнее с примером Assistant: управления состоянием обработки на уровне каждого сообщения вместо использования глобального флага isProcessing, вы можете применить подход, в котором каждое сообщение имеет свой собственный статус. Для этого вам потребуются изменения в логике обработки сообщений.

    Вот основные шаги, как это можно реализовать:

    1. Создайте очередь для сообщений: Вместо одного флага состояния вы можете хранить состояния обработки для каждого сообщения в очереди.
    2. Управляйте состоянием каждого сообщения: Используйте массив для хранения информации о каждом ожидающем сообщении, что позволит легко отслеживать, какие сообщения уже обрабатываются.

    Пример реализации

    Вот переработанный фрагмент вашего кода, где каждое сообщение будет обрабатываться отдельно, с использованием очереди:

    const WebSocket = require('ws');
    const Bottleneck = require('bottleneck');
    
    // Объект для хранения действий и состояния каждого клиента
    const clientActions = {};
    // Объект для хранения ограничителей по каждому клиенту
    const limiters = {};
    
    const wss = new WebSocket.Server({ port: 3000 });
    
    wss.on('connection', (ws, req) => {
        const urlParams = new URLSearchParams(req.url.split('?')[1]);
        const userId = urlParams.get('token'); // Получаем UUID из URL
    
        console.log('Client connected with user ID:', userId);
    
        if (!clientActions[userId]) {
            clientActions[userId] = {
                messagesQueue: [], // Очередь для хранения сообщений
                connected: true,   // Статус подключения
            };
    
            // Создаем экземпляр Bottleneck для каждого клиента
            limiters[userId] = new Bottleneck({
                maxConcurrent: 1,
                minTime: 1000
            });
        }
    
        ws.on('message', (message) => {
            if (Buffer.isBuffer(message)) 
                message = message.toString(); 
            
            try {
                message = JSON.parse(message);
                const messages = message.messages;
    
                // Добавляем сообщение в очередь
                clientActions[userId].messagesQueue.push(messages);
    
                // Запускаем обработчик сообщений, если он еще не запущен
                processMessageQueue(userId, ws);
            } catch (error) {
                console.error('Error parsing JSON:', error);
                const response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
                if (ws.readyState === WebSocket.OPEN) {
                    ws.send(JSON.stringify(response));
                }
            }
        });
    
        ws.on('close', () => {
            clientActions[userId].connected = false; 
            delete clientActions[userId];
            delete limiters[userId];
            console.log('Client disconnected');
        });
    });
    
    async function processMessageQueue(userId, ws) {
        // Проверяем, есть ли сообщения в очереди
        if (clientActions[userId].messagesQueue.length === 0) {
            return; // Заканчиваем, если очередь пуста
        }
    
        const messages = clientActions[userId].messagesQueue.shift(); // Извлекаем первое сообщение
    
        limiters[userId].schedule(() => {
            return call(messages, ws).finally(() => {
                // После обработки сообщения вызываем функцию снова для обработки следующего
                processMessageQueue(userId, ws);
            });
        }).catch(error => {
            console.error('Rate limit exceeded, message ignored:', error);
            const response = { code: 2, message: "Превышен лимит запросов. Пожалуйста, попробуйте позже." };
            if (ws.readyState === WebSocket.OPEN) {
                ws.send(JSON.stringify(response));
            }
        });
    }
    
    async function call(userMessage, ws) {
        try {
            let fullResponse = "";
            console.log('Запрос клиента:', userMessage);
    
            gpt4o({
                messages: userMessage,
                markdown: false
            }, (result) => {
                if (!result.finish) {
                    fullResponse = result.message || "";
                } else {
                    let response = { code: 1, message: fullResponse };
                    console.log('Ответ чата:', response);
                    if (ws.readyState === WebSocket.OPEN) {
                        ws.send(JSON.stringify(response));
                    }
                }
            });
        } catch (error) {
            console.error('Error:', error);
            let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
            if (ws.readyState === WebSocket.OPEN) {
                ws.send(JSON.stringify(response));
            }
        }
    }
    
    console.log('WebSocket сервер запущен через порт 3000');
    

    Объяснение изменений:

    1. Очередь сообщений: Для каждого клиента теперь создается массив messagesQueue, куда добавляются входящие сообщения.
    2. Асинхронная обработка очереди: Функция processMessageQueue проверяет, есть ли сообщения в очереди и обрабатывает их по одному. После завершения обработки текущего сообщения она вызывает саму себя для обработки следующего.
    3. Упраление состоянием: Это позволяет не блокировать входящие сообщения, даже если последнее сообщение обрабатывается. Каждый запрос обрабатывается по очереди.

    С таким подходом, даже если клиент отправит несколько сообщений подряд, они будут обработаны по очереди. Это улучшает производительность и предсказуемость работы сервера. User: Но очереди как раз быть не должно, isProcessing используется чтобы отклонять все запросы клиента пока не дан ответ на предыдущий запрос. Assistant: онял. Если ваша цель — предотвратить отправку новых запросов от клиента, пока предыдущий запрос не будет полностью обработан, оставляя при этом саму логику обработки сообщений без очередей, вы можете сохранять флаг isProcessing только для текущего соединения, но также стоит учитывать, что можно использовать более точные механизмы для управления состоянием обработки запросов. В вашем случае флаг isProcessing будет достаточным, но только для одного обработки за раз.

    Переработанный подход

    Вот как можно переписать обработку сообщений с использованием isProcessing только на уровне соединения, чтобы предотвратить отправку нескольких запросов, но без использования очереди:

    const WebSocket = require('ws');
    const Bottleneck = require('bottleneck');
    
    const clientActions = {};
    const limiters = {};
    
    const wss = new WebSocket.Server({ port: 3000 });
    
    wss.on('connection', (ws, req) => {
        const urlParams = new URLSearchParams(req.url.split('?')[1]);
        const userId = urlParams.get('token');
    
        console.log('Client connected with user ID:', userId);
    
        if (!clientActions[userId]) {
            clientActions[userId] = {
                connected: true,
                isProcessing: false // Флаг обработки для каждого клиента
            };
    
            // Создаем экземпляр Bottleneck для каждого клиента
            limiters[userId] = new Bottleneck({
                maxConcurrent: 1,
                minTime: 1000
            });
        }
    
        ws.on('message', (message) => {
            if (Buffer.isBuffer(message)) 
                message = message.toString(); 
    
            try {
                message = JSON.parse(message);
                const messages = message.messages;
    
                // Проверяем, идет ли уже обработка
                if (clientActions[userId].isProcessing) {
                    const response = { code: 2, message: "Пожалуйста, подождите, ваш предыдущий запрос еще обрабатывается." };
                    if (ws.readyState === WebSocket.OPEN) {
                        ws.send(JSON.stringify(response));
                    }
                    return; // Останавливаем выполнение
                }
    
                // Устанавливаем флаг на время обработки
                clientActions[userId].isProcessing = true;
    
                // Используем Bottleneck для управления количеством запросов
                limiters[userId].schedule(() => {
                    return call(messages, ws).finally(() => {
                        clientActions[userId].isProcessing = false; // Сбрасываем флаг при завершении
                    });
                }).catch(error => {
                    console.error('Rate limit exceeded, message ignored:', error);
                    const response = { code: 2, message: "Превышен лимит запросов. Пожалуйста, попробуйте позже." };
                    if (ws.readyState === WebSocket.OPEN) {
                        ws.send(JSON.stringify(response));
                    }
                    clientActions[userId].isProcessing = false; // Сбрасываем флаг, если есть ошибка
                });
    
            } catch (error) {
                console.error('Error parsing JSON:', error);
                const response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
                if (ws.readyState === WebSocket.OPEN) {
                    ws.send(JSON.stringify(response));
                }
                clientActions[userId].isProcessing = false; // Сбрасываем флаг для обработки ошибки JSON
            }
        });
    
        ws.on('close', () => {
            clientActions[userId].connected = false; 
            delete clientActions[userId];
            delete limiters[userId];
            console.log('Client disconnected');
        });
    });
    
    async function call(userMessage, ws) {
        try {
            let fullResponse = "";
            console.log('Запрос клиента:', userMessage);
    
            gpt4o({
                messages: userMessage,
                markdown: false
            }, (result) => {
                if (!result.finish) {
                    fullResponse = result.message || "";
                } else {
                    let response = { code: 1, message: fullResponse };
                    console.log('Ответ чата:', response);
                    if (ws.readyState === WebSocket.OPEN) {
                        ws.send(JSON.stringify(response));
                    }
                }
            });
        } catch (error) {
            console.error('Error:', error);
            let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
            if (ws.readyState === WebSocket.OPEN) {
                ws.send(JSON.stringify(response));
            }
        }
    }
    
    console.log('WebSocket сервер запущен через порт 3000');
    

    Объяснение изменений:

    1. Флаг isProcessing: Теперь isProcessing хранится в объекте состояния для каждого клиента. Он используется для предотвращения обработки нового сообщения, пока предыдущее еще не завершено.

    2. Проверка состояния: Перед началом обработки входящего сообщения проверяется значение флага. Если сообщение обрабатывается, клиенту отправляется сообщение об ожидании.

    3. Обработка ошибок: Если возникает ошибка, флаг также сбрасывается, чтобы в дальнейшем клиент мог отправить новые сообщения.

    Таким образом, вы надежно управляете состоянием обработки запросов и сохраняете возможность обрабатывать только один запрос за раз, предотвращая любые проблемы из-за параллельной обработки. User: Почему при большом количестве запросов этот код обрабатывает два запроса подряд, несмотря на наличие isProcessing и minTime: 5000? Запросы приходят такие Запрос клиента: [ { role: 'user', content: 'привет' } ] и Запрос клиента: [ 0|gpt-server | { role: 'user', content: 'привет' }, 0|gpt-server | { 0|gpt-server | role: 'assistant', 0|gpt-server | content: 'Пожалуйста, подождите, ваш предыдущий запрос еще обрабатывается.' 0|gpt-server | } 0|gpt-server | ]

    Соответственно ответа тоже два подряд Assistant: Пожалуйста, подождите, ваш предыдущий запрос еще обрабатывается. Assistant:

  2. Assistant

    Если вы наблюдаете, что код обрабатывает два запроса подряд, несмотря на наличие флага isProcessing и настройки minTime для Bottleneck, это может быть вызвано несколькими факторами. Давайте рассмотрим возможные причины и решения этой проблемы.

    Потенциальные причины

    1. Состояние флага isProcessing: Если флаг isProcessing не сбрасывается везде, где это необходимо, это может привести к тому, что следующий запрос будет принят, даже если он еще обрабатывается. Убедитесь, что в каждом возможном месте, где происходит завершение обработки запроса, флаг сбрасывается.

    2. Асинхронные вызовы и вызовы обратного вызова: Если функция, которая обрабатывает ответ, выполняется асинхронно и не блокирует следующий шаг, то возможно, что флаг isProcessing сбрасывается до завершения всех асинхронных операций, что ведет к тому, что новый запрос может быть принят преждевременно.

    3. Параллельные соединения: Если у клиентов есть возможность подключиться к серверу одновременно, у каждого клиента будет свой флаг isProcessing. Однако если один клиент отправляет множество сообщений через разные соединения, это может вызвать путаницу с состоянием флагов.

    4. Bottleneck: Убедитесь, что вы используете Bottleneck правильно, так как он управляет только самой обработкой и не защищает от повторной отправки сообщений.

    Решение и Улучшения

    Вот несколько рекомендаций и примеров, как можно улучшить ваше решение, чтобы предотвратить обработку нескольких запросов одновременно:

    1. Убедитесь, что флаг isProcessing сбрасывается только после полной обработки запроса (включая обработчик обратного вызова):

      Ваша асинхронная функция call должна гарантировать сброс isProcessing после завершения всех операций, включая обработку результата:

      async function call(userMessage, ws) {
          let fullResponse = "";
          try {
              console.log('Запрос клиента:', userMessage);
              await new Promise((resolve) => {
                  gpt4o({
                      messages: userMessage,
                      markdown: false
                  }, (result) => {
                      if (!result.finish) {
                          fullResponse = result.message || "";
                      } else {
                          let response = { code: 1, message: fullResponse };
                          console.log('Ответ чата:', response);
                          if (ws.readyState === WebSocket.OPEN) {
                              ws.send(JSON.stringify(response));
                          }
                          resolve(); // Завершение обработки
                      }
                  });
              });
          } catch (error) {
              console.error('Error:', error);
              // Обработка ошибки
          } finally {
              clientActions[userId].isProcessing = false; // Сбрасываем флаг в блоке finally
          }
      }
      
    2. Произвести более строгие проверки состояния при получении сообщения: Убедитесь, что флаг isProcessing действительно проверяется перед обработкой каждого сообщения:

      ws.on('message', (message) => {
          // ... ваш исходный код ...
      
          if (clientActions[userId].isProcessing) {
              const response = { code: 2, message: "Пожалуйста, подождите, ваш предыдущий запрос еще обрабатывается." };
              if (ws.readyState === WebSocket.OPEN) {
                  ws.send(JSON.stringify(response));
              }
              return; // Останавливаем выполнение
          }
      
          // После проверок
          clientActions[userId].isProcessing = true;
          // ... обработка запроса ...
      });
      
    3. Проверка настроек Bottleneck: Убедитесь, что minTime установлен корректно и учитывает фактическое время обработки ваших запросов. Возможно, вам потребуется установить более высокое значение, если обрабатываемые запросы более ресурсоемкие.

    4. Проверка на наличие повторных соединений: Убедитесь, что клиенты не создают несколько соединений с сервером одновременно, что может привести к путанице со статусами.

    5. Логирование событий: Убедитесь, что вы логируете состояние isProcessing и другие критически важные события, чтобы в дальнейшем легче было провести диагностику.

    Заключение

    Сочетание этих подходов должно помочь вам решить проблему, когда два запроса обрабатываются одновременно. Обычно лучшая методология для поддержки статуса — это хороший контроль потока выполнения и четкие асинхронные вызовы в вашем коде.