Update app.py

app.py

@@ -1,44 +1,39 @@
 import gradio as gr
 from huggingface_hub import InferenceClient
 import os
-import json # Added for debug printing payloads
+import json
 import base64
 from PIL import Image
 import io
 
 ACCESS_TOKEN = os.getenv("HF_TOKEN")
-print(f"Access token from HF_TOKEN env var loaded. Is it None? {ACCESS_TOKEN is None}. Length if not None: {len(ACCESS_TOKEN) if ACCESS_TOKEN else 'N/A'}")
+print("Access token loaded.")
 
 # Function to encode image to base64
-def encode_image(image_path_or_pil):
-    if not image_path_or_pil:
-        print("No image path or PIL Image provided to encode_image")
+def encode_image(image_path):
+    if not image_path:
+        print("No image path provided")
         return None
     
     try:
-        # print(f"Encoding image. Input type: {type(image_path_or_pil)}") # Debug
+        print(f"Encoding image from path: {image_path}")
         
-        if isinstance(image_path_or_pil, Image.Image):
-            image = image_path_or_pil
-            # print("Input is already a PIL Image.")
-        elif isinstance(image_path_or_pil, str):
-            # print(f"Input is a path string: {image_path_or_pil}")
-            if not os.path.exists(image_path_or_pil):
-                print(f"Error: Image path does not exist: {image_path_or_pil}")
-                return None
-            image = Image.open(image_path_or_pil)
+        # If it's already a PIL Image
+        if isinstance(image_path, Image.Image):
+            image = image_path
         else:
-            print(f"Error: Unsupported type for encode_image: {type(image_path_or_pil)}")
-            return None
+            # Try to open the image file
+            image = Image.open(image_path)
         
+        # Convert to RGB if image has an alpha channel (RGBA)
         if image.mode == 'RGBA':
-            # print("Converting RGBA image to RGB.")
             image = image.convert('RGB')
         
+        # Encode to base64
         buffered = io.BytesIO()
         image.save(buffered, format="JPEG")
         img_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
-        # print("Image encoded successfully to base64.")
+        print("Image encoded successfully")
         return img_str
     except Exception as e:
         print(f"Error encoding image: {e}")
