Update app.py

app.py

@@ -1,409 +1,318 @@
 import os
 import gradio as gr
 from gradio import ChatMessage
-from typing import Iterator, List, Tuple, Optional
+from typing import Iterator
 import google.generativeai as genai
-import time
+import time # Import time module for potential debugging/delay
 
 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:
-    # Если ключ не найден, можно либо вызвать ошибку, либо попробовать работать без него (если модель это позволяет)
-    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)
+genai.configure(api_key=GEMINI_API_KEY)
 
 print("add API key complete ")
 print("add model")
 
-# --- Возвращаем модель из лога пользователя ---
 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 # Завершаем, если модель не инициализирована
-# ----------------------------
+
+# we will be using the Gemini 2.0 Flash model with Thinking capabilities
+model = genai.GenerativeModel(used_model)
+
+print(f"add model {used_model} complete\n")
 
 def format_chat_history(messages: list) -> list:
     print("\nstart format history")
     """
-    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.
+    Formats the chat history into a structure Gemini can understand
     """
     formatted_history = []
     for message in messages:
-        content = message.get("content")
-        if not content:
-            continue
-
-        role = message.get("role")
-        if role == "user":
+        #print(f"t1 {message}")
+        # Skip thinking messages (messages with metadata)
+        #if not (message.get("role") == "assistant" and "metadata" in message):
+        #    print(f"t2 {message}")
+        #    formatted_history.append({
+        #        "role": "user" if message.get("role") == "user" else "assistant",
+        #        "parts": [message.get("content", "")]
+        #    })
+            
+        #print(f"t2 {message}")
+
+        if message.get("role") == "user" :
+            formatted_history.append({
+            "role": "user",
+            "parts": [message.get("content", "")]
+            })
+        elif message.get("role") == "assistant" :
             formatted_history.append({
-                "role": "user",
-                "parts": [content]
+            "role": "model",
+            "parts": [message.get("content", "")]
             })
