Update app.py

app.py

@@ -3,228 +3,195 @@ from openai import OpenAI
 from datetime import datetime
 import gradio as gr
 import time
-import openai # Already imported OpenAI above, this line is redundant
+import openai # Redundant import
 
 # --- Constants ---
-# Use a model available in the dropdown as the default
-DEFAULT_MODEL = "gpt-4o-mini-2024-07-18"
-DEFAULT_TEMPERATURE = 1.0
-DEFAULT_TOP_P = 1.0
-DEFAULT_FREQ_PENALTY = 0
-DEFAULT_PRES_PENALTY = 0
-MAX_TOKENS = 2048 # This is often controlled by the model, but can be a limit
-MAX_HISTORY_LENGTH = 5
+# Default model might need to align with what client.responses.create supports
+DEFAULT_MODEL = "gpt-4.1" # As per your example
+MAX_HISTORY_LENGTH = 5 # History formatting will be manual and limited
 
 # --- API Key and Client Initialization ---
-# Ensure the API key is set in your Hugging Face Space secrets
 API_KEY = os.getenv("OPENAI_API_KEY")
 if not API_KEY:
-    # Provide a clear error message if the key is missing
-    # In a real HF Space, you might raise an exception or disable the UI
     print("Error: OPENAI_API_KEY environment variable not set.")
-    # Consider adding a gr.Markdown warning in the UI as well if API_KEY is None
-    # For now, we'll let it proceed, but OpenAI() will likely raise an error later.
+    # Handle missing key appropriately (e.g., disable UI, raise error)
 client = OpenAI(api_key=API_KEY)
 
 # --- Helper Functions ---
-def get_openai_response(prompt, model=DEFAULT_MODEL, temperature=DEFAULT_TEMPERATURE, top_p=DEFAULT_TOP_P,
-                        frequency_penalty=DEFAULT_FREQ_PENALTY, presence_penalty=DEFAULT_PRES_PENALTY,
-                        max_tokens=MAX_TOKENS, system_prompt="", chat_history=None):
-    """Gets a response from the OpenAI API, handling errors and streaming."""
+
+# !!! WARNING: This function is adapted to the requested format and LOSES features !!!
+def get_openai_response_simplified(prompt, model=DEFAULT_MODEL, system_prompt="", chat_history=None):
+    """
+    Gets a response using the client.responses.create format.
+    NOTE: This is NON-STREAMING and handles history/system prompt crudely.
+    Advanced parameters (temp, top_p etc.) are NOT supported by this structure.
+    """
     today_day = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    messages = []
+
+    # --- Attempt to manually format history and system prompt into 'input' ---
+    formatted_input = ""
     # Add system prompt if provided
     effective_system_prompt = f"Today's date is: {today_day}. {system_prompt}".strip()
     if effective_system_prompt:
-         messages.append({"role": "system", "content": effective_system_prompt})
+         # How best to include system prompt? Prepend? Specific tags? Unknown.
+         formatted_input += f"System: {effective_system_prompt}\n\n"
 
-    # Add chat history
+    # Add chat history (simple concatenation)
     if chat_history:
         for turn in chat_history:
-            # Ensure turn has two elements before trying to access them
-            if len(turn) == 2 and turn[0] is not None and turn[1] is not None:
-                 messages.append({"role": "user", "content": str(turn[0])}) # Ensure content is string
-                 messages.append({"role": "assistant", "content": str(turn[1])}) # Ensure content is string
-            # else: # Optional: Handle malformed history entries
-            #     print(f"Skipping malformed history entry: {turn}")
+             if len(turn) == 2 and turn[0] is not None and turn[1] is not None:
+                 formatted_input += f"User: {turn[0]}\nAssistant: {turn[1]}\n"
 
     # Add the current user prompt
-    messages.append({"role": "user", "content": prompt})
+    formatted_input += f"User: {prompt}\nAssistant:" # Prompt the model for the next turn
 
     try:
-        # *** This is the correct, modern API call for chat models ***
-        response = client.chat.completions.create(
+        # *** Using the requested client.responses.create format ***
+        # NOTE: This assumes client.responses.create actually exists and works this way.
+        # NOTE: Parameters like temperature, top_p, max_tokens are NOT included here
+        #       as they are not part of the provided example format.
+        response = client.responses.create(
             model=model,
-            messages=messages,
-            temperature=temperature,
-            max_tokens=max_tokens, # Correct parameter name for this call
-            top_p=top_p,
-            frequency_penalty=frequency_penalty,
-            presence_penalty=presence_penalty,
-            # response_format={"type": "text"}, # Usually not needed unless forcing JSON etc. Let model decide default.
-            stream=True  # Enable streaming
+            input=formatted_input
         )
+        # Assuming the response object has an 'output_text' attribute
+        return response.output_text
 
-        collected_messages = []
-        full_reply_content = "" # Initialize before loop
-        for chunk in response:
-            # Check if delta and content exist before accessing
-            if chunk.choices and chunk.choices[0].delta and chunk.choices[0].delta.content is not None:
-                chunk_message = chunk.choices[0].delta.content
-                collected_messages.append(chunk_message)
-                full_reply_content = ''.join(collected_messages)
-                yield full_reply_content # Yield the accumulated message
-
-    # Use specific exceptions from the openai library
+    # Error handling might need adjustment based on how client.responses.create fails
     except openai.APIConnectionError as e:
         print(f"OpenAI API request failed: {e}")
-        yield f"Error: Could not connect to OpenAI API. {e}"
+        return f"Error: Could not connect to OpenAI API. {e}"
     except openai.RateLimitError as e:
         print(f"OpenAI API request failed: {e}")
-        yield f"Error: Rate limit exceeded. Please try again later. {e}"
+        return f"Error: Rate limit exceeded. Please try again later. {e}"
     except openai.AuthenticationError as e:
         print(f"OpenAI API request failed: {e}")
-        yield f"Error: Authentication failed. Check your API key. {e}"
+        return f"Error: Authentication failed. Check your API key. {e}"
     except openai.APIStatusError as e:
         print(f"OpenAI API request failed: {e}")
-        yield f"Error: OpenAI API returned an error (Status: {e.status_code}). {e}"
+        return f"Error: OpenAI API returned an error (Status: {e.status_code}). {e}"
+    except AttributeError as e:
+        print(f"Error accessing response or client method: {e}")
+        return f"Error: The API call structure 'client.responses.create' or its response format might be incorrect or not available. {e}"
     except Exception as e:
         print(f"An unexpected error occurred: {e}")
-        yield f"An unexpected error occurred: {e}"
-
-
-def update_ui(message, chat_history, model, temperature, top_p, frequency_penalty, presence_penalty, system_prompt, history_length):
-    """Updates the Gradio UI; handles streaming response."""
-    if not message: # Don't send empty messages
-        yield "", chat_history
-        return
-
-    # Trim history before sending to API if it's longer than needed for context
-    # (Optional optimization, the API call does include full history passed here)
-    # history_for_api = chat_history[-(MAX_HISTORY_LENGTH*2):] # Keep pairs
-
-    bot_message_gen = get_openai_response(
-        prompt=message, model=model, temperature=temperature, top_p=top_p,
-        frequency_penalty=frequency_penalty, presence_penalty=presence_penalty,
-        system_prompt=system_prompt, chat_history=chat_history # Pass full history for context
+        return f"An unexpected error occurred: {e}"
+
+# !!! WARNING: This update function is now NON-STREAMING !!!
+def update_ui_simplified(message, chat_history, model, system_prompt, history_length):
+    """Updates the Gradio UI WITHOUT streaming."""
+    if not message:
+        return "", chat_history # Return original history if message is empty
+
+    # Keep only the specified length of history for the *next* call
+    history_for_api = chat_history[-int(history_length):] if history_length > 0 else []
+
+    # Call the simplified, non-streaming function
+    bot_response = get_openai_response_simplified(
+        prompt=message,
+        model=model,
+        system_prompt=system_prompt,
+        chat_history=history_for_api # Pass the potentially trimmed history
     )
 
-    chat_history.append((message, "")) # Add user message and placeholder for bot response
+    # Append the user message and the *complete* bot response
+    chat_history.append((message, bot_response))
 
-    # Stream the response
-    for bot_message_chunk in bot_message_gen:
-        chat_history[-1] = (message, bot_message_chunk) # Update the last entry with the streamed chunk
-        # Control visibility based on the slider
-        visible_history = chat_history[-int(history_length):] if history_length > 0 else []
-        # time.sleep(0.02) # Slightly shorter delay might feel more responsive
-        yield "", visible_history
+    # Update UI only once with the full response
+    # Always display history based on the slider length for visibility
+    visible_history = chat_history[-int(history_length):] if history_length > 0 else []
+    return "", visible_history # Clear input, return updated history
 
-# --- Gradio Interface ---
+# --- Gradio Interface (Modified for Simplified API Call) ---
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    # Keep your informative Markdown sections
-    gr.Markdown("# Chat with OpenAI Models") # Updated Title
-    gr.Markdown("❗ GPT-4.5 experiment details from Feb 27, 2025...") # Keep context
-    gr.Markdown("☕ [Buy me a Coffee](https://buymeacoffee.com/diegocp01m)")
+    # Keep your Markdown, titles, etc.
+    gr.Markdown("# Chat (Simplified API Demo)")
+    gr.Markdown("---")
+    gr.Markdown("Using a simplified, non-streaming API call structure.")
     gr.Markdown("---")
-    gr.Markdown("""
-    🚀 **GPT-4.5 EXPERIMENT RECAP:** GPT-4.5 was briefly accessible via API on Feb 27, 2025.
-    This space allowed free access during that window.
 
-    📊 **Chat Completions Metrics (Feb 27, 2025):**
-    - 111 requests
-    - 64,764 Total tokens processed
-    - Total spend: $10.99
+    # ... (rest of your Markdown) ...
 
-    This space went live at 4:23 PM ET, Feb 27, 2025 until 8:53 PM ET. [Read More](https://x.com/diegocabezas01/status/1895291365376041045)
-    Results from OpenAI platform: 👇
-    """)
-    gr.Image("https://pbs.twimg.com/media/Gk1tVnRXkAASa2U?format=jpg&name=4096x4096", elem_id="gpt4_5_image")
-    gr.Markdown("Chat with available models like GPT-4o mini below: 👇")
+    gr.Markdown("Chat below (Note: Responses will appear all at once): 👇")
 
     with gr.Row():
         with gr.Column(scale=4):
             chatbot = gr.Chatbot(
-                label="Chat Window", # Added label for clarity
+                label="Chat Window",
                 show_label=False,
                 avatar_images=(
-                    # Using generic user icon
                     "https://cdn-icons-png.flaticon.com/512/1077/1077114.png", # User
-                    # Using generic AI icon
                     "https://cdn-icons-png.flaticon.com/512/8649/8649540.png" # AI
                 ),
                 render_markdown=True,
                 height=500,
-                bubble_full_width=False # Optional: makes bubbles look nicer
+                bubble_full_width=False
             )
             msg = gr.Textbox(
-                label="Your Message", # Added label
+                label="Your Message",
                 placeholder="Type your message here and press Enter...",
                 scale=4,
                 show_label=False,
-                container=False # Makes it sit closer to the button
+                container=False
             )
 
-            with gr.Accordion("Advanced Options", open=False):
+            # Accordion remains, but parameters might not be used by the simplified API call
+            with gr.Accordion("Advanced Options (May Not Apply to Simplified API)", open=False):
                 model_select = gr.Dropdown(
                     label="Model",
-                    # Ensure these models are available to your API key
-                    choices=["gpt-4o-mini-2024-07-18", "gpt-3.5-turbo-0125", "gpt-4o"],
-                    value=DEFAULT_MODEL, # Use the constant defined above
+                    # Ensure gpt-4.1 is a valid choice if used
+                    choices=["gpt-4.1", "gpt-4o-mini-2024-07-18", "gpt-3.5-turbo-0125", "gpt-4o"],
+                    value=DEFAULT_MODEL,
                     interactive=True
                 )
-                temperature_slider = gr.Slider(label="Temperature (Randomness)", minimum=0.0, maximum=2.0, value=DEFAULT_TEMPERATURE, step=0.1, interactive=True)
-                top_p_slider = gr.Slider(label="Top P (Nucleus Sampling)", minimum=0.0, maximum=1.0, value=DEFAULT_TOP_P, step=0.05, interactive=True)
-                frequency_penalty_slider = gr.Slider(label="Frequency Penalty (Discourage repetition)", minimum=-2.0, maximum=2.0, value=DEFAULT_FREQ_PENALTY, step=0.1, interactive=True)
-                presence_penalty_slider = gr.Slider(label="Presence Penalty (Discourage repeating topics)", minimum=-2.0, maximum=2.0, value=DEFAULT_PRES_PENALTY, step=0.1, interactive=True)
+                # These sliders are kept for UI, but won't be passed to the simplified API call
+                temperature_slider = gr.Slider(label="Temperature (Not Used)", minimum=0.0, maximum=2.0, value=1.0, step=0.1, interactive=True)
+                top_p_slider = gr.Slider(label="Top P (Not Used)", minimum=0.0, maximum=1.0, value=1.0, step=0.05, interactive=True)
+                frequency_penalty_slider = gr.Slider(label="Frequency Penalty (Not Used)", minimum=-2.0, maximum=2.0, value=0.0, step=0.1, interactive=True)
+                presence_penalty_slider = gr.Slider(label="Presence Penalty (Not Used)", minimum=-2.0, maximum=2.0, value=0.0, step=0.1, interactive=True)
                 system_prompt_textbox = gr.Textbox(label="System Prompt", placeholder="e.g., You are a helpful assistant.", lines=3, interactive=True)
-                history_length_slider = gr.Slider(label="Chat History Display Length", minimum=1, maximum=20, value=MAX_HISTORY_LENGTH, step=1, interactive=True)
+                history_length_slider = gr.Slider(label="Chat History Length (Affects Input & Display)", minimum=1, maximum=20, value=MAX_HISTORY_LENGTH, step=1, interactive=True)
+
 
             with gr.Row():
-                 # Place clear button first maybe?
                  clear = gr.Button("Clear Chat")
-                 send = gr.Button("Send Message", variant="primary") # Make send more prominent
+                 send = gr.Button("Send Message", variant="primary")
 
 
-    # --- Event Handlers ---
-    # Define reusable inputs list
-    inputs = [
-        msg, chatbot, model_select, temperature_slider, top_p_slider,
-        frequency_penalty_slider, presence_penalty_slider, system_prompt_textbox,
+    # --- Event Handlers (Using Simplified Functions) ---
+    # Define inputs, excluding sliders not used by the simplified function
+    inputs_simplified = [
+        msg, chatbot, model_select, system_prompt_textbox,
         history_length_slider
     ]
-    # Define reusable outputs list
-    outputs = [msg, chatbot]
+    outputs = [msg, chatbot] # Outputs remain the same
 
     # Connect send button click
     send.click(
-        update_ui,
-        inputs=inputs,
+        update_ui_simplified, # Use the non-streaming UI update function
+        inputs=inputs_simplified,
         outputs=outputs,
-        queue=True # Use queue for handling multiple users potentially
+        queue=True
     )
 
     # Connect textbox submit (Enter key)
     msg.submit(
-        update_ui,
-        inputs=inputs,
+        update_ui_simplified, # Use the non-streaming UI update function
+        inputs=inputs_simplified,
         outputs=outputs,
         queue=True
     )
 
     # Connect clear button
-    # Clears the message box and the chatbot history
     clear.click(lambda: (None, []), None, outputs=[msg, chatbot], queue=False)
 
     gr.Examples(
         examples=["Tell me about the latest AI developments", "Write a short story about a friendly robot", "Explain black holes simply"],
         inputs=msg,
-        label="Example Prompts" # Add label
+        label="Example Prompts"
     )
-    # msg.focus() # Autoselect msg box - Sometimes causes issues, use if needed
 
 # --- Launch ---
 if __name__ == "__main__":
-    # Add share=True for a public link if running locally and want to share
-    # Add debug=True for more verbose logging during development
-    demo.queue() # Enable queue for better handling of multiple requests
+    demo.queue()
     demo.launch()