@@ -46,7 +41,7 @@ def encode_image(image_path_or_pil):
 
 def respond(
     message,
-    image_files,
+    image_files,  # Changed parameter name and structure
     history: list[tuple[str, str]],
     system_message,
     max_tokens,
@@ -55,144 +50,139 @@ def respond(
     frequency_penalty,
     seed,
     provider,
-    custom_api_key, # This is the value from byok_textbox
+    custom_api_key,
     custom_model,    
     model_search_term,
     selected_model
 ):
-    print(f"--- New Respond Call ---")
-    print(f"Received message: '{message}'")
-    print(f"Received {len(image_files) if image_files else 0} image files.")
-    # print(f"History length: {len(history)}") # History can be verbose
-    print(f"System message: '{system_message}'")
-    print(f"Generation Params: MaxTokens={max_tokens}, Temp={temperature}, TopP={top_p}, FreqPenalty={frequency_penalty}, Seed={seed}")
-    print(f"Selected provider: '{provider}'")
+    print(f"Received message: {message}")
+    print(f"Received {len(image_files) if image_files else 0} images")
+    print(f"History: {history}")
+    print(f"System message: {system_message}")
+    print(f"Max tokens: {max_tokens}, Temperature: {temperature}, Top-P: {top_p}")
+    print(f"Frequency Penalty: {frequency_penalty}, Seed: {seed}")
+    print(f"Selected provider: {provider}")         
+    print(f"Custom API Key provided: {bool(custom_api_key.strip())}")
+    print(f"Selected model (custom_model): {custom_model}")  
+    print(f"Model search term: {model_search_term}")
+    print(f"Selected model from radio: {selected_model}")
+
+    # Determine which token to use
+    token_to_use = custom_api_key if custom_api_key.strip() != "" else ACCESS_TOKEN
     
-    # Explicitly show the raw custom_api_key received
-    raw_key_type = type(custom_api_key)
-    raw_key_len = len(custom_api_key) if isinstance(custom_api_key, str) else 'N/A (not a string)'
-    print(f"Raw custom_api_key from UI: type={raw_key_type}, length={raw_key_len}")
-    if isinstance(custom_api_key, str) and len(custom_api_key) > 0:
-         print(f"Raw custom_api_key (masked): '{custom_api_key[:4]}...{custom_api_key[-4:]}'" if len(custom_api_key) > 8 else custom_api_key)
-
-
-    token_to_use = None
-    effective_custom_key = ""
-
-    if custom_api_key and isinstance(custom_api_key, str): # Ensure it's a string and not None
-        effective_custom_key = custom_api_key.strip()
-
-    if effective_custom_key: # True if string is not empty after stripping
-        token_to_use = effective_custom_key
-        print(f"TOKEN SELECTION: USING CUSTOM API KEY (BYOK). Length: {len(token_to_use)}")
-        if ACCESS_TOKEN and token_to_use == ACCESS_TOKEN:
-            print("INFO: Custom key is identical to the environment HF_TOKEN.")
+    if custom_api_key.strip() != "":
+        print("USING CUSTOM API KEY: BYOK token provided by user is being used for authentication")
     else:
-        token_to_use = ACCESS_TOKEN # This will be None if HF_TOKEN is not set or empty
-        if token_to_use:
-            print(f"TOKEN SELECTION: USING DEFAULT API KEY (HF_TOKEN from env). Length: {len(token_to_use)}")
-        else:
-            print("TOKEN SELECTION: DEFAULT API KEY (HF_TOKEN from env) IS NOT SET or EMPTY. Custom key was also empty.")
-
-    if not token_to_use:
-        print("CRITICAL WARNING: No API token determined (neither custom nor default was usable/provided). Inference will likely fail or use public access if supported by model/provider.")
-        # InferenceClient will handle token=None by trying its own env var lookup or failing.
-    else:
-        # For debugging, print a masked version of the token being finally used
-        if isinstance(token_to_use, str) and len(token_to_use) > 8:
-            print(f"FINAL TOKEN for InferenceClient: '{token_to_use[:4]}...{token_to_use[-4:]}' (masked)")
-        elif isinstance(token_to_use, str):
-            print(f"FINAL TOKEN for InferenceClient: '{token_to_use}' (short token)")
-        else: # Should not happen if logic above is correct and token_to_use is string or None
-            print(f"FINAL TOKEN for InferenceClient: {token_to_use} (not a string or None, unusual!)")
+        print("USING DEFAULT API KEY: Environment variable HF_TOKEN is being used for authentication")
     
     # Initialize the Inference Client with the provider and appropriate token
     client = InferenceClient(token=token_to_use, provider=provider)
-    print(f"Hugging Face Inference Client initialized with provider: '{provider}'.")
+    print(f"Hugging Face Inference Client initialized with {provider} provider.")
 
-    if seed == -1: # Convert seed to None if -1 (meaning random)
+    # Convert seed to None if -1 (meaning random)
+    if seed == -1:
         seed = None
 
-    # Prepare user_content (current message with text and/or images)
-    user_content_parts = []
-    if message and message.strip():
-        user_content_parts.append({"type": "text", "text": message})
-    
+    # Create multimodal content if images are present
     if image_files and len(image_files) > 0:
-        for img_file_path in image_files:
-            if img_file_path: # img_file_path is a string path from Gradio MultimodalTextbox
-                encoded_image = encode_image(img_file_path)
-                if encoded_image:
-                    user_content_parts.append({
-                        "type": "image_url",
-                        "image_url": {"url": f"data:image/jpeg;base64,{encoded_image}"}
-                    })
-                else:
-                    print(f"Warning: Failed to encode image for current message: {img_file_path}")
-    
-    # Determine final user_content structure
-    if not user_content_parts: # No text and no images
-        print("Warning: Current user message is empty (no text, no images).")
-        # Depending on API, might need to send empty string or handle this case.
-        # For now, let it proceed; API might error or interpret as empty prompt.
-        final_user_content = "" 
-    elif len(user_content_parts) == 1 and user_content_parts[0]["type"] == "text":
-        final_user_content = user_content_parts[0]["text"] # Text-only, pass as string
+        # Process the user message to include images
+        user_content = []
+        
+        # Add text part if there is any
+        if message and message.strip():
+            user_content.append({
+                "type": "text",
+                "text": message
+            })
+        
+        # Add image parts
+        for img in image_files:
+            if img is not None:
+                # Get raw image data from path
+                try:
+                    encoded_image = encode_image(img)
+                    if encoded_image:
+                        user_content.append({
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/jpeg;base64,{encoded_image}"
+                            }
+                        })
+                except Exception as e:
+                    print(f"Error encoding image: {e}")
     else:
-        final_user_content = user_content_parts # Multimodal, pass as list of dicts
+        # Text-only message
+        user_content = message
 
-    # Prepare messages list for the API
+    # Prepare messages in the format expected by the API
     messages = [{"role": "system", "content": system_message}]