-        elif role == "assistant":
-             if not message.get("metadata"): # Skip potential metadata-only messages
-                 # --- Используем 'model' - стандарт для google-generativeai. ---
-                 # --- Если Gemma требует 'assistant', измените здесь. ---
-                 formatted_history.append({
-                    "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(f"t3 {formatted_history}")
     print("return formatted history")
     return formatted_history
 
-# --- Функция Undo ---
-def undo_last(history: List[ChatMessage]) -> Tuple[List[ChatMessage], List[ChatMessage]]:
-    print("\nAttempting Undo")
-    undone_pair = []
-    if len(history) >= 2:
-        # 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:]
-            history = history[:-2]
-        else:
-            print("Last two messages are not a user/assistant pair. Cannot undo.")
-    else:
-        print("Not enough messages in history to undo.")
-    return history, undone_pair
-
-# --- Функция Redo ---
-def redo_last(history: List[ChatMessage], undone_pair: List[ChatMessage]) -> Tuple[List[ChatMessage], List[ChatMessage]]:
-    print("\nAttempting Redo")
-    if undone_pair and len(undone_pair) == 2:
-        print("Found undone pair to redo.")
-        history.extend(undone_pair)
-        undone_pair = [] # Clear the state after redoing
-    else:
-        print("No valid undone pair available to redo.")
-        undone_pair = [] # Ensure it's cleared even if invalid
-    return history, undone_pair
-
-# --- Функция Regenerate ---
-def regenerate_response(history: List[ChatMessage]) -> Tuple[List[ChatMessage], Optional[str], List[ChatMessage]]:
-    print("\nAttempting Regenerate")
-    last_user_message_content = None
-    history_for_regen = history[:] # Work on a copy
-
-    # 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":
-            last_user_index = i
-            break
-
-    if last_user_index != -1:
-        # 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 # 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")
-    if not user_message or not user_message.strip():
-        print("Empty or None user message received in stream_gemini_response. Skipping API call.")
+    """
+    Streams thoughts and response with conversation history support for text input only.
+    """
+    if not user_message.strip(): # Robust check: if text message is empty or whitespace
+        messages.append(ChatMessage(role="assistant", content="Please provide a non-empty text message. Empty input is not allowed.")) # More specific message
         yield messages
+        print("Empty text message")
         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 ===")
-        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...")
+        print(f"\n=== New Request (Text) ===")
+        print(f"User message: {user_message}")
+
+        # Format chat history for Gemini
+        chat_history = format_chat_history(messages)
+
+        #print(f"hist {chat_history}")
+        
+        # Initialize Gemini chat
+        print("Chat parameter")
+        chat = model.start_chat(history=chat_history)
+        print("Start response")
         response = chat.send_message(user_message, stream=True)
 
+        # Initialize buffers and flags
+        thought_buffer = ""
         response_buffer = ""
-        # Add an empty assistant message placeholder to update
-        messages.append(ChatMessage(role="assistant", content=""))
-        yield messages # Show the placeholder immediately
+        #thinking_complete = False
+
+        # Add initial thinking message
+        #messages.append(
+        #    ChatMessage(
+        #        role="assistant",
+        #        content="",
+        #        metadata={"title": "⚙️ Thinking: *The thoughts produced by the model are experimental"}
+        #    )
+        #)
+        
+        messages.append(
+            ChatMessage(
+                role="assistant",
+                content=response_buffer
+            )
+        )
+        #print(f"mes {messages} \n\nhis {chat_history}")
+        
+        thinking_complete = True
 
-        print("Streaming response...")
-        chunk_count = 0
         for chunk in response:
-            chunk_count += 1
-            try:
-                # 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
-                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(
+            print("chunk start")
+            parts = chunk.candidates[0].content.parts
+            current_chunk = parts[0].text
+
+            print(f"\n=========\nparts len: {len(parts)}\n\nparts: {parts}\n\ncurrent chunk: {current_chunk}\n=========\n")
+            
+            if len(parts) == 2 and not thinking_complete:
+                # Complete thought and start response
+                thought_buffer += current_chunk
+                print(f"\n=== Complete Thought ===\n{thought_buffer}")
+
+                messages[-1] = ChatMessage(
+                    role="assistant",
+                    content=thought_buffer,
+                    metadata={"title": "⚙️ Thinking: *The thoughts produced by the model are experimental"}
+                )
+                yield messages
+
+                # Start response
+                response_buffer = parts[1].text
+                print(f"\n=== Starting Response ===\n{response_buffer}")
+
+                messages.append(
+                    ChatMessage(
                         role="assistant",
                         content=response_buffer
                     )
-                else:
-                    # 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[Error processing response part: {chunk_err}]"
-                 )
-                 yield messages
-                 return # Stop streaming on chunk error
-
-            # 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
+                )
+                thinking_complete = True
+
+            elif thinking_complete:
+                # Stream response
+                response_buffer += current_chunk
+                print(f"\n=== Response Chunk ===\n{current_chunk}")
+
+                messages[-1] = ChatMessage(
+                    role="assistant",
+                    content=response_buffer
+                )
+
+            else:
+                # Stream thinking
+                thought_buffer += current_chunk
+                print(f"\n=== Thinking Chunk ===\n{current_chunk}")
+
+                messages[-1] = ChatMessage(
+                    role="assistant",
+                    content=thought_buffer,
+                    metadata={"title": "⚙️ Thinking: *The thoughts produced by the model are experimental"}
+                )
+            #time.sleep(0.05) #Optional: Uncomment this line to add a slight delay for debugging/visualization of streaming. Remove for final version
+            print("Response end")
+            yield messages
+
+        print(f"\n=== Final Response ===\n{response_buffer}")
 
     except Exception as e:
-        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))
+        print(f"\n=== Error ===\n{str(e)}")
+        messages.append(
+            ChatMessage(
+                role="assistant",
+                content=f"I apologize, but I encountered an error: {str(e)}"
+            )
+        )
         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}'")
