Update app.py

app.py

@@ -15,14 +15,14 @@ if not GEMINI_API_KEY:
     exit()
 genai.configure(api_key=GEMINI_API_KEY)
 
-# Доступные модели
+# Список доступных моделей
 AVAILABLE_MODELS = [
     "gemini-1.5-flash",
     "gemini-1.5-pro",
-    "gemini-2.0-flash-thinking-exp",
+    "gemini-2.0-flash-thinking-exp"
 ]
 
-# Пытаемся инициализировать все модели заранее и складываем в словарь
+# Инициализируем модели и храним их в словаре
 MODELS = {}
 for model_name in AVAILABLE_MODELS:
     try:
@@ -30,34 +30,32 @@ for model_name in AVAILABLE_MODELS:
     except Exception as e:
         print(f"[Предупреждение] Не удалось инициализировать модель {model_name}: {e}")
 
-
 ###############################################################################
-# 2. Утилиты для преобразования истории Gradio <-> Gemini
+# 2. Утилиты для преобразования истории между Gradio-форматом и Gemini
 ###############################################################################
 
 def _history_gradio_to_genai(history):
     """
-    Gradio хранит чат как [(user_msg, bot_msg), (user_msg, bot_msg), ...].
-    Для Gemini нужен формат [{'role': 'user', 'content': ...}, ...].
+    Gradio хранит историю как [(user_msg, bot_msg), (user_msg, bot_msg), ...].
+    Библиотека google.generativeai ждёт [{'role': 'user', 'parts': ...}, {'role': 'assistant', 'parts': ...}, ...].
     """
     genai_history = []
     for user_text, bot_text in history:
         if user_text:
-            genai_history.append({"role": "user", "content": user_text})
+            genai_history.append({"role": "user", "parts": user_text})
         if bot_text:
-            genai_history.append({"role": "assistant", "content": bot_text})
+            genai_history.append({"role": "assistant", "parts": bot_text})
     return genai_history
 
 
 ###############################################################################
-# 3. Функции-генераторы для запроса ответа от моделей (обычный/thinking)
+# 3. Асинхронные генераторы для получения ответа от моделей
 ###############################################################################
 
 async def _respond_stream(model_name, user_message, history):
     """
-    Генерация ответа для Обычных моделей (без thinking) с помощью stream=True
-    - Возвращаем куски текста через yield
-    - В конце просто делаем return (без значения)
+    Генерация ответа (постепенного, stream=True) для обычных моделей (без thinking).
+    Возвращаем кусочки текста через yield.
     """
     if model_name not in MODELS:
         yield "Ошибка: модель не найдена."
@@ -67,17 +65,18 @@ async def _respond_stream(model_name, user_message, history):
     genai_history = _history_gradio_to_genai(history)
 
     try:
+        # Создаём чат с уже накопленной историей
         chat = model.start_chat(history=genai_history)
+        # Запрашиваем стриминг (постепенный) ответа
         response_stream = chat.send_message(user_message, stream=True)
 
         partial_text = ""
         for chunk in response_stream:
             chunk_text = chunk.text or ""
             partial_text += chunk_text
-            # Возвращаем промежуточный вариант ответа
             yield partial_text
 
-        return  # Завершить генератор без возвращения значения
+        return  # Завершить генератор без значения
     except Exception as e:
         yield f"Ошибка при запросе к API: {e}"
         return
@@ -85,29 +84,28 @@ async def _respond_stream(model_name, user_message, history):
 
 async def _respond_thinking(model_name, user_message, history):
     """
-    Генерация ответа для модели с "thinking" (например, gemini-2.0-flash-thinking-exp).
-    1) Сначала выдаём "Думаю..."
-    2) Затем, когда модель ответит (stream=False), выделяем thinking + финальный ответ.
-    3) Возвращаем (полезный_ответ, размышления) в виде кортежа.
-       В Gradio это обычно [(assistant_text, thinking_text), ...].
+    Генерация ответа для thinking-модели (gemini-2.0-flash-thinking-exp).
+    1) Сначала отдаём "Думаю..."
+    2) Затем формируем итоговый ответ + собираем «размышления» part.thought == True.
     """
     if model_name not in MODELS:
-        # Выдаем ошибку через yield
         yield "Ошибка: модель не найдена.", ""
         return
 
     model = MODELS[model_name]
     genai_history = _history_gradio_to_genai(history)
 
-    # Шаг 1: временно "Думаю..."
+    # Шаг 1: сообщаем "Думаю..."
     yield "Думаю...", ""
 
     try:
         chat = model.start_chat(history=genai_history)
+        # Без стриминга — дожидаемся полного ответа
         response = chat.send_message(user_message, stream=False)
 
         thinking_process_text = ""
         final_text = ""
+
         if response.candidates:
             parts = response.candidates[0].content.parts
             for p in parts:
@@ -116,7 +114,6 @@ async def _respond_thinking(model_name, user_message, history):
                 else:
                     final_text += p.text or ""
 
-        # Возвращаем готовый ответ и размышления
         yield final_text, thinking_process_text
         return
     except Exception as e:
@@ -125,7 +122,7 @@ async def _respond_thinking(model_name, user_message, history):
 
 
 ###############################################################################
-# 4. Основная асинхронная функция Gradio, обрабатывающая новый пользовательский ввод
+# 4. Основная функция для обработки нового пользовательского сообщения в Gradio
 ###############################################################################
 
 async def user_send_message(
@@ -136,29 +133,27 @@ async def user_send_message(
 ):
     """
     Параметры:
-      user_message: вход от пользователя (текущая реплика)
-      history: история [(user, assistant), ...]
-      model_name: выбранная модель
+      user_message : строка, введённая пользователем
+      history      : текущая история [(user, assistant), ...]
+      model_name   : выбранная модель
       thinking_text: текущее содержимое поля «Размышления»
-
-    Выход (через yield):
-      (обновлённая история, обновлённое thinking_text)
+    
+    Возвращаем (обновлённую историю, обновлённое thinking_text) пошагово через yield.
     """
-    # Если пользователь ничего не ввёл, просто возвращаем текущее состояние
     if not user_message.strip():
+        # Если пользователь не ввёл ничего, не делаем запрос
         yield history, thinking_text
         return
 
-    # Добавляем новую запись в историю: ассистент пока None
+    # Добавляем новый шаг в историю (ассистент пока None)
     history.append((user_message, None))
 
-    # Проверяем, thinking-модель ли
+    # Если модель — thinking
     if "thinking" in model_name.lower():
-        # Обрабатываем через _respond_thinking
         async for (assistant_text, thought_text) in _respond_thinking(model_name, user_message, history):
-            # Обновляем последнюю пару в истории
+            # Обновляем последний элемент истории
             history[-1] = (user_message, assistant_text)
-            # Обновляем thinking_text
+            # Записываем «размышления» во второе поле
             yield history, thought_text
         return
     else:
@@ -167,7 +162,6 @@ async def user_send_message(
         async for chunk in _respond_stream(model_name, user_message, history):
             partial_answer = chunk
             history[-1] = (user_message, partial_answer)
-            # В обычном режиме thinking_text = ""
             yield history, ""
         return
 
@@ -177,40 +171,33 @@ async def user_send_message(
 ###############################################################################
 
 def clear_all():
-    """
-    Полная очистка чата и размышлений.
-    """
-    return [], ""  # (history, thinking_store)
+    """ Очистить историю и размышления. """
+    return [], ""
 
 
 ###############################################################################
-# 6. Определяем интерфейс Gradio
+# 6. Gradio-интерфейс
 ###############################################################################
 
 with gr.Blocks() as demo:
-    gr.Markdown("## Gemini Chatbot (с сохранением истории и thinking-режимом)")
+    gr.Markdown("## Chat с Gemini (поддержка разных моделей и «thinking»-режима)")
 
     with gr.Row():
         model_dropdown = gr.Dropdown(
             choices=AVAILABLE_MODELS,
             value="gemini-1.5-flash",
-            label="Выберите модель",
+            label="Выберите модель"
         )
         clear_button = gr.Button("Очистить чат")
 
-    # Храним историю чата в gr.State
-    history_state = gr.State([])  # список кортежей (user, assistant)
-    # Храним «размышления» отдельно
-    thinking_store = gr.State("")
+    # Состояние для хранения истории и размышлений
+    history_state = gr.State([])   # [(user, assistant), ...]
+    thinking_store = gr.State("")  # текст размышлений
 
     chatbot = gr.Chatbot(label="Диалог с Gemini")
+    user_input = gr.Textbox(label="Ваш вопрос", placeholder="Введите текст...")
 
-    user_input = gr.Textbox(
-        label="Ваш вопрос",
-        placeholder="Введите вопрос и нажмите Enter...",
-    )
-
-    # Отдельный блок для показа «размышлений»
+    # Поле для размышлений
     thinking_output = gr.Textbox(
         label="Размышления (только для gemini-2.0-flash-thinking-exp)",
         interactive=False
@@ -218,62 +205,66 @@ with gr.Blocks() as demo:
 
     send_btn = gr.Button("Отправить")
 
-    # Связка: кнопка «Отправить» => user_send_message => обновление истории и размышлений
-    send_btn.click(
+    # 1) При нажатии «Отправить»
+    send_chain = send_btn.click(
         fn=user_send_message,
         inputs=[user_input, history_state, model_dropdown, thinking_store],
         outputs=[history_state, thinking_store],
         queue=True
-    ).then(
-        # После того как получили новую историю, обновляем чат
+    )
+    # Затем обновляем чат
+    send_chain.then(
         fn=lambda h: h,
         inputs=[history_state],
         outputs=[chatbot],
         queue=True
-    ).then(
-        # После этого выводим thinking_store
+    )
+    # И отображаем размышления
+    send_chain.then(
         fn=lambda t: t,
         inputs=[thinking_store],
         outputs=[thinking_output],
         queue=True
     )
 
-    # Аналогичное поведение при нажатии Enter в поле ввода
-    user_input.submit(
+    # 2) При нажатии Enter в textbox
+    submit_chain = user_input.submit(
         fn=user_send_message,
         inputs=[user_input, history_state, model_dropdown, thinking_store],
         outputs=[history_state, thinking_store],
         queue=True
-    ).then(
+    )
+    submit_chain.then(
         fn=lambda h: h,
         inputs=[history_state],
         outputs=[chatbot],
         queue=True
-    ).then(
+    )
+    submit_chain.then(
         fn=lambda t: t,
         inputs=[thinking_store],
         outputs=[thinking_output],
         queue=True
     )
 
-    # Кнопка «Очистить» сбрасывает историю и thinking_store
-    clear_button.click(
+    # 3) Кнопка «Очистить»
+    clear_chain = clear_button.click(
         fn=clear_all,
         inputs=[],
         outputs=[history_state, thinking_store],
         queue=False
-    ).then(
-        # Затем обновляем чат
+    )
+    clear_chain.then(
         fn=lambda h: h,
         inputs=[history_state],
         outputs=[chatbot]
-    ).then(
-        # И обнуляем thinking_output
+    )
+    clear_chain.then(
         fn=lambda _: "",
         inputs=[],
         outputs=[thinking_output]
     )
 
-# Запуск Gradio
+# Запуск приложения
 if __name__ == "__main__":
     demo.launch()