Update app.py

app.py

@@ -1,41 +1,49 @@
 import os
 import gradio as gr
 from gradio import ChatMessage
-from typing import Iterator, List, Tuple, Optional # Добавили типы
+from typing import Iterator, List, Tuple, Optional
 import google.generativeai as genai
-import time # Import time module for potential debugging/delay
+import time
 
 print("import library complete")
 print("add API key")
 
 # get Gemini API Key from the environ variable
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
-# --- Безопасность: Добавим проверку наличия ключа ---
 if not GEMINI_API_KEY:
-    raise ValueError("GEMINI_API_KEY environment variable not set!")
-# ----------------------------------------------------
-genai.configure(api_key=GEMINI_API_KEY)
-
+    # Если ключ не найден, можно либо вызвать ошибку, либо попробовать работать без него (если модель это позволяет)
+    print("Warning: GEMINI_API_KEY environment variable not set!")
+    # raise ValueError("GEMINI_API_KEY environment variable not set!") # Раскомментируйте, чтобы требовать ключ
+    # На случай если используется модель, не требующая ключа, или для локальных тестов UI
+    genai.configure(api_key="DUMMY_KEY_IF_NEEDED") # Заглушка, если API Key не обязателен для используемой модели/библиотеки
+else:
+    genai.configure(api_key=GEMINI_API_KEY)
 
 print("add API key complete ")
 print("add model")
 
-# --- Используем более подходящую модель для чата, если Gemma IT недоступна или неоптимальна ---
-used_model = "gemma-3-27b-it" # Gemma может не поддерживать role='model' явно, Gemini Pro лучше для чата
-#used_model = "gemini-1.5-flash-latest" # Рекомендуется для чата с историей
-# ------------------------------------------------------------------------------------------
-model = genai.GenerativeModel(used_model)
-
-print(f"add model {used_model} complete\n")
+# --- Возвращаем модель из лога пользователя ---
+used_model = "gemma-3-27b-it"
+# -------------------------------------------
+# --- Инициализация модели ---
+try:
+    model = genai.GenerativeModel(used_model)
+    print(f"add model {used_model} complete\n")
+except Exception as model_init_error:
+    print(f"Error initializing model {used_model}: {model_init_error}")
+    # Можно завершить работу или использовать запасную модель
+    raise model_init_error # Завершаем, если модель не инициализирована
+# ----------------------------
 
 def format_chat_history(messages: list) -> list:
     print("\nstart format history")
     """
-    Formats the chat history into a structure Gemini can understand
+    Formats the chat history into a structure the API expects.
+    NOTE: Gemma models might expect 'assistant' role instead of 'model'.
+    Adjust if you encounter issues with history context.
     """
     formatted_history = []
     for message in messages:
-        # Пропускаем пустые сообщения или сообщения без контента (на всякий случай)
         content = message.get("content")
         if not content:
             continue
@@ -47,27 +55,30 @@ def format_chat_history(messages: list) -> list:
                 "parts": [content]
             })
         elif role == "assistant":
-             # Пропускаем "thinking" сообщения, если они есть (хотя мы их убрали)
-            if not message.get("metadata"):
+             if not message.get("metadata"): # Skip potential metadata-only messages
+                 # --- Используем 'model' - стандарт для google-generativeai. ---
+                 # --- Если Gemma требует 'assistant', измените здесь. ---
                  formatted_history.append({
-                    "role": "model", # Gemini API ожидает 'model' для ответов ассистента
+                    "role": "model",
                     "parts": [content]
                  })
-        # Игнорируем другие возможные роли или типы сообщений
+                 # --- Альтернатива для Gemma, если 'model' не работает: ---
+                 # formatted_history.append({
+                 #    "role": "assistant",
+                 #    "parts": [content]
+                 # })
+                 # ----------------------------------------------------------
     print(f"Formatted history length: {len(formatted_history)}")
+    # print(f"Formatted history content: {formatted_history}") # Отладка: посмотреть историю
     print("return formatted history")
     return formatted_history
 
-# --- Новая функция для Undo ---
+# --- Функция Undo ---
 def undo_last(history: List[ChatMessage]) -> Tuple[List[ChatMessage], List[ChatMessage]]:
-    """
-    Removes the last user message and the last assistant response.
-    Returns the updated history and the pair that was removed (for potential redo).
-    """
     print("\nAttempting Undo")
     undone_pair = []
     if len(history) >= 2:
-        # Проверяем, что последние два сообщения - это user и assistant
+        # Ensure the last two are user and assistant in that order
         if history[-2].role == "user" and history[-1].role == "assistant":
             print("Found user/assistant pair to undo.")
             undone_pair = history[-2:]
@@ -77,36 +88,26 @@ def undo_last(history: List[ChatMessage]) -> Tuple[List[ChatMessage], List[ChatM
     else:
         print("Not enough messages in history to undo.")
     return history, undone_pair
-# -----------------------------
 
-# --- Новая функция для Redo ---
+# --- Функция Redo ---
 def redo_last(history: List[ChatMessage], undone_pair: List[ChatMessage]) -> Tuple[List[ChatMessage], List[ChatMessage]]:
-    """
-    Restores the last undone user/assistant pair.
-    Returns the updated history and clears the undone pair state.
-    """
     print("\nAttempting Redo")
-    if undone_pair:
+    if undone_pair and len(undone_pair) == 2:
         print("Found undone pair to redo.")
         history.extend(undone_pair)
-        undone_pair = [] # Очищаем состояние после восстановления
+        undone_pair = [] # Clear the state after redoing
     else:
-        print("No undone pair available to redo.")
+        print("No valid undone pair available to redo.")
+        undone_pair = [] # Ensure it's cleared even if invalid
     return history, undone_pair
-# -----------------------------
 
-# --- Новая функция для Regenerate ---
+# --- Функция Regenerate ---
 def regenerate_response(history: List[ChatMessage]) -> Tuple[List[ChatMessage], Optional[str], List[ChatMessage]]:
-    """
-    Removes the last assistant response and returns the history ending
-    with the last user message, and the content of that user message.
-    Also returns an empty list to clear the undone_state.
-    """
     print("\nAttempting Regenerate")
     last_user_message_content = None
-    history_for_regen = history[:] # Создаем копию
+    history_for_regen = history[:] # Work on a copy
 
-    # Ищем последний user message с конца
+    # Find the index of the last user message
     last_user_index = -1
     for i in range(len(history_for_regen) - 1, -1, -1):
         if history_for_regen[i].role == "user":
@@ -114,126 +115,137 @@ def regenerate_response(history: List[ChatMessage]) -> Tuple[List[ChatMessage],
             break
 
     if last_user_index != -1:
-        print(f"Found last user message at index {last_user_index}")
-        last_user_message_content = history_for_regen[last_user_index].content
-        # Обрезаем историю до этого user message включительно
-        history_for_regen = history_for_regen[:last_user_index + 1]
-        print("Prepared history for regeneration.")
+        # Check if the very next message is an assistant message (the one to remove)
+        if last_user_index + 1 < len(history_for_regen) and history_for_regen[last_user_index + 1].role == "assistant":
+            print(f"Found last user message at {last_user_index}, removing assistant response at {last_user_index + 1}")
+            last_user_message_content = history_for_regen[last_user_index].content
+            # Trim history up to and including the last user message
+            history_for_regen = history_for_regen[:last_user_index + 1]
+            print("Prepared history for regeneration.")
+        elif last_user_index == len(history_for_regen) - 1:
+             # Last message IS the user message, nothing to remove after it
+             print(f"Last message is the user message at {last_user_index}. Ready for regeneration.")
+             last_user_message_content = history_for_regen[last_user_index].content
+             # History is already correct
+        else:
+             print(f"Found last user message at {last_user_index}, but the next message is not an assistant response. Cannot regenerate.")
+             history_for_regen = history # Revert to original history
+             last_user_message_content = None
     else:
         print("No user message found to regenerate from.")
-        history_for_regen = history # Возвращаем оригинал, если не нашли
-
-    # Регенерация инвалидирует предыдущее undo
-    return history_for_regen, last_user_message_content, [] # Возвращаем историю и контент пользователя, очищаем undone_state
-# ----------------------------------
+        history_for_regen = history # Revert to original history
 
+    # Regeneration invalidates the previous undo state
+    return history_for_regen, last_user_message_content, []
 
+# --- Функция стриминга ответа ---
 def stream_gemini_response(user_message: str, messages: list) -> Iterator[list]:
     print("start model response stream")
-    """
-    Streams response with conversation history support for text input only.
-    (Убрали логику "Thinking" для упрощения и совместимости)
-    """
-    # --- Добавили проверку на None или пустую строку ---
     if not user_message or not user_message.strip():
-        print("Empty or None user message received. Skipping API call.")
-        # Можно добавить сообщение об ошибке или просто ничего не делать
-        # messages.append(ChatMessage(role="assistant", content="Please provide a non-empty text message."))
-        yield messages # Просто возвращаем текущее состояние
+        print("Empty or None user message received in stream_gemini_response. Skipping API call.")
+        yield messages
         return
-    # -----------------------------------------------------
+
+    # Ensure messages list is not empty before formatting/sending
+    if not messages:
+         print("Error: Message history is empty before sending to API.")
+         messages.append(ChatMessage(role="assistant", content="Error: History is empty."))
+         yield messages
+         return
 
     try:
-        print(f"\n=== New Request (Text) ===")
-        print(f"User message: {user_message}") # Может быть None при регенерации, но мы проверили выше
-
-        # Форматируем историю *перед* добавлением нового ответа ассистента
-        # Важно: история для API должна содержать только завершенные user/model пары
-        chat_history = format_chat_history(messages) # messages здесь уже содержит user message, с которого регенерируем, или новый
-
-        print("Chat parameter")
-        chat = model.start_chat(history=chat_history)
-        print("Start response")
-        # Отправляем *только* последнее сообщение пользователя (которое уже есть в messages)
-        # Gemini API берет историю из start_chat, а последнее сообщение из send_message
-        # Важно: user_message здесь - это то, на что мы генерируем ответ
+        print(f"\n=== New Request ===")
+        print(f"User message to send: '{user_message}'") # This is the trigger message
+        print(f"Current history length before API call: {len(messages)}")
+
+        # Format history *up to the last user message*
+        # The API takes the history via start_chat and the latest message via send_message
+        # Important: Ensure the history sent doesn't contain the assistant message we are about to generate
+        history_to_send = format_chat_history(messages[:-1] if messages[-1].role == "user" else messages) # Send history *before* the current user trigger
+
+        print(f"Formatted history length for API: {len(history_to_send)}")
+
+        print("Initializing chat with history...")
+        chat = model.start_chat(history=history_to_send)
+        print(f"Sending message '{user_message}' to model...")
         response = chat.send_message(user_message, stream=True)
 
         response_buffer = ""
-        # Добавляем пустое сообщение ассистента, которое будем обновлять
+        # Add an empty assistant message placeholder to update
         messages.append(ChatMessage(role="assistant", content=""))
-        yield messages # Показываем пустой контейнер для ответа
+        yield messages # Show the placeholder immediately
 
         print("Streaming response...")
+        chunk_count = 0
         for chunk in response:
-            # --- Обработка возможных ошибок в чанке ---
+            chunk_count += 1
             try:
-                # Проверяем наличие candidates и parts
-                if chunk.candidates and chunk.candidates[0].content and chunk.candidates[0].content.parts:
+                # Defensive coding: Check structure exists before accessing
+                current_chunk_text = ""
+                if chunk.candidates and \
+                   chunk.candidates[0].content and \
+                   chunk.candidates[0].content.parts:
                     current_chunk_text = chunk.candidates[0].content.parts[0].text
-                    # print(f"Chunk: '{current_chunk_text}'") # Отладка чанков
+                elif hasattr(chunk, 'text'): # Fallback for simpler text responses
+                     current_chunk_text = chunk.text
+
+                if current_chunk_text:
+                    # print(f"Chunk {chunk_count}: '{current_chunk_text}'") # Debug chunk content
                     response_buffer += current_chunk_text
                     messages[-1] = ChatMessage(
                         role="assistant",
                         content=response_buffer
                     )
                 else:
-                    # Обработка случая, когда структура чанка неожиданная
-                    print(f"Warning: Unexpected chunk structure: {chunk}")
-                    # Можно добавить запасной вариант или пропустить чанк
-                    if hasattr(chunk, 'text'): # Иногда API возвращает просто text
-                         response_buffer += chunk.text
-                         messages[-1] = ChatMessage(role="assistant", content=response_buffer)
-
-            except (AttributeError, IndexError, ValueError) as chunk_err:
-                 # Ловим ошибки доступа к атрибутам/индексам или другие проблемы чанка
-                 print(f"Error processing chunk: {chunk_err}")
+                    # Handle cases where a chunk might be empty or have unexpected structure
+                    print(f"Warning: Received empty or unexpected chunk structure at chunk {chunk_count}: {chunk}")
+
+            except (AttributeError, IndexError, ValueError, StopIteration) as chunk_err:
+                 print(f"Error processing chunk {chunk_count}: {chunk_err}")
                  print(f"Problematic chunk data: {chunk}")
-                 # Можно прервать или продолжить, добавив сообщение об ошибке
                  messages[-1] = ChatMessage(
                      role="assistant",
-                     content=response_buffer + f"\n\n[Ошибка обработки части ответа: {chunk_err}]"
+                     content=response_buffer + f"\n\n[Error processing response part: {chunk_err}]"
                  )
                  yield messages
-                 return # Прерываем стриминг при ошибке в чанке
-            # -------------------------------------------
+                 return # Stop streaming on chunk error
 
-            # time.sleep(0.05) # Раскомментируйте для замедления стриминга (отладка)
-            yield messages # Отправляем обновленное сообщение в интерфейс
-
-        print(f"\n=== Final Response ===\n{response_buffer}")
-        # Проверка на пустой финальный ответ (если модель ничего не вернула)
-        if not response_buffer.strip() and len(messages) > 0 and messages[-1].role == "assistant":
-             messages[-1] = ChatMessage(
-                 role="assistant",
-                 content="[Модель не дала ответа]"
-             )
-             yield messages
+            # time.sleep(0.05) # Optional delay for debugging
+            yield messages # Update UI with the latest buffer content
 
+        print(f"\n=== Final Response ({chunk_count} chunks received) ===\n{response_buffer}")
+        if chunk_count == 0 or not response_buffer.strip():
+             # Handle case where the stream finished but buffer is empty
+             print("Warning: Stream finished but response buffer is empty.")
+             if messages and messages[-1].role == "assistant":
+                 messages[-1] = ChatMessage(role="assistant", content="[Model provided no response]")
+                 yield messages
 
-    # --- Улучшенная обработка ошибок API ---
     except Exception as e:
-        error_message = f"Произошла ошибка при обращении к Gemini API: {str(e)}"
-        print(f"\n=== Error ===\n{error_message}")
-        # Пытаемся добавить сообщение об ошибке в чат, если возможно
-        if messages and isinstance(messages[-1], ChatMessage) and messages[-1].role == "assistant" and messages[-1].content == "":
-            # Если последний элемент - пустое сообщение ассистента, заменяем его ошибкой
+        error_message = f"Error calling Gemini API: {str(e)}"
+        print(f"\n=== API Error ===\n{error_message}")
+        # Attempt to add or replace the last message with the error
+        if messages and messages[-1].role == "assistant" and messages[-1].content == "":
              messages[-1] = ChatMessage(role="assistant", content=error_message)
         else:
-            # Иначе добавляем новое сообщение с ошибкой
              messages.append(ChatMessage(role="assistant", content=error_message))
         yield messages
-    # -------------------------------------
-
 
+# --- Фу��кция добавления сообщения пользователя ---
 def user_message(msg: str, history: list) -> tuple[str, list, list]:
     """Adds user message to chat history and clears the undone state."""
     print(f"\nUser message added: '{msg}'")
-    history.append(ChatMessage(role="user", content=msg))
-    # Новое сообщение пользователя инвалидирует предыдущее undo
-    return "", history, [] # Возвращаем пустую строку, историю и пустой undone_state
+    if msg and msg.strip(): # Only add non-empty messages
+        history.append(ChatMessage(role="user", content=msg))
+    else:
+        print("Skipping empty user message.")
+    # New user message invalidates previous undo state
+    return "", history, [] # Return empty string to clear textbox, updated history, empty undone_state
 
-# Create the Gradio interface
+
+# ==================================
+# --- Gradio Interface Definition ---
+# ==================================
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="slate", neutral_hue="neutral")) as demo:
     gr.Markdown("# Chat with " + used_model)
 
@@ -241,138 +253,141 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="slate", n
                <img src="https://api.visitorbadge.io/api/combined?path=https%3A%2F%2Fhuggingface.co%2Fspaces%2Fzelk12%2FGemini-2&countColor=%23263759" />
                </a>""")
 
-    # --- Добавляем состояние для Undo/Redo ---
+    # State for Undo/Redo
     undone_state = gr.State([])
-    # --------------------------------------
 
     chatbot = gr.Chatbot(
-        [], # Начинаем с пустого списка
+        [], # Start empty
         type="messages",
         label=used_model + " Chatbot (Streaming Output)",
         render_markdown=True,
         scale=1,
-        # editable="all", # editable="all" может мешать undo/redo, лучше отключить или user
-        editable=False,
+        editable=False, # Keep False to avoid conflicts with history management
         avatar_images=(None,"https://lh3.googleusercontent.com/oxz0sUBF0iYoN4VvhqWTmux-cxfD1rxuYkuFEfm1SFaseXEsjjE4Je_C_V3UQPuJ87sImQK3HfQ3RXiaRnQetjaZbjJJUkiPL5jFJ1WRl5FKJZYibUA=w214-h214-n-nu"),
-        height=600 # Задаем высоту для лучшего вида
+        height=600
     )
 
-    with gr.Row(equal_height=False): # equal_height=False может быть лучше для кнопок разной высоты
+    with gr.Row(equal_height=False):
         input_box = gr.Textbox(
             lines=1,
             label="Chat Message",
             placeholder="Type your message here...",
-            scale=4
+            scale=4,
+            container=False # Better alignment potentially
         )
 
-        # --- Группируем кнопки управления ---
-        with gr.Column(scale=1, min_width=150): # Даем минимальную ширину колонке с кнопками
-             submit_button = gr.Button("Submit", scale=1, variant="primary") # Выделяем основную кнопку
+        with gr.Column(scale=1, min_width=150):
+             submit_button = gr.Button("Submit", scale=1, variant="primary")
              with gr.Row():
                  undo_button = gr.Button("Undo", scale=1)
                  redo_button = gr.Button("Redo", scale=1)
              regenerate_button = gr.Button("Regenerate", scale=1)
              clear_button = gr.Button("Clear Chat", scale=1)
 
-
-    # --- Переименовали кнопки для ясности ---
-    # undo_button = test_button
-    # redo_button = test1_button
-    # regenerate_button = test2_button
-    # ----------------------------------------
-
-    # Add example prompts
+    # Examples
     example_prompts = [
         ["Write a short poem about the sunset."],
         ["Explain the theory of relativity in simple terms."],
-        ["If a train leaves Chicago at 6am traveling at 60mph, and another train leaves New York at 8am traveling at 80mph, at what time will they meet?"],
         ["Summarize the plot of Hamlet."],
         ["Write a haiku about a cat."]
     ]
-
     gr.Examples(
         examples=example_prompts,
         inputs=input_box,
-        label="Examples: Try these prompts!", # Убрали про thinking, т.к. убрали его вывод
-        examples_per_page=5
+        label="Examples:",
+        examples_per_page=4
     )
 
-    # --- Обновленные обработчики событий ---
-    msg_store = gr.State("") # Store for preserving user message during processing
+    # State to hold the message content for streaming
+    msg_store = gr.State("")
+
+    # --- Event Handlers ---
+
+    # --- Helper function to get last user message content ---
+    def get_last_user_message(history: List[ChatMessage]) -> Optional[str]:
+        if history and history[-1].role == "user":
+            return history[-1].content
+        print("Warning: Could not find last user message in history for get_last_user_message")
+        return None # Return None if history is empty or last message isn't user
 
-    # --- Обработчик для Enter в input_box ---
+    # --- Handler for Enter key in input_box ---
     input_box.submit(
-        user_message,  # 1. Добавить сообщение пользователя в историю, очистить undone_state
+        user_message,
         inputs=[input_box, chatbot],
-        outputs=[input_box, chatbot, undone_state] # input_box очищается первым возвращаемым значением ""
+        outputs=[input_box, chatbot, undone_state] # Clears input, updates history, clears undo
     ).then(
-        lambda x: (x, x), # 2. Скопировать сообщение из history[-1].content в msg_store для stream_gemini_response
-        inputs=[chatbot], # Берем историю, где последнее сообщение - пользовательское
-        outputs=[msg_store, msg_store], # Копируем контент последнего сообщения (пользователя)
-        fn=lambda history: (history[-1].content, history[-1].content) if history and history[-1].role == "user" else (None, None)
+        # No positional lambda here! Use fn=
+        fn=get_last_user_message, # 2. Get content of the message just added
+        inputs=[chatbot],
+        outputs=[msg_store], # Store it for streaming
+        queue=False # Getting content is fast
     ).then(
-        stream_gemini_response,  # 3. Сгенерировать и стримить ответ
-        inputs=[msg_store, chatbot], # Используем сохраненное сообщение и обновленную историю
+        stream_gemini_response, # 3. Stream response using stored message and updated history
+        inputs=[msg_store, chatbot],
         outputs=[chatbot]
+        # queue=True by default for potentially long API calls
     )
 
-    # --- Обработчик для кнопки Submit ---
+    # --- Handler for Submit button click ---
     submit_button.click(
-        user_message, # 1. Добавить сообщение пользователя, очистить undone_state
+        user_message,
         inputs=[input_box, chatbot],
-        outputs=[input_box, chatbot, undone_state]
+        outputs=[input_box, chatbot, undone_state] # Clears input, updates history, clears undo
     ).then(
-        lambda x: (x, x), # 2. Скопировать сообщение пользователя в msg_store
+        # No positional lambda here! Use fn=
+        fn=get_last_user_message, # 2. Get content of the message just added
         inputs=[chatbot],
-        outputs=[msg_store, msg_store],
-        fn=lambda history: (history[-1].content, history[-1].content) if history and history[-1].role == "user" else (None, None)
+        outputs=[msg_store], # Store it for streaming
+        queue=False # Getting content is fast
     ).then(
-        stream_gemini_response, # 3. Сгенерировать ответ
+        stream_gemini_response, # 3. Stream response using stored message and updated history
         inputs=[msg_store, chatbot],
         outputs=[chatbot]
+        # queue=True by default
     )
 
-    # --- Обработчик для кнопки Clear ---
+    # --- Handler for Clear button ---
     clear_button.click(
-        lambda: ([], "", [], ""), # Очищаем chatbot, input_box, msg_store, undone_state
+        lambda: ([], "", [], ""), # Clear chatbot, input_box, msg_store, undone_state
         outputs=[chatbot, input_box, msg_store, undone_state],
-        queue=False # Очистка быстрая, очередь не нужна
+        queue=False
     )
 
-    # --- Обработчик для кнопки Undo ---
+    # --- Handler for Undo button ---
     undo_button.click(
         undo_last,
         inputs=[chatbot],
-        outputs=[chatbot, undone_state], # Обновляем историю и сохраняем удаленную пару
-        queue=False # Действие быстрое
+        outputs=[chatbot, undone_state],
+        queue=False
     )
 
-    # --- Обработчик для кнопки Redo ---
+    # --- Handler for Redo button ---
     redo_button.click(
         redo_last,
-        inputs=[chatbot, undone_state], # Нужна история и сохраненная пара
-        outputs=[chatbot, undone_state], # Обновляем историю и очищаем сохраненную пару
-        queue=False # Действие быстрое
+        inputs=[chatbot, undone_state],
+        outputs=[chatbot, undone_state],
+        queue=False
     )
 
-    # --- Обработчик для кнопки Regenerate ---
+    # --- Handler for Regenerate button ---
     regenerate_button.click(
-        regenerate_response, # 1. Подготовить историю и получить сообщение пользователя, очистить undone_state
+        regenerate_response, # 1. Prepare history, get last user msg, clear undo
         inputs=[chatbot],
-        outputs=[chatbot, msg_store, undone_state] # Обновляем историю, помещаем user msg в msg_store, очищаем undone
+        outputs=[chatbot, msg_store, undone_state] # Update history, put user msg in store, clear undo
+        # queue=False # Preparation should be fast
     ).then(
-        stream_gemini_response, # 2. Сгенерировать новый ответ на user msg из msg_store
-        inputs=[msg_store, chatbot], # Используем user msg из msg_store и подготовленную историю
+        stream_gemini_response, # 2. Stream new response using msg from store and prepared history
+        inputs=[msg_store, chatbot],
         outputs=[chatbot]
+        # queue=True by default
     )
-    # -------------------------------------
 
     gr.Markdown(
         """
         <br><br><br>
         ---
         ### About this Chatbot
-        **Try out the example prompts below!**
+        **Try out the example prompts!**
         **Key Features:**
         *   Powered by Google's **""" + used_model + """** model.
         *   Supports **conversation history**, **undo**, **redo**, and **regenerate**.
@@ -386,11 +401,9 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="slate", n
         """
     )
 
-
 # Launch the interface
 if __name__ == "__main__":
-    # --- Добавим возможность запускать на публичном URL через share=True ---
-    # demo.launch(debug=True) # Для локальной отладки
-    demo.launch(share=True) # Для получения публичной ссылки (если нужно)
-    # demo.launch() # Стандартный локальный запуск
-    # -----------------------------------------------------------------
+    print("Starting Gradio Interface...")
+    # demo.launch(debug=True) # For detailed debugging
+    # demo.launch(share=True) # To get a public link
+    demo.launch() # Standard local launch