-    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
-
-
-# ==================================
-# --- Gradio Interface Definition ---
-# ==================================
-with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="slate", neutral_hue="neutral")) as demo:
+def user_message(msg: str, history: list) -> tuple[str, list]:
+    """Adds user message to chat history"""
+    history.append(ChatMessage(role="user", content=msg))
+    return "", history
+
+
+# Create the Gradio interface
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="slate", neutral_hue="neutral")) as demo: # Using Soft theme with adjusted hues for a refined look
     gr.Markdown("# Chat with " + used_model)
 
+    
     gr.HTML("""<a href="https://visitorbadge.io/status?path=https%3A%2F%2Fhuggingface.co%2Fspaces%2Fzelk12%2FGemini-2">
                <img src="https://api.visitorbadge.io/api/combined?path=https%3A%2F%2Fhuggingface.co%2Fspaces%2Fzelk12%2FGemini-2&countColor=%23263759" />
                </a>""")
 
-    # State for Undo/Redo
-    undone_state = gr.State([])
-
+    
     chatbot = gr.Chatbot(
-        [], # Start empty
         type="messages",
-        label=used_model + " Chatbot (Streaming Output)",
+        label=used_model + " Chatbot (Streaming Output)", #Label now indicates streaming
         render_markdown=True,
         scale=1,
-        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
+        editable="all",
+        avatar_images=(None,"https://lh3.googleusercontent.com/oxz0sUBF0iYoN4VvhqWTmux-cxfD1rxuYkuFEfm1SFaseXEsjjE4Je_C_V3UQPuJ87sImQK3HfQ3RXiaRnQetjaZbjJJUkiPL5jFJ1WRl5FKJZYibUA=w214-h214-n-nu")
     )
 
-    with gr.Row(equal_height=False):
+    with gr.Row(equal_height=True):
         input_box = gr.Textbox(
             lines=1,
             label="Chat Message",
             placeholder="Type your message here...",
-            scale=4,
-            container=False # Better alignment potentially
+            scale=4
         )
 
-        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)
+        with gr.Column(scale=1):
+            submit_button = gr.Button("Submit", scale=1)
+            clear_button = gr.Button("Clear Chat", scale=1)
+
+    with gr.Row(equal_height=True):
+        test_button = gr.Button("test", scale=1)
+        test1_button = gr.Button("test1", scale=1)
+        test2_button = gr.Button("test2", scale=1)
+        test3_button = gr.Button("test3", scale=1)
 
-    # Examples
+    # Add example prompts - removed file upload examples. Kept text focused 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:",
-        examples_per_page=4
+        label="Examples: Try these prompts to see Gemini's thinking!",
+        examples_per_page=5 # Adjust as needed
     )
 
-    # State to hold the message content for streaming
-    msg_store = gr.State("")
-
-    # --- Event Handlers ---
+# Created by gemini-2.5-pro-exp-03-25
+#def process_message(msg):
+#    """Обрабатывает сообщение пользователя: сохраняет, отображает и генерирует ответ."""
+#    msg_store_val, _, _ = lambda msg: (msg, msg, "")(msg) # Store message and clear input (inline lambda)
+#    input_box_val, chatbot_val = user_message(msg_store_val, chatbot) # Add user message to chat
+#    chatbot_val_final = stream_gemini_response(msg_store_val, chatbot_val) # Generate and stream response
+#    return msg_store_val, input_box_val, chatbot_val_final
+#
+#input_box.submit(
+#    process_message,
+#    inputs=[input_box],
+#    outputs=[msg_store, input_box, chatbot],  # Исправлены outputs, чтобы включать chatbot
+#    queue=False
+#)
+
+#submit_button.click(
+#    process_message,
+#    inputs=[input_box],
+#    outputs=[msg_store, input_box, chatbot],  # Исправлены outputs, чтобы включать chatbot
+#    queue=False
+#)
+    
+    # Set up event handlers
+    msg_store = gr.State("")  # Store for preserving user message
 
-    # --- 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
-
-    # --- Handler for Enter key in input_box ---
     input_box.submit(
-        user_message,
-        inputs=[input_box, chatbot],
-        outputs=[input_box, chatbot, undone_state] # Clears input, updates history, clears undo
+        lambda msg: (msg, msg, ""),  # Store message and clear input
+        inputs=[input_box],
+        outputs=[msg_store, input_box, input_box],
+        queue=False
     ).then(
-        # 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
+        user_message,  # Add user message to chat
+        inputs=[msg_store, chatbot],
+        outputs=[input_box, chatbot],
+        queue=False
     ).then(
-        stream_gemini_response, # 3. Stream response using stored message and updated history
+        stream_gemini_response,  # Generate and stream response
         inputs=[msg_store, chatbot],
-        outputs=[chatbot]
-        # queue=True by default for potentially long API calls
+        outputs=chatbot
     )
 
-    # --- Handler for Submit button click ---
     submit_button.click(
-        user_message,
-        inputs=[input_box, chatbot],
-        outputs=[input_box, chatbot, undone_state] # Clears input, updates history, clears undo
+        lambda msg: (msg, msg, ""),  # Store message and clear input
+        inputs=[input_box],
+        outputs=[msg_store, input_box, input_box],
+        queue=False
     ).then(
-        # 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
+        user_message,  # Add user message to chat
+        inputs=[msg_store, chatbot],
+        outputs=[input_box, chatbot],
+        queue=False
     ).then(
-        stream_gemini_response, # 3. Stream response using stored message and updated history
+        stream_gemini_response,  # Generate and stream response
         inputs=[msg_store, chatbot],
-        outputs=[chatbot]
-        # queue=True by default
+        outputs=chatbot
     )
 
-    # --- Handler for Clear button ---
     clear_button.click(
-        lambda: ([], "", [], ""), # Clear chatbot, input_box, msg_store, undone_state
-        outputs=[chatbot, input_box, msg_store, undone_state],
-        queue=False
-    )
-
-    # --- Handler for Undo button ---
-    undo_button.click(
-        undo_last,
-        inputs=[chatbot],
-        outputs=[chatbot, undone_state],
+        lambda: ([], "", ""),
+        outputs=[chatbot, input_box, msg_store],
         queue=False
     )
 
-    # --- Handler for Redo button ---
-    redo_button.click(
-        redo_last,
-        inputs=[chatbot, undone_state],
-        outputs=[chatbot, undone_state],
-        queue=False
-    )
-
-    # --- Handler for Regenerate button ---
-    regenerate_button.click(
-        regenerate_response, # 1. Prepare history, get last user msg, clear undo
-        inputs=[chatbot],
-        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. Stream new response using msg from store and prepared history
-        inputs=[msg_store, chatbot],
-        outputs=[chatbot]
-        # queue=True by default
-    )
-
-    gr.Markdown(
+    gr.Markdown(  # Description moved to the bottom - updated for text-only
         """
-        <br><br><br>
+        <br><br><br>  <!-- Add some vertical space -->
         ---
         ### About this Chatbot
-        **Try out the example prompts!**
+        **Try out the example prompts below to see Gemini in action!**
         **Key Features:**
-        *   Powered by Google's **""" + used_model + """** model.
-        *   Supports **conversation history**, **undo**, **redo**, and **regenerate**.
-        *   Uses **streaming** for responses.
+        *   Powered by Google's **Gemini 2.0 Flash** model.
+        *   Supports **conversation history** for multi-turn chats.
+        *   Uses **streaming** for a more interactive experience.
         **Instructions:**
-        1.  Type your message or select an example.
-        2.  Press Enter or click Submit.
-        3.  Use Undo/Redo to correct mistakes or explore alternatives.
-        4.  Use Regenerate to get a different response to your last message.
-        5.  Use Clear Chat to start over.
+        1.  Type your message in the input box below or select an example.
+        2.  Press Enter or click Submit to send.
+        3.  Observe the chatbot's "Thinking" process followed by the final response.
+        4.  Use the "Clear Chat" button to start a new conversation.
         """
     )
 
+
 # Launch the interface
 if __name__ == "__main__":
-    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
+    demo.launch(debug=True)