-
-    for hist_user_content, hist_assistant_content in history:
-        # hist_user_content can be string (text) or tuple (text, [image_paths])
-        if hist_user_content:
-            if isinstance(hist_user_content, tuple) and len(hist_user_content) == 2:
-                # Multimodal history entry: (text, [list_of_image_paths])
-                hist_text, hist_image_paths = hist_user_content
-                current_hist_user_parts = []
-                if hist_text and hist_text.strip():
-                    current_hist_user_parts.append({"type": "text", "text": hist_text})
-                if hist_image_paths:
-                    for hist_img_path in hist_image_paths:
-                        encoded_hist_img = encode_image(hist_img_path)
-                        if encoded_hist_img:
-                            current_hist_user_parts.append({
-                                "type": "image_url",
-                                "image_url": {"url": f"data:image/jpeg;base64,{encoded_hist_img}"}
-                            })
-                        else:
-                             print(f"Warning: Failed to encode history image: {hist_img_path}")
-                if current_hist_user_parts: # Only add if there's content
-                     messages.append({"role": "user", "content": current_hist_user_parts})
-
-            elif isinstance(hist_user_content, str): # Text-only history entry
-                messages.append({"role": "user", "content": hist_user_content})
+    print("Initial messages array constructed.")
+
+    # Add conversation history to the context
+    for val in history:
+        user_part = val[0]
+        assistant_part = val[1]
+        if user_part:
+            # Handle both text-only and multimodal messages in history
+            if isinstance(user_part, tuple) and len(user_part) == 2:
+                # This is a multimodal message with text and images
+                history_content = []
+                if user_part[0]:  # Text
+                    history_content.append({
+                        "type": "text",
+                        "text": user_part[0]
+                    })
+                
+                for img in user_part[1]:  # Images
+                    if img:
+                        try:
+                            encoded_img = encode_image(img)
+                            if encoded_img:
+                                history_content.append({
+                                    "type": "image_url",
+                                    "image_url": {
+                                        "url": f"data:image/jpeg;base64,{encoded_img}"
+                                    }
+                                })
+                        except Exception as e:
+                            print(f"Error encoding history image: {e}")
+                
+                messages.append({"role": "user", "content": history_content})
             else:
-                print(f"Warning: Unexpected type for history user content: {type(hist_user_content)}")
-
-        if hist_assistant_content:
-            messages.append({"role": "assistant", "content": hist_assistant_content})
+                # Regular text message
+                messages.append({"role": "user", "content": user_part})
+            print(f"Added user message to context (type: {type(user_part)})")
+        
+        if assistant_part:
+            messages.append({"role": "assistant", "content": assistant_part})
+            print(f"Added assistant message to context: {assistant_part}")
 
-    messages.append({"role": "user", "content": final_user_content})
-    # print(f"Final messages object for API: {json.dumps(messages, indent=2)}") # Very verbose, use for deep debugging
+    # Append the latest user message
+    messages.append({"role": "user", "content": user_content})
+    print(f"Latest user message appended (content type: {type(user_content)})")
 
+    # Determine which model to use, prioritizing custom_model if provided
     model_to_use = custom_model.strip() if custom_model.strip() != "" else selected_model
-    print(f"Model selected for inference: '{model_to_use}'")
+    print(f"Model selected for inference: {model_to_use}")
 
-    response_text = ""
-    print(f"Sending request to provider '{provider}' for model '{model_to_use}'. Streaming enabled.")
+    # Start with an empty string to build the response as tokens stream in
+    response = ""
+    print(f"Sending request to {provider} provider.")
 
+    # Prepare parameters for the chat completion request
     parameters = {
         "max_tokens": max_tokens,
         "temperature": temperature,
         "top_p": top_p,
         "frequency_penalty": frequency_penalty,
     }
+    
     if seed is not None:
         parameters["seed"] = seed
 
+    # Use the InferenceClient for making the request
     try:
+        # Create a generator for the streaming response
         stream = client.chat_completion(
             model=model_to_use,
             messages=messages,
@@ -200,316 +190,378 @@ def respond(
             **parameters
         )
         
-        # print("Streaming response tokens: ", end="", flush=True) # Can be noisy
+        print("Received tokens: ", end="", flush=True)
+        
+        # Process the streaming response
         for chunk in stream:
             if hasattr(chunk, 'choices') and len(chunk.choices) > 0:
-                delta = chunk.choices[0].delta
-                if delta and hasattr(delta, 'content') and delta.content:
-                    token_text = delta.content
-                    # print(token_text, end="", flush=True) # Handled by yield
-                    response_text += token_text
-                    yield response_text
-        # print("\nStream ended.")
+                # Extract the content from the response
+                if hasattr(chunk.choices[0], 'delta') and hasattr(chunk.choices[0].delta, 'content'):
+                    token_text = chunk.choices[0].delta.content
+                    if token_text:
+                        print(token_text, end="", flush=True)
+                        response += token_text
+                        yield response
+        
+        print()
     except Exception as e:
-        error_message = f"{type(e).__name__}: {str(e)}"
-        print(f"ERROR DURING INFERENCE: {error_message}")
-        # If it's a client error (4xx), the request body might be relevant
-        if hasattr(e, 'response') and e.response is not None:
-            print(f"Error details: Status {e.response.status_code}. Response text: {e.response.text}")
-            if 400 <= e.response.status_code < 500:
-                 try:
-                    print(f"Offending request messages payload (first 1000 chars): {json.dumps(messages, indent=2)[:1000]}")
-                 except Exception as E:
-                    print(f"Could not dump messages payload: {E}")
-
-        response_text += f"\nAn error occurred: {error_message}"
-        yield response_text
-
-    print("Completed response generation for current call.")
+        print(f"Error during inference: {e}")
+        response += f"\nError: {str(e)}"
+        yield response
 
+    print("Completed response generation.")
 
 # Function to validate provider selection based on BYOK
-def validate_provider(api_key, provider_choice): # Renamed provider to provider_choice
-    # This function's purpose was to force hf-inference if no BYOK for other providers.
-    # However, InferenceClient handles provider-specific keys or HF token routing.
-    # For now, let's assume any key might work with any provider and let InferenceClient handle it.
-    # If a custom key is entered, it *could* be for any provider.
-    # If no custom key, and ACCESS_TOKEN is used, it's an HF_TOKEN, best for hf-inference or HF-managed providers.
-    # The current logic doesn't strictly need this validation if we trust InferenceClient.
-    # Keeping it simple:
-    # if not api_key.strip() and provider_choice != "hf-inference":
-    #     print(f"No BYOK, but provider '{provider_choice}' selected. Forcing 'hf-inference'.")
-    #     return gr.update(value="hf-inference")
-    return gr.update(value=provider_choice) # No change for now, allow user selection.
+def validate_provider(api_key, provider):
+    if not api_key.strip() and provider != "hf-inference":
+        return gr.update(value="hf-inference")
+    return gr.update(value=provider)
 
 # GRADIO UI
 with gr.Blocks(theme="Nymbo/Nymbo_Theme") as demo:
+    # Create the chatbot component
     chatbot = gr.Chatbot(
         height=600, 
         show_copy_button=True, 
-        placeholder="Select a model, enter your message, and upload images if needed.",
-        layout="panel",
-        avatar_images=(None, "https://huggingface.co/chat/huggingchat/logo.svg") # Example bot avatar
+        placeholder="Select a model and begin chatting. Now supports multiple inference providers and multimodal inputs",
+        layout="panel"
     )
+    print("Chatbot interface created.")
     
+    # Multimodal textbox for messages (combines text and file uploads)
     msg = gr.MultimodalTextbox(
         placeholder="Type a message or upload images...",
         show_label=False,
         container=False,
-        scale=12, # Ensure this is within a gr.Row() or similar if scale is used effectively
+        scale=12,
         file_types=["image"],
-        file_count="multiple", # Allows multiple image uploads
-        sources=["upload"] # Can add "clipboard"
+        file_count="multiple",
+        sources=["upload"]
     )
     
+    # Note: We're removing the separate submit button since MultimodalTextbox has its own
+
+    # Create accordion for settings
     with gr.Accordion("Settings", open=False):
+        # System message
         system_message_box = gr.Textbox(
             value="You are a helpful AI assistant that can understand images and text.", 
             placeholder="You are a helpful assistant.",
             label="System Prompt"
         )
         
+        # Generation parameters
         with gr.Row():
             with gr.Column():
-                max_tokens_slider = gr.Slider(1, 4096, value=512, step=1, label="Max new tokens")
-                temperature_slider = gr.Slider(0.1, 2.0, value=0.7, step=0.05, label="Temperature") # Range adjusted
-                top_p_slider = gr.Slider(0.1, 1.0, value=0.95, step=0.05, label="Top-P")
+                max_tokens_slider = gr.Slider(
+                    minimum=1,
+                    maximum=4096,
+                    value=512,
+                    step=1,
+                    label="Max tokens"
+                )
+                
+                temperature_slider = gr.Slider(
+                    minimum=0.1,
+                    maximum=4.0,
+                    value=0.7,
+                    step=0.1,
+                    label="Temperature"
+                )
+                
+                top_p_slider = gr.Slider(
+                    minimum=0.1,
+                    maximum=1.0,
+                    value=0.95,
+                    step=0.05,
+                    label="Top-P"
+                )
+                
             with gr.Column():
-                frequency_penalty_slider = gr.Slider(-2.0, 2.0, value=0.0, step=0.1, label="Frequency Penalty")
-                seed_slider = gr.Slider(-1, 65535, value=-1, step=1, label="Seed (-1 for random)")
+                frequency_penalty_slider = gr.Slider(
+                    minimum=-2.0,
+                    maximum=2.0,
+                    value=0.0,
+                    step=0.1,
+                    label="Frequency Penalty"
+                )
+                
+                seed_slider = gr.Slider(
+                    minimum=-1,
+                    maximum=65535,
+                    value=-1,
+                    step=1,
+                    label="Seed (-1 for random)"
+                )
+        
+        # Provider selection
+        providers_list = [
+            "hf-inference",  # Default Hugging Face Inference
+            "cerebras",      # Cerebras provider
+            "together",      # Together AI
+            "sambanova",     # SambaNova
+            "novita",        # Novita AI
+            "cohere",        # Cohere
+            "fireworks-ai",  # Fireworks AI
+            "hyperbolic",    # Hyperbolic
+            "nebius",        # Nebius
+        ]
         
-        providers_list = ["hf-inference", "cerebras", "together", "sambanova", "novita", "cohere", "fireworks-ai", "hyperbolic", "nebius"]
-        provider_radio = gr.Radio(choices=providers_list, value="hf-inference", label="Inference Provider")
+        provider_radio = gr.Radio(
+            choices=providers_list,
+            value="hf-inference",
+            label="Inference Provider",
+        )
         
+        # New BYOK textbox
         byok_textbox = gr.Textbox(
-            value="", label="BYOK (Bring Your Own Key)", 
-            info="Enter your API key. For 'hf-inference', use an HF token. For other providers, use their specific key or an HF token if supported.",
-            placeholder="Enter your API token here", type="password"
+            value="",
+            label="BYOK (Bring Your Own Key)",
+            info="Enter a custom Hugging Face API key here. When empty, only 'hf-inference' provider can be used.",
+            placeholder="Enter your Hugging Face API token",
+            type="password"  # Hide the API key for security
         )
         
+        # Custom model box
         custom_model_box = gr.Textbox(
-            value="", label="Custom Model ID / Endpoint", 
-            info="(Optional) Provide a custom model ID (e.g., 'meta-llama/Llama-3-70b-chat-hf') or full endpoint URL. Overrides featured model selection.",
-            placeholder="org/model-name or full URL"
+            value="",
+            label="Custom Model",
+            info="(Optional) Provide a custom Hugging Face model path. Overrides any selected featured model.",
+            placeholder="meta-llama/Llama-3.3-70B-Instruct"
         )
         
-        model_search_box = gr.Textbox(label="Filter Featured Models", placeholder="Search...", lines=1)
+        # Model search
+        model_search_box = gr.Textbox(
+            label="Filter Models",
+            placeholder="Search for a featured model...",
+            lines=1
+        )
         
+        # Featured models list
+        # Updated to include multimodal models
         models_list = [
-            "meta-llama/Llama-3.2-11B-Vision-Instruct", "meta-llama/Llama-3.3-70B-Instruct",
-            "meta-llama/Llama-3.1-70B-Instruct", "meta-llama/Llama-3.0-70B-Instruct",
-            "meta-llama/Llama-3.2-3B-Instruct", "meta-llama/Llama-3.2-1B-Instruct",
-            "meta-llama/Llama-3.1-8B-Instruct", "NousResearch/Hermes-3-Llama-3.1-8B",
-            "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO", "mistralai/Mistral-Nemo-Instruct-2407",
-            "mistralai/Mixtral-8x7B-Instruct-v0.1", "mistralai/Mistral-7B-Instruct-v0.3",
-            "mistralai/Mistral-7B-Instruct-v0.2", "Qwen/Qwen3-235B-A22B", "Qwen/Qwen3-32B",
-            "Qwen/Qwen2.5-72B-Instruct", "Qwen/Qwen2.5-3B-Instruct", "Qwen/Qwen2.5-0.5B-Instruct",
-            "Qwen/QwQ-32B", "Qwen/Qwen2.5-Coder-32B-Instruct", "microsoft/Phi-3.5-mini-instruct",
-            "microsoft/Phi-3-mini-128k-instruct", "microsoft/Phi-3-mini-4k-instruct",
+            "meta-llama/Llama-3.2-11B-Vision-Instruct",
+            "meta-llama/Llama-3.3-70B-Instruct",
+            "meta-llama/Llama-3.1-70B-Instruct",
+            "meta-llama/Llama-3.0-70B-Instruct",
+            "meta-llama/Llama-3.2-3B-Instruct",
+            "meta-llama/Llama-3.2-1B-Instruct",
+            "meta-llama/Llama-3.1-8B-Instruct",
+            "NousResearch/Hermes-3-Llama-3.1-8B",
+            "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO",
+            "mistralai/Mistral-Nemo-Instruct-2407",
+            "mistralai/Mixtral-8x7B-Instruct-v0.1",
+            "mistralai/Mistral-7B-Instruct-v0.3",
+            "mistralai/Mistral-7B-Instruct-v0.2",
+            "Qwen/Qwen3-235B-A22B",
+            "Qwen/Qwen3-32B",
+            "Qwen/Qwen2.5-72B-Instruct",
+            "Qwen/Qwen2.5-3B-Instruct",
+            "Qwen/Qwen2.5-0.5B-Instruct",
+            "Qwen/QwQ-32B",
+            "Qwen/Qwen2.5-Coder-32B-Instruct",
+            "microsoft/Phi-3.5-mini-instruct",
+            "microsoft/Phi-3-mini-128k-instruct",
+            "microsoft/Phi-3-mini-4k-instruct",
         ]
+
         featured_model_radio = gr.Radio(
-            label="Select a Featured Model", choices=models_list, 
-            value="meta-llama/Llama-3.2-11B-Vision-Instruct", interactive=True
+            label="Select a model below",
+            choices=models_list,
+            value="meta-llama/Llama-3.2-11B-Vision-Instruct",  # Default to a multimodal model
+            interactive=True
         )
-        gr.Markdown("[All Text-to-Text Models](https://huggingface.co/models?inference_provider=all&pipeline_tag=text-generation&sort=trending) | [All Multimodal Models](https://huggingface.co/models?inference_provider=all&pipeline_tag=image-text-to-text&sort=trending)")
-
-    # Chat history state (remains gr.State for proper handling by Gradio)
-    # The `chatbot` component itself manages its display state.
-    # We need a separate state if we want to manipulate the history structure before passing to API.
-    # The current `bot` function takes `chatbot` (which is history) directly.
-
-    # Revised user function for MultimodalTextbox
-    # It appends the user's input (text and/or files) to the chatbot history.
-    # The `bot` function will then process this history.
-    def handle_user_input(multimodal_input, chat_history_list):
-        text_input = multimodal_input.get("text", "").strip()
-        file_inputs = multimodal_input.get("files", []) # List of file paths
-
-        # print(f"User input: Text='{text_input}', Files={file_inputs}")
-
-        if not text_input and not file_inputs:
-            # print("User input empty, not adding to history.")
-            return chat_history_list # No change if input is empty
+        
+        gr.Markdown("[View all Text-to-Text models](https://huggingface.co/models?inference_provider=all&pipeline_tag=text-generation&sort=trending) | [View all multimodal models](https://huggingface.co/models?inference_provider=all&pipeline_tag=image-text-to-text&sort=trending)")
 
-        # For multimodal display in chatbot, we can represent images using Markdown.
-        # The actual file paths will be used by `respond` for API calls.
-        # We need to decide how to store this in history for `respond`
-        # Option 1: Store (text, [paths]) tuple for user turns.
-        # Option 2: Create separate entries for text and images.
+    # Chat history state
+    chat_history = gr.State([])
+    
+    # Function to filter models
+    def filter_models(search_term):
+        print(f"Filtering models with search term: {search_term}")
+        filtered = [m for m in models_list if search_term.lower() in m.lower()]
+        print(f"Filtered models: {filtered}")
+        return gr.update(choices=filtered)
+
+    # Function to set custom model from radio
+    def set_custom_model_from_radio(selected):
+        print(f"Featured model selected: {selected}")
+        return selected
+
+    # Function for the chat interface
+    def user(user_message, history):
+        # Debug logging for troubleshooting
+        print(f"User message received: {user_message}")
         
-        # Let's use Option 1 for structured history, easier for `respond`
-        # The `chatbot` component can display a text representation.
+        # Skip if message is empty (no text and no files)
+        if not user_message or (not user_message.get("text") and not user_message.get("files")):
+            print("Empty message, skipping")
+            return history
         
-        display_entry_user = ""
-        if text_input:
-            display_entry_user += text_input
+        # Prepare multimodal message format
+        text_content = user_message.get("text", "").strip()
+        files = user_message.get("files", [])
         
-        # For display in chatbot, we can use Markdown for images.
-        # For passing to `respond` via history, we need the actual paths.
-        # The `bot` function will unpack this.
+        print(f"Text content: {text_content}")
+        print(f"Files: {files}")
         
-        # For `chatbot` display:
-        # If there are images, we can create a text representation.
-        # For example, just list "<image1> <image2>" or use Markdown if supported for local files.
-        # Gradio Chatbot displays images if the path is a local temp file path.
+        # If both text and files are empty, skip
+        if not text_content and not files:
+            print("No content to display")
+            return history
         
-        user_turn_content_for_api = (text_input, [f.name for f in file_inputs if f] if file_inputs else [])
-
-        # For chatbot display:
-        # Gradio's Chatbot can display images directly if you pass a list like:
-        # [[(image_path1,), (image_path2,)], None] for an image-only user message
-        # Or [[text_input, (image_path1,)], None]
-        # Let's try to prepare for this.
-
-        if file_inputs:
-            # If there's text AND files, Gradio expects text first, then tuples for files.
-            # e.g., history.append( [ [text_input] + [(file.name,) for file in file_inputs], None] )
-            # Or, more simply, if Chatbot handles multimodal input display well:
-            chatbot_user_message = []
-            if text_input:
-                chatbot_user_message.append(text_input)
-            for file_obj in file_inputs:
-                if file_obj and hasattr(file_obj, 'name'): # file_obj is a TemporaryFileWrapper
-                     chatbot_user_message.append((file_obj.name,)) # Tuple for image path
+        # Add message with images to history
+        if files and len(files) > 0:
+            # Add text message first if it exists
+            if text_content:
+                # Add a separate text message
+                print(f"Adding text message: {text_content}")
+                history.append([text_content, None])
             
-            chat_history_list.append([chatbot_user_message, None])
-
-        elif text_input: # Text only
-            chat_history_list.append([text_input, None])
+            # Then add each image file separately
+            for file_path in files:
+                if file_path and isinstance(file_path, str):
+                    print(f"Adding image: {file_path}")
+                    # Add image as a separate message with no text
+                    history.append([f"![Image]({file_path})", None])
+            
+            return history
+        else:
+            # For text-only messages
+            print(f"Adding text-only message: {text_content}")
+            history.append([text_content, None])
+            return history
+    
+    # Define bot response function
+    def bot(history, system_msg, max_tokens, temperature, top_p, freq_penalty, seed, provider, api_key, custom_model, search_term, selected_model):
+        # Check if history is valid
+        if not history or len(history) == 0:
+            print("No history to process")
+            return history
         
-        # The `bot` function will receive `chat_history_list`.
-        # It needs to reconstruct text and image paths from `chat_history_list[-1][0]`
-        # to pass to `respond`'s `message` and `image_files` parameters.
-
-        return chat_history_list
-
-
-    # Revised bot function to handle history from handle_user_input
-    def process_bot_response(
-        current_chat_history, # This is the full history from the chatbot
-        system_msg, max_tkns, temp, tp_p, freq_pen, sd, prov, api_k, cust_model, srch_term, sel_model
-    ):
-        if not current_chat_history or not current_chat_history[-1][0]:
-            print("Bot: History is empty or last user message is empty.")
-            return current_chat_history # Or yield current_chat_history
-
-        last_user_turn_content = current_chat_history[-1][0] # This is what handle_user_input created
+        # Get the most recent message and detect if it's an image
+        user_message = history[-1][0]
+        print(f"Processing user message: {user_message}")
         
-        # Extract text and image paths from last_user_turn_content
-        current_message_text = ""
-        current_image_paths = []
-
-        if isinstance(last_user_turn_content, str): # Text-only
-            current_message_text = last_user_turn_content
-        elif isinstance(last_user_turn_content, list): # Potentially multimodal from handle_user_input
-            for item in last_user_turn_content:
-                if isinstance(item, str):
-                    current_message_text = item # Assumes one text part
-                elif isinstance(item, tuple) and len(item) > 0 and isinstance(item[0], str):
-                    current_image_paths.append(item[0]) # item[0] is the image path
+        is_image = False
+        image_path = None
+        text_content = user_message
         
-        # print(f"Bot: Extracted for respond - Text='{current_message_text}', Images={current_image_paths}")
-
-        # History for `respond` should be all turns *except* the current one.
-        history_for_api = []
-        for user_content, assistant_content in current_chat_history[:-1]:
-            # Reconstruct (text, [paths]) structure for history items if they were multimodal
-            # This part needs careful handling if history itself contains multimodal user turns
-            # For simplicity, assuming history user_content is string or already (text, [paths])
-            # The current `handle_user_input` makes `user_content` a list for multimodal.
-            # This needs to be harmonized.
-            
-            # Let's simplify: `respond` will parse history. We just pass it.
-            # The `respond` function's history processing needs to handle the new format.
-            # The `respond` function expects history items to be:
-            # user_part: str OR (text_str, [img_paths_list])
-            # assistant_part: str
-            
-            # Let's re-structure history_for_api based on how `handle_user_input` formats it.
-            # `handle_user_input` stores `chatbot_user_message` which is `[text, (path1,), (path2,)]` or `text`
-            # `respond` needs to be adapted for this history format if we pass it directly.
-            
-            # For now, let's adapt the history passed to `respond` to its expected format.
-            api_hist_user_entry = None
-            if isinstance(user_content, str): # Simple text history
-                api_hist_user_entry = user_content
-            elif isinstance(user_content, list): # Multimodal history from `handle_user_input`
-                hist_text = ""
-                hist_paths = []
-                for item in user_content:
-                    if isinstance(item, str): hist_text = item
-                    elif isinstance(item, tuple): hist_paths.append(item[0])
-                api_hist_user_entry = (hist_text, hist_paths)
-
-            history_for_api.append( (api_hist_user_entry, assistant_content) )
-
-
-        # Call respond with the current message parts and the processed history
-        # The `respond` function's first two args are `message` (text) and `image_files` (list of paths)
-        # for the *current* turn.
+        # Check if this is an image message (marked with ![Image])
+        if isinstance(user_message, str) and user_message.startswith("![Image]("):
+            is_image = True
+            # Extract image path from markdown format ![Image](path)
+            image_path = user_message.replace("![Image](", "").replace(")", "")
+            print(f"Image detected: {image_path}")
+            text_content = ""  # No text for image-only messages
         
-        # Clear the placeholder for bot's response in the last history item
-        current_chat_history[-1][1] = "" 
+        # Look back for text context if this is an image
+        text_context = ""
+        if is_image and len(history) > 1:
+            # Use the previous message as context if it's text
+            prev_message = history[-2][0]
+            if isinstance(prev_message, str) and not prev_message.startswith("![Image]("):
+                text_context = prev_message
+                print(f"Using text context from previous message: {text_context}")
         
-        stream = respond(
-            current_message_text,
-            current_image_paths,
-            history_for_api, # Pass the history *before* the current turn
-            system_msg, max_tkns, temp, tp_p, freq_pen, sd, prov, api_k, cust_model, srch_term, sel_model
-        )
+        # Process message through respond function
+        history[-1][1] = ""
         
-        for partial_response in stream:
-            current_chat_history[-1][1] = partial_response
-            yield current_chat_history
-
-
-    # Event handlers
-    # 1. User submits message (text and/or files)
-    # 2. `handle_user_input` updates chatbot history with user's message.
-    # 3. `process_bot_response` takes this new history, calls API, and streams response back to chatbot.
-    
-    submit_event = msg.submit(
-        handle_user_input,
-        inputs=[msg, chatbot], # Pass current message and full history
-        outputs=[chatbot],    # Update chatbot with user's message
-        queue=False           # Process user input quickly
+        # Use either the image or text for the API
+        if is_image:
+            # For image messages
+            for response in respond(
+                text_context,           # Text context from previous message if any
+                [image_path],           # Current image
+                history[:-1],           # Previous history
+                system_msg,
+                max_tokens,
+                temperature,
+                top_p,
+                freq_penalty,
+                seed,
+                provider,
+                api_key,
+                custom_model,
+                search_term,
+                selected_model
+            ):
+                history[-1][1] = response
+                yield history
+        else:
+            # For text-only messages
+            for response in respond(
+                text_content,           # Text message
+                None,                   # No image
+                history[:-1],           # Previous history
+                system_msg,
+                max_tokens,
+                temperature,
+                top_p,
+                freq_penalty,
+                seed,
+                provider,
+                api_key,
+                custom_model,
+                search_term,
+                selected_model
+            ):
+                history[-1][1] = response
+                yield history
+
+    # Event handlers - only using the MultimodalTextbox's built-in submit functionality
+    msg.submit(
+        user,
+        [msg, chatbot],
+        [chatbot],
+        queue=False
     ).then(
-        process_bot_response,
-        inputs=[
-            chatbot, # Full history including the latest user message
-            system_message_box, max_tokens_slider, temperature_slider, top_p_slider, 
-            frequency_penalty_slider, seed_slider, provider_radio, byok_textbox, 
-            custom_model_box, model_search_box, featured_model_radio
-        ],
-        outputs=[chatbot] # Stream bot's response to chatbot
+        bot,
+        [chatbot, system_message_box, max_tokens_slider, temperature_slider, top_p_slider, 
+         frequency_penalty_slider, seed_slider, provider_radio, byok_textbox, custom_model_box, 
+         model_search_box, featured_model_radio],
+        [chatbot]
     ).then(
-        lambda: gr.update(value=None),  # Clear MultimodalTextbox (text and files)
-        None, # No inputs
-        [msg], # Target component to clear
-        queue=False
+        lambda: {"text": "", "files": []},  # Clear inputs after submission
+        None,
+        [msg]
     )
     
-    def filter_models_choices(search_term):
-        # print(f"Filtering models with: '{search_term}'")
-        if not search_term: return gr.update(choices=models_list)
-        filtered = [m for m in models_list if search_term.lower() in m.lower()]
-        # print(f"Filtered models: {filtered}")
-        return gr.update(choices=filtered if filtered else [])
+    # Connect the model filter to update the radio choices
+    model_search_box.change(
+        fn=filter_models,
+        inputs=model_search_box,
+        outputs=featured_model_radio
+    )
+    print("Model search box change event linked.")
 
-    model_search_box.change(fn=filter_models_choices, inputs=model_search_box, outputs=featured_model_radio)
+    # Connect the featured model radio to update the custom model box
+    featured_model_radio.change(
+        fn=set_custom_model_from_radio,
+        inputs=featured_model_radio,
+        outputs=custom_model_box
+    )
+    print("Featured model radio button change event linked.")
     
-    # When a featured model is selected, it could optionally update the custom_model_box.
-    # For now, custom_model_box is an override. If empty, featured_model_radio is used by `respond`.
-    # No direct link needed unless you want radio to populate custom_model_box.
-
-    # Provider validation (simplified, as InferenceClient handles token logic)
-    byok_textbox.change(fn=validate_provider, inputs=[byok_textbox, provider_radio], outputs=provider_radio)
-    provider_radio.change(fn=validate_provider, inputs=[byok_textbox, provider_radio], outputs=provider_radio)
+    # Connect the BYOK textbox to validate provider selection
+    byok_textbox.change(
+        fn=validate_provider,
+        inputs=[byok_textbox, provider_radio],
+        outputs=provider_radio
+    )
+    print("BYOK textbox change event linked.")
 
-    print("Gradio UI defined. Initializing...")
+    # Also validate provider when the radio changes to ensure consistency
+    provider_radio.change(
+        fn=validate_provider,
+        inputs=[byok_textbox, provider_radio],
+        outputs=provider_radio
+    )
+    print("Provider radio button change event linked.")
 
+print("Gradio interface initialized.")
 
 if __name__ == "__main__":
-    print("Launching Gradio demo...")
-    demo.launch(show_api=True, debug=True) # Enable debug for more Gradio logs
-    print("Gradio demo launched.")
+    print("Launching the demo application.")
+    demo.launch(show_api=True)