Привет! Вот мой исходный код:

import struct
import uuid
import socket
import threading
import queue
import numpy as np
import sherpa_onnx
import json

from loggers import logger
from param import Constants

class k_STTServer:
    def __init__(self, host='0.0.0.0', port=5000):
       
        self.running = True
        self.audio_queue = queue.Queue()
       
        # Настройка TCP сервера
        self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.server_socket.bind((host, port))
        self.server_socket.listen(100)  # Увеличиваем очередь подключений
        
        # Словарь для хранения активных соединений
        self.active_connections = {}
        
        # Запуск потоков
        self.socket_thread = threading.Thread(target=self._socket_listener, daemon=True)
        self.processing_thread = threading.Thread(target=self._process_audio, daemon=True)
        
        self.socket_thread.start()
        self.processing_thread.start()
        
        logger.info(f"STT сервер запущен на {host}:{port}")

    def _socket_listener(self):
        while self.running:
            try:
                client_socket, addr = self.server_socket.accept()
                logger.info(f"Новое соединение от {addr}")
                
                # Создаем уникальный идентификатор соединения
                connection_id = str(uuid.uuid4())

                self.active_connections[connection_id] = {
                    'socket': client_socket,
                    'buffer': b'',
                    'call_id': None,
                    'addr': addr,
                    'active': True
                }
                
                # Запускаем обработчик для этого соединения
                client_thread = threading.Thread(
                    target=self._handle_client,
                    args=(connection_id,),
                    daemon=True
                )
                client_thread.start()
                
            except Exception as e:
                logger.error(f"Ошибка принятия соединения: {str(e)}")

    def _handle_client(self, connection_id):
        """Обработка отдельного клиентского соединения"""
        conn_data = self.active_connections.get(connection_id)
        if not conn_data:
            logger.error(f" НЕТУ ДАННЫЕ ОТ КЛИЕНТА: {connection_id}")
            return
        
        client_socket = conn_data['socket']
        
        while self.running and conn_data['active']:
            try:
                # Ожидаем заголовок (call_id + размер данных)
                header = client_socket.recv(36 + 4)  # 36 байт UUID + 4 байта размера
                if not header:
                    # Соединение закрыто клиентом
                    logger.info(f"Соединение {connection_id} закрыто клиентом")
                    break
                    
                if len(header) != 40:
                    # Если не получили полный заголовок, пытаемся дочитать
                    remaining = 40 - len(header)
                    header += client_socket.recv(remaining)
                    if len(header) != 40:
                        raise ValueError("Неверный размер заголовка")
                
                call_id = header[:36].decode('utf-8')
                data_size = int.from_bytes(header[36:40], byteorder='big')
                
                # Проверяем UUID
                try:
                    uuid.UUID(call_id)
                except ValueError:
                    raise ValueError("Неверный формат call_id")
                
                conn_data['call_id'] = call_id
                logger.info(f"Начало получения данных для call_id {call_id}, размер: {data_size} байт")
                
                # Получаем аудио данные
                received = 0
                conn_data['buffer'] = b''  # Очищаем буфер перед новыми данными
                while received < data_size:
                    chunk = client_socket.recv(min(4096, data_size - received))
                    if not chunk:
                        break
                    conn_data['buffer'] += chunk
                    received += len(chunk)
                
                if received != data_size:
                    raise ValueError(f"Получено {received} байт из {data_size} ожидаемых")
                
                # Добавляем в очередь обработки
                self.audio_queue.put((call_id, conn_data['buffer']))
                
            except socket.timeout:
                # Таймаут - нормальная ситуация для долгоживущих соединений
                continue
            except Exception as e:
                logger.error(f"Ошибка обработки клиента {connection_id}: {str(e)}")
                break
        
        # Очистка соединения при выходе
        self._cleanup_connection(connection_id)
        logger.info(f"Обработчик для соединения {connection_id} завершен")
        
    def _handle_client_old(self, connection_id):
        """Обработка отдельного клиентского соединения"""
        while self.running:
            try:
              conn_data = self.active_connections[connection_id]
              client_socket = conn_data['socket']
              
              # Читаем заголовок (call_id + размер данных)
              header = client_socket.recv(36 + 4)  # 36 байт UUID + 4 байта размера
              if len(header) != 40:
                  raise ValueError("Неверный размер заголовка")
              
              call_id = header[:36].decode('utf-8')
              data_size = int.from_bytes(header[36:40], byteorder='big')
              
              # Проверяем UUID
              try:
                  uuid.UUID(call_id)
              except ValueError:
                  raise ValueError("Неверный формат call_id")
              
              conn_data['call_id'] = call_id
              logger.info(f"Начало получения данных для call_id {call_id}, размер: {data_size} байт")
              
              # Получаем аудио данные
              received = 0
              while received < data_size:
                  chunk = client_socket.recv(min(4096, data_size - received))
                  if not chunk:
                      break
                  conn_data['buffer'] += chunk
                  received += len(chunk)
              
              if received != data_size:
                  raise ValueError(f"Получено {received} байт из {data_size} ожидаемых")
              
              # Добавляем в очередь обработки
              #self.audio_queue.put((connection_id, call_id, conn_data['buffer']))
              self.audio_queue.put((call_id, conn_data['buffer']))
              
              #self._cleanup_connection(connection_id)
              
            except Exception as e:
                logger.error(f"Ошибка обработки клиента {connection_id}: {str(e)}")
            finally:
                logger.info(f" _handle_client завершение1")
                #    self._cleanup_connection(connection_id)
                
        logger.info(f" _handle_client завершение2")

    def _process_audio(self):
        sample_rate = Constants.SIP_SAMPLERATE
        
        # Инициализация модели распознавания речи
        recognizer = sherpa_onnx.OfflineRecognizer.from_transducer(
            encoder=f"{Constants.STT_PATH}/am-onnx/encoder.onnx",
            decoder=f"{Constants.STT_PATH}/am-onnx/decoder.onnx",
            joiner=f"{Constants.STT_PATH}/am-onnx/joiner.onnx",
            tokens=f"{Constants.STT_PATH}/lang/tokens.txt",
            num_threads=6,
            provider='cpu',
            sample_rate=sample_rate,
            dither=3e-5,
            max_active_paths=5,
            debug=False,
            decoding_method="modified_beam_search"
        )
        
        trigger_words = ["афина", "джой", "алиса", "салют", "включи", "дж"]

        while self.running:
            try:
                #connection_id, call_id, audio_data = self.audio_queue.get()
                
                #if connection_id not in self.active_connections:
                #    logger.warning(f"Соединение {connection_id} уже закрыто")
                #    continue
                call_id, audio_data = self.audio_queue.get()
               
                # Конвертация аудио
                audio_np = np.frombuffer(audio_data, dtype=np.int16)
                audio_float = audio_np.astype(np.float32) / 32768.0
                
                # Распознавание речи
                stream = recognizer.create_stream()
                stream.accept_waveform(sample_rate, audio_float)
                recognizer.decode_stream(stream)
                
                text = stream.result.text.lower()
                logger.info(f"Распознанный текст для call_id {call_id}: {text}")
                
                # Фильтрация триггерных слов
                if any(word in text for word in trigger_words):
                    text = "..."
                    
                    
                logger.error(f" РАСПОЗНАНЫЙ ТЕКСТ: {text}")
                 
                # Отправка результата
                #self._send_response(connection_id, {
                #    "call_id": call_id,
                #    "text": text,
                #    "status": "success"
                #})
                
            except Exception as e:
                logger.error(f"Ошибка обработки аудио: {str(e)}")

    def _send_response(self, connection_id, response):
        """Отправка успешного ответа клиенту"""
        try:
            if connection_id in self.active_connections:
                client_socket = self.active_connections[connection_id]['socket']
                client_socket.sendall(json.dumps(response).encode('utf-8'))
        except Exception as e:
            logger.error(f"Ошибка отправки ответа: {str(e)}")
        finally:
            self._cleanup_connection(connection_id)

    def _cleanup_connection(self, connection_id):
        """Очистка соединения"""
        if connection_id in self.active_connections:
            try:
                self.active_connections[connection_id]['socket'].close()
            except:
                pass
            del self.active_connections[connection_id]

    def stop(self):
        self.running = False
        self.server_socket.close()
        logger.info("STT сервер остановлен")


"""
# Отправка результата
        response = {
            "call_id": call_id,
            "text": text,
            "status": "success"
        }
        
        client_socket.sendall(json.dumps(response).encode('utf-8'))

"""

Нужно внести **минимальные изменения**, убрать call_id.. изменить протокол передачи, в такой вид
№команды - это цифра от 1-9 а потом идут данные и чтобы по № компанды я уже мог делать логику - разделить 

Пожалуйста:  
- Не переименовывать функции.  
- Не добавлять новых функций.  
- Не менять названия переменных.  
- Не менять структуру и логику кода (если не очень нужно).  
- Не вносить ничего лишнего.  
- Если не получится без изменений, спроси меня, пожалуйста.

Сделай исправленную версию.

Спасибо!