как реализовать стриминг данных из процесса c помощью fastaip?

Есть эти очереди:
    input_queue_1 = manager.Queue()
    input_queue_2 = manager.Queue()
    input_queue_3 = manager.Queue()
    input_queue_4 = manager.Queue()

    output_queue_1 = manager.Queue()
    output_queue_2 = manager.Queue()
    output_queue_3 = manager.Queue()
    output_queue_4 = manager.Queue()

    request_queues_1 = manager.dict()
    request_queues_2 = manager.dict()
    request_queues_3 = manager.dict()
    request_queues_4 = manager.dict()

Очередями управляет следующая функция запущенная в потоке:
# Функция для обработки ответов
def handle_responses(output_queue, request_queues):
    while True:
        request_id, response = output_queue.get()
        if request_id in request_queues:
            request_queues[request_id].put(response)

    threading.Thread(target=handle_responses, args=(output_queue_2, request_queues_2), daemon=True).start()


Эндпоинт работает так:
# Функция для обработки запросов
def process_request(request, input_queue, output_queue, request_queues):
    request_id = str(uuid.uuid4())
    response_queue = Manager().Queue()  # Создаем очередь для ответа
    request_queues[request_id] = response_queue
    input_queue.put((request_id, request))
    
    # Ожидаем ответа
    response = response_queue.get()
    del request_queues[request_id]  # Удаляем очередь после получения ответа
    return {"response": response}

@app.post("/generate_LLM_response")
async def process_request_endpoint_3(request: Request):
    global task_GenerateResponseProcess_started
    data = await request.json()
    task_GenerateResponseProcess_started.value = True
    return await process_request_stream(data, input_queue_3, output_queue_3, request_queues_3)


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

class GenerateResponseProcess:

    def __init__(self, input_queue, output_queue, ImageInterpretation, TranscriptProcessor, GenerateLLMResponse, Wispper, task_GenerateResponseProcess_started):
        self.input_queue = input_queue
        self.output_queue = output_queue

        self.ImageInterpretation = ImageInterpretation
        self.TranscriptProcessor = TranscriptProcessor
        self.GenerateLLMResponse = GenerateLLMResponse
        self.task_GenerateResponseProcess_started = task_GenerateResponseProcess_started
        self.Wispper = Wispper

    async def Get_LLM_Response(self):
        import time
        from server_modules.text_web_ui import local_answer
        while True:

            # Задержка, чтобы не создавать излишнюю нагрузку на CPU
            await asyncio.sleep(1)

            # Принудительное чтение значений
            generate_llm_response_value = self.GenerateLLMResponse.value  # Принудительное чтение
            wispper_value = self.Wispper.value  # Принудительное чтение
            task_GenerateResponseProcess_value = self.task_GenerateResponseProcess_started.value  # Принудительное чтение
            
            if generate_llm_response_value == False  and wispper_value == False and task_GenerateResponseProcess_value == True:
                self.GenerateLLMResponse.value = True
                start_time = time.time()
                request_id, message_content = await asyncio.get_event_loop().run_in_executor(None, self.input_queue.get)
                try:
                    try:
                        model_info = requests.get("http://127.0.0.1:5000/v1/internal/model/info").json()
                        if 'model_name' in model_info and 'c4ai-command-r-08-2024-IQ4_XS.gguf' in model_info['model_name']:
                            pass
                        else:
                            requests.post("http://127.0.0.1:5000/v1/internal/model/unload")
                            data = {"model_name": "c4ai-command-r-08-2024-IQ4_XS.gguf", "args": {}, "settings": {}}
                            requests.post("http://127.0.0.1:5000/v1/internal/model/load", json=data)
                        print(f"Error while fetching model info: {e}")
                        
                    except Exception as e:
                        print(e)
                    
                    try:
                        # Стримим данные по частям
                        async for part in local_answer(message_content):
                            await asyncio.get_event_loop().run_in_executor(None, self.output_queue.put, (request_id, part))

                        # Сообщаем о завершении обработки
                        await asyncio.get_event_loop().run_in_executor(None, self.output_queue.put, (request_id, None))
                    except Exception as e:
                        print(e)

                    await asyncio.get_event_loop().run_in_executor(None, self.output_queue.put, (request_id, response))
                    self.GenerateLLMResponse.value = False
                    self.task_GenerateResponseProcess_started.value = False
                    end_time = time.time()
                    print("----------")
                    print("Function: Image Interpretation")
                    print(f"Execution time: {end_time - start_time} seconds")
                    print("----------")
                except Exception as e:
                    print(e)
                    response = f"Error while recognition iumage. Try again later."
                    self.GenerateLLMResponse.value = False
                    self.task_GenerateResponseProcess_started = False
                    await asyncio.get_event_loop().run_in_executor(None, self.output_queue.put, (request_id, response))

    
    def _run(self):
        asyncio.run(self.Get_LLM_Response())

    GRP = Process(target=GenerateResponseProcess(input_queue_3, output_queue_3, ImageInterpretation, TranscriptProcessor, GenerateLLMResponse, Wispper, task_GenerateResponseProcess_started)._run)
    processes.append(GRP)
    TPP.start(), IIP.start(), GRP.start()