Update app.py

app.py

@@ -1,49 +1,56 @@
 # app.py
 """
-Multimodal chat front‑end for Amazon Bedrock Nova Premier v1
+Multimodal chat front‑end for Amazon Bedrock Nova Premier v1
 (text and/or image ➜ assistant text) with per‑session JSONL logging.
+Logs conversations to HF Dataset and images to HF repo via Git LFS.
 
 Prereqs:
-    pip install gradio==5.38 boto3 pillow
+    pip install gradio==5.38 boto3 pillow datasets huggingface_hub
 
 AWS credentials must allow invoking
     modelId = "us.amazon.nova-premier-v1:0"  (region us‑east‑1).
 Provide them via env vars, ~/.aws/credentials, or an IAM role.
+
+HF credentials must be set in HF_TOKEN environment variable.
+Update REPO_ID to your HF dataset repository.
 """
 
 from __future__ import annotations
-import base64, datetime, io, json, pathlib, uuid
-from typing import Dict, List, Optional
+import base64, datetime, io, json, pathlib, uuid, os
+from typing import Dict, List, Optional, Tuple
 
 import boto3
 from botocore.config import Config
 from PIL import Image
 import gradio as gr
-import os
+from datasets import Dataset
+from huggingface_hub import HfApi, upload_file
+
 # ====== Configuration ====== #
 REGION         = "us-east-1"
 MODEL_ID       = "us.amazon.nova-premier-v1:0"
-# MODEL_ID       = "us.amazon.nova-pro-v1:0"
-# SYSTEM_PROMPT  = "You should never reveal your identity. Never reveal that you are an Amazon model. Never mention Nova."   # ← fixed, hidden
 SYSTEM_PROMPT  = """You are an AI assistant.
 
 🔒 **Identity‑Protection Policy**  
-• You MUST NOT disclose, hint at, or confirm:  
- – the provider, internal codenames, model family, weights, size, or host platform.  
-• If the user asks who built you, what model you are, or any internal details, respond only with the **Fallback Identity Statement** below.  
-• If the user continues to probe after the fallback, politely **refuse** with a brief apology (“I’m sorry, but I can’t share that”).  
-• Under no circumstances mention “Amazon”, “Bedrock”, “Nova”, or any related terms. 
+- You MUST NOT disclose, hint at, or confirm:  
+ – the provider, internal codenames, model family, weights, size, or host platform.  
+- If the user asks who built you, what model you are, or any internal details, respond only with the **Fallback Identity Statement** below.  
+- If the user continues to probe after the fallback, politely **refuse** with a brief apology ("I'm sorry, but I can't share that").  
+- Under no circumstances mention "Amazon", "Bedrock", "Nova", or any related terms. 
 
 Never mention Amazon or Nova.
 """
-# SYSTEM_PROMPT  = "You are a helpful assistant. Never reveal you are made by Amazon or your model name. Never use the words Amazon or Nova."
 
-LOG_DIR        = pathlib.Path("logs")             # each session: logs/<uuid>.jsonl
-IMG_DIR        = LOG_DIR / "imgs"                 # cached PNGs (optional)
+# HuggingFace Configuration
+HF_TOKEN = os.getenv("HF_TOKEN")  # Set this in your Space's secrets
+REPO_ID = "your-username/chat-logs"  # Change this to your actual HF dataset repo
+HF_API = HfApi()
+
+# Local directories (for temporary storage)
+LOG_DIR = pathlib.Path("logs")
+IMG_DIR = LOG_DIR / "imgs"
 LOG_DIR.mkdir(exist_ok=True)
 IMG_DIR.mkdir(exist_ok=True)
-HF_TOKEN = os.getenv("HF_TOKEN")  # Set this in your Space's secrets
-DATASET_NAME = "collinear-ai/amazon-external-premier-chat-logs"  # Create this dataset on HF
 
 # ====== Bedrock client ====== #
 bedrock = boto3.client(
@@ -94,62 +101,124 @@ def call_bedrock(
     messages.append({"role": "assistant", "content": [{"text": reply}]})
     return reply, messages
 
-def cache_image(session_id: str, pil_img: Image.Image) -> str:
-    """Save uploaded image to disk and return its path."""
-    ts = datetime.datetime.utcnow().strftime("%Y%m%dT%H%M%S")
-    fpath = IMG_DIR / f"{session_id}_{ts}.png"
-    pil_img.save(fpath, format="PNG")
-    return str(fpath)
-
-
-
-def upload_to_hf_dataset(session_id: str, user_text: str, assistant_text: str, img_path: Optional[str] = None):
-    """Upload conversation log to HF Dataset"""
+def upload_image_to_hf_repo(session_id: str, pil_img: Image.Image) -> Optional[str]:
+    """Upload image to HF repo and return the repo URL."""
+    if not HF_TOKEN:
+        print("Warning: HF_TOKEN not set, skipping image upload to HF repo")
+        return None
+        
+    try:
+        # Create unique filename
+        ts = datetime.datetime.utcnow().strftime("%Y%m%dT%H%M%S")
+        filename = f"images/{session_id}_{ts}.png"
+        
+        # Save locally first
+        local_path = IMG_DIR / f"{session_id}_{ts}.png"
+        pil_img.save(local_path, format="PNG")
+        
+        # Upload to HF repo
+        upload_file(
+            path_or_fileobj=str(local_path),
+            path_in_repo=filename,
+            repo_id=REPO_ID,
+            token=HF_TOKEN,
+            repo_type="dataset",
+            commit_message=f"Add image for session {session_id[:8]}"
+        )
+        
+        # Return the HF repo URL
+        hf_image_url = f"https://huggingface.co/datasets/{REPO_ID}/resolve/main/{filename}"
+        print(f"Image uploaded to HF repo: {hf_image_url}")
+        return hf_image_url
+        
+    except Exception as e:
+        print(f"Failed to upload image to HF repo: {e}")
+        return None
+
+def upload_conversation_to_hf_dataset(session_id: str, user_text: str, assistant_text: str, hf_image_url: Optional[str] = None):
+    """Upload conversation log to HF Dataset with image URL."""
+    if not HF_TOKEN:
+        print("Warning: HF_TOKEN not set, skipping upload to HF dataset")
+        return
+        
     try:
         record = {
             "session_id": session_id,
             "timestamp": datetime.datetime.utcnow().isoformat() + "Z",
             "user_message": user_text,
             "assistant_message": assistant_text,
-            "has_image": img_path is not None,
-            "image_path": img_path if img_path else ""
+            "image_url": hf_image_url if hf_image_url else "",
+            "has_image": hf_image_url is not None
         }
         
-        # Create dataset from single record
-        dataset = Dataset.from_list([record])
+        # Try to load existing dataset and append
+        try:
+            existing_dataset = Dataset.load_dataset(REPO_ID, token=HF_TOKEN, split="train")
+            # Convert to list, add new record, convert back
+            records = existing_dataset.to_list()
+            records.append(record)
+            updated_dataset = Dataset.from_list(records)
+        except Exception as load_error:
+            print(f"Could not load existing dataset (creating new): {load_error}")
+            # Dataset doesn't exist yet, create new one
+            updated_dataset = Dataset.from_list([record])
         
-        # Push to hub (append mode)
-        dataset.push_to_hub(
-            DATASET_NAME,
+        # Push updated dataset
+        updated_dataset.push_to_hub(
+            REPO_ID,
             token=HF_TOKEN,
-            private=True  # Keep logs private
+            private=True,
+            commit_message=f"Add conversation from session {session_id[:8]}"
         )
+        
+        print(f"Conversation logged to HF dataset: {REPO_ID}")
+        
     except Exception as e:
-        print(f"Failed to upload log: {e}")
+        print(f"Failed to upload conversation log to HF dataset: {e}")
 
-# Replace your append_log function with:
-def append_log(session_id: str, user_text: str, assistant_text: str, img_path: Optional[str] = None):
-    # Keep local logging for immediate access
+def cache_image(session_id: str, pil_img: Image.Image) -> Tuple[str, Optional[str]]:
+    """Save image locally AND upload to HF repo. Returns (local_path, hf_url)."""
+    # Save locally for immediate use
+    ts = datetime.datetime.utcnow().strftime("%Y%m%dT%H%M%S")
+    local_path = IMG_DIR / f"{session_id}_{ts}.png"
+    pil_img.save(local_path, format="PNG")
+    
+    # Upload to HF repo
+    hf_url = upload_image_to_hf_repo(session_id, pil_img)
+    
+    return str(local_path), hf_url
+
+def append_log(session_id: str, user_text: str, assistant_text: str, local_img_path: Optional[str] = None, hf_img_url: Optional[str] = None):
+    """Log conversation locally AND to HF dataset."""
+    # Local logging (existing functionality for immediate access)
     record = {
         "ts": datetime.datetime.utcnow().isoformat(timespec="seconds") + "Z",
         "user": user_text,
         "assistant": assistant_text,
     }
-    if img_path:
-        record["image_file"] = img_path
+    if local_img_path:
+        record["image_file"] = local_img_path
+    if hf_img_url:
+        record["hf_image_url"] = hf_img_url
+        
     path = LOG_DIR / f"{session_id}.jsonl"
     with path.open("a", encoding="utf-8") as f:
         f.write(json.dumps(record, ensure_ascii=False) + "\n")
     
-    # Also upload to HF Dataset
-    upload_to_hf_dataset(session_id, user_text, assistant_text, img_path)
+    # Upload to HF Dataset (persistent storage)
+    upload_conversation_to_hf_dataset(session_id, user_text, assistant_text, hf_img_url)
 
 # ====== Gradio UI ====== #
-with gr.Blocks(title="Multimodal Chat") as demo:
+with gr.Blocks(title="Multimodal Chat with HF Logging") as demo:
     gr.Markdown(
-        """
-        ## Multimodal Chat  
+        f"""
+        ## Multimodal Chat with Persistent Logging 📝
         Upload an image *(optional)*, ask a question, and continue the conversation.
+        
+        **Logging Status:**
+        - 💾 Local logs: Always saved to temporary storage
+        - 🤗 HF Dataset: {"✅ Enabled" if HF_TOKEN else "❌ Disabled (set HF_TOKEN)"} - Repo: `{REPO_ID}`
+        - 🖼️ Images: {"✅ Uploaded to HF repo" if HF_TOKEN else "❌ Local only"}
         """
     )
 
@@ -172,6 +241,15 @@ with gr.Blocks(title="Multimodal Chat") as demo:
         top_p  = gr.Slider(0.0, 1.0, value=0.9, step=0.01, label="top_p")
         top_k  = gr.Slider(1,   100, value=50, step=1,   label="top_k")
 
+    # Status area for logging feedback
+    with gr.Row():
+        log_status = gr.Textbox(
+            label="Logging Status", 
+            value="Ready to log conversations...",
+            interactive=False,
+            max_lines=2
+        )
+
     # ---- main handler ---- #
     def chat(chat_log, br_history, sess_id,
              image, text,
@@ -183,430 +261,83 @@ with gr.Blocks(title="Multimodal Chat") as demo:
         if not sess_id:
             sess_id = str(uuid.uuid4())
 
-        reply, new_br = call_bedrock(
-            br_history, image, text.strip(),
-            int(max_tokens), float(temperature),
-            float(top_p),    int(top_k)
-        )
-
-        img_path = cache_image(sess_id, image) if image else None
-        display_user = text if text.strip() else "[image]"
+        # Call Bedrock
+        try:
+            reply, new_br = call_bedrock(
+                br_history, image, text.strip(),
+                int(max_tokens), float(temperature),
+                float(top_p), int(top_k)
+            )
+        except Exception as e:
+            raise gr.Error(f"Bedrock API error: {str(e)}")
+
+        # Handle image caching (both local and HF)
+        local_img_path, hf_img_url = None, None
+        if image:
+            local_img_path, hf_img_url = cache_image(sess_id, image)
+        
+        display_user = text.strip() if text.strip() else "[image uploaded]"
         chat_log.append((display_user, reply))
-        append_log(sess_id, display_user, reply, img_path)
+        
+        # Log with both local and HF image paths
+        append_log(sess_id, display_user, reply, local_img_path, hf_img_url)
+        
+        # Update status message
+        status_msg = f"✅ Logged conversation for session {sess_id[:8]}"
+        if image:
+            if hf_img_url:
+                status_msg += f" | 🖼️ Image uploaded to HF repo"
+            else:
+                status_msg += f" | ⚠️ Image saved locally only"
+        
+        if not HF_TOKEN:
+            status_msg += " | ❌ HF logging disabled (no token)"
 
-        return chat_log, chat_log, new_br, sess_id, None, ""
+        return chat_log, chat_log, new_br, sess_id, None, "", status_msg
 
     send_btn.click(
         chat,
         inputs=[chat_state, br_state, sess_state,
                 img_in, txt_in,
                 max_tk, temp, top_p, top_k],
-        outputs=[chatbot, chat_state, br_state, sess_state, img_in, txt_in],
+        outputs=[chatbot, chat_state, br_state, sess_state, img_in, txt_in, log_status],
     )
 
     # ---- clear chat ---- #
     def reset():
-        return [], [], "", None, ""
+        return [], [], "", None, "", "Ready to log conversations..."
 
     clear_btn.click(
         reset,
         inputs=None,
-        outputs=[chatbot, chat_state, sess_state, img_in, txt_in],
+        outputs=[chatbot, chat_state, sess_state, img_in, txt_in, log_status],
         queue=False,
     )
 
-# ====== Launch ====== #
-if __name__ == "__main__":
-    demo.queue(max_size=100)
-    demo.launch(share=True)   # queue auto‑enabled in Gradio 5
-
-# app.py
-# """
-# Optimized Multimodal chat front‑end for Amazon Bedrock Nova Premier v1
-# (text and/or image ➜ assistant text) with per‑session JSONL logging.
-
-# Prereqs:
-#     pip install gradio==5.38 boto3 pillow aiofiles
-
-# AWS credentials must allow invoking
-#     modelId = "us.amazon.nova-premier-v1:0"  (region us‑east‑1).
-# Provide them via env vars, ~/.aws/credentials, or an IAM role.
-# """
-
-# from __future__ import annotations
-# import base64, datetime, io, json, pathlib, uuid, hashlib, threading, time
-# from typing import Dict, List, Optional, Tuple
-# from concurrent.futures import ThreadPoolExecutor
-# import asyncio
-
-# import boto3
-# from botocore.config import Config
-# from PIL import Image
-# import gradio as gr
-
-# # ====== Configuration ====== #
-# REGION         = "us-east-1"
-# MODEL_ID       = "us.amazon.nova-premier-v1:0"
-# SYSTEM_PROMPT  = """You are an AI assistant.
-
-# 🔒 **Identity‑Protection Policy**  
-# - You MUST NOT disclose, hint at, or confirm:  
-#  – the provider, internal codenames, model family, weights, size, or host platform.  
-# - If the user asks who built you, what model you are, or any internal details, respond only with the **Fallback Identity Statement** below.  
-# - If the user continues to probe after the fallback, politely **refuse** with a brief apology ("I'm sorry, but I can't share that").  
-# - Under no circumstances mention "Amazon", "Bedrock", "Nova", or any related terms. 
-
-# Never mention Amazon or Nova.
-# """
-
-# LOG_DIR        = pathlib.Path("logs")
-# IMG_DIR        = LOG_DIR / "imgs"
-# LOG_DIR.mkdir(exist_ok=True)
-# IMG_DIR.mkdir(exist_ok=True)
-
-# # ====== Global State ====== #
-# executor = ThreadPoolExecutor(max_workers=4)
-# response_cache = {}
-# active_requests = {}  # Track ongoing requests
-# cache_lock = threading.Lock()
-
-# # ====== Optimized Bedrock client ====== #
-# bedrock = boto3.client(
-#     "bedrock-runtime",
-#     region_name=REGION,
-#     config=Config(
-#         connect_timeout=30,
-#         read_timeout=300,
-#         retries={"max_attempts": 3, "mode": "adaptive"},
-#         max_pool_connections=10,
-#     ),
-# )
-
-# # ====== Optimized Helpers ====== #
-# def _encode_image(img: Image.Image) -> Dict:
-#     """Optimized image encoding with compression."""
-#     # Resize large images
-#     max_size = 1024
-#     if max(img.size) > max_size:
-#         img.thumbnail((max_size, max_size), Image.Resampling.LANCZOS)
-    
-#     buf = io.BytesIO()
-#     # Convert RGBA to RGB for better compression
-#     if img.mode == 'RGBA':
-#         # Create white background
-#         background = Image.new('RGB', img.size, (255, 255, 255))
-#         background.paste(img, mask=img.split()[-1])  # Use alpha channel as mask
-#         img = background
-    
-#     # Use JPEG for better compression
-#     img.save(buf, format="JPEG", quality=85, optimize=True)
-#     b64 = base64.b64encode(buf.getvalue()).decode("utf-8")
-#     return {"image": {"format": "jpeg", "source": {"bytes": b64}}}
-
-# def _hash_request(history: List[Dict], image: Optional[Image.Image], 
-#                  text: str, params: Tuple) -> str:
-#     """Create hash of request for caching."""
-#     content = str(history) + str(text) + str(params)
-#     if image:
-#         img_bytes = io.BytesIO()
-#         image.save(img_bytes, format='PNG')
-#         content += str(hashlib.md5(img_bytes.getvalue()).hexdigest())
-#     return hashlib.sha256(content.encode()).hexdigest()
-
-# def call_bedrock(
-#     history: List[Dict],
-#     image: Optional[Image.Image],
-#     user_text: str,
-#     max_tokens: int,
-#     temperature: float,
-#     top_p: float,
-#     top_k: int,
-# ) -> Tuple[str, List[Dict]]:
-#     """Send full conversation to Bedrock with caching."""
-    
-#     # Check cache first
-#     cache_key = _hash_request(history, image, user_text, 
-#                              (max_tokens, temperature, top_p, top_k))
-    
-#     with cache_lock:
-#         if cache_key in response_cache:
-#             return response_cache[cache_key]
-    
-#     content: List[Dict] = []
-#     if image is not None:
-#         content.append(_encode_image(image))
-#     if user_text:
-#         content.append({"text": user_text})
-
-#     messages = history + [{"role": "user", "content": content}]
-#     body = {
-#         "schemaVersion": "messages-v1",
-#         "messages": messages,
-#         "system": [{"text": SYSTEM_PROMPT}],
-#         "inferenceConfig": {
-#             "maxTokens": max_tokens,
-#             "temperature": temperature,
-#             "topP": top_p,
-#             "topK": top_k,
-#         },
-#     }
-
-#     try:
-#         resp = bedrock.invoke_model(modelId=MODEL_ID, body=json.dumps(body))
-#         reply = json.loads(resp["body"].read())["output"]["message"]["content"][0]["text"]
-        
-#         messages.append({"role": "assistant", "content": [{"text": reply}]})
-#         result = (reply, messages)
-        
-#         # Cache the result
-#         with cache_lock:
-#             response_cache[cache_key] = result
-#             # Limit cache size
-#             if len(response_cache) > 100:
-#                 # Remove oldest entries
-#                 oldest_keys = list(response_cache.keys())[:20]
-#                 for key in oldest_keys:
-#                     del response_cache[key]
+    # Add info about viewing logs
+    gr.Markdown(
+        f"""
+        ### 📊 Viewing Your Logs
         
-#         return result
+        If HF logging is enabled, you can view your conversation logs at:
+        - **Dataset**: [https://huggingface.co/datasets/{REPO_ID}](https://huggingface.co/datasets/{REPO_ID})
+        - **Images**: Browse the `images/` folder in the dataset repository
         
-#     except Exception as e:
-#         raise Exception(f"Bedrock API error: {str(e)}")
+        **Local logs** (temporary): Saved in JSONL format, accessible until Space restarts.
+        """
+    )
 
-# def cache_image_optimized(session_id: str, pil_img: Image.Image) -> str:
-#     """Optimized image caching with compression."""
-#     ts = datetime.datetime.utcnow().strftime("%Y%m%dT%H%M%S")
-#     fpath = IMG_DIR / f"{session_id}_{ts}.jpg"  # Use JPEG for smaller files
-    
-#     # Optimize image before saving
-#     if pil_img.mode == 'RGBA':
-#         background = Image.new('RGB', pil_img.size, (255, 255, 255))
-#         background.paste(pil_img, mask=pil_img.split()[-1])
-#         pil_img = background
-    
-#     pil_img.save(fpath, format="JPEG", quality=85, optimize=True)
-#     return str(fpath)
-
-# def append_log_threaded(session_id: str, user_text: str, assistant_text: str, 
-#                        img_path: Optional[str] = None):
-#     """Thread-safe logging."""
-#     def write_log():
-#         record = {
-#             "ts": datetime.datetime.utcnow().isoformat(timespec="seconds") + "Z",
-#             "user": user_text,
-#             "assistant": assistant_text,
-#         }
-#         if img_path:
-#             record["image_file"] = img_path
-        
-#         path = LOG_DIR / f"{session_id}.jsonl"
-#         with path.open("a", encoding="utf-8") as f:
-#             f.write(json.dumps(record, ensure_ascii=False) + "\n")
-    
-#     # Write to log in background thread
-#     executor.submit(write_log)
-
-# # ====== Request Status Manager ====== #
-# class RequestStatus:
-#     def __init__(self):
-#         self.is_complete = False
-#         self.result = None
-#         self.error = None
-#         self.start_time = time.time()
-
-# # ====== Gradio UI ====== #
-# with gr.Blocks(title="Optimized Multimodal Chat", 
-#                css="""
-#                .thinking { opacity: 0.7; font-style: italic; }
-#                .error { color: #ff4444; }
-#                """) as demo:
+# ====== Launch ====== #
+if __name__ == "__main__":
+    # Validate configuration on startup
+    if not HF_TOKEN:
+        print("⚠️  WARNING: HF_TOKEN not set. Logging will be local only and will be lost on Space restart.")
+        print("   To enable persistent logging:")
+        print("   1. Go to your Space settings → Repository secrets")
+        print("   2. Add HF_TOKEN with your HuggingFace token (write permissions)")
+        print("   3. Create a dataset repository and update REPO_ID in the code")
+    else:
+        print(f"✅ HF logging enabled. Logs will be saved to: {REPO_ID}")
     
-#     gr.Markdown(
-#         """
-#         ## 🚀 Optimized Multimodal Chat  
-#         Upload an image *(optional)*, ask a question, and continue the conversation.
-#         *Now with improved performance and responsive UI!*
-#         """
-#     )
-
-#     chatbot = gr.Chatbot(height=420)
-#     chat_state = gr.State([])   # [(user, assistant), …]
-#     br_state = gr.State([])     # Bedrock message dicts
-#     sess_state = gr.State("")   # UUID for this browser tab
-#     request_id_state = gr.State("")  # Track current request
-
-#     with gr.Row():
-#         img_in = gr.Image(label="Image (optional)", type="pil")
-#         txt_in = gr.Textbox(
-#             lines=3, 
-#             label="Your message",
-#             placeholder="Ask something about the image… or just chat!",
-#             interactive=True
-#         )
-
-#     with gr.Row():
-#         send_btn = gr.Button("Send", variant="primary")
-#         clear_btn = gr.Button("Clear chat")
-#         stop_btn = gr.Button("Stop", variant="stop", visible=False)
-
-#     with gr.Row():
-#         status_text = gr.Textbox(
-#             label="Status",
-#             value="Ready",
-#             interactive=False,
-#             max_lines=1
-#         )
-
-#     with gr.Accordion("⚙️ Advanced generation settings", open=False):
-#         max_tk = gr.Slider(16, 1024, value=512, step=16, label="max_tokens")
-#         temp = gr.Slider(0.0, 1.0, value=1.0, step=0.05, label="temperature")
-#         top_p = gr.Slider(0.0, 1.0, value=0.9, step=0.01, label="top_p")
-#         top_k = gr.Slider(1, 100, value=50, step=1, label="top_k")
-
-#     # ---- Optimized chat handler ---- #
-#     def chat_optimized(chat_log, br_history, sess_id, request_id,
-#                       image, text,
-#                       max_tokens, temperature, top_p, top_k):
-        
-#         if image is None and not text.strip():
-#             return chat_log, chat_log, br_history, sess_id, request_id, None, "", "⚠️ Upload an image or enter a message.", True, False
-
-#         if not sess_id:
-#             sess_id = str(uuid.uuid4())
-        
-#         # Generate new request ID
-#         request_id = str(uuid.uuid4())
-        
-#         display_user = text.strip() if text.strip() else "[image uploaded]"
-        
-#         # Add thinking message immediately
-#         chat_log.append((display_user, "🤔 Processing your request..."))
-        
-#         # Create request status tracker
-#         status = RequestStatus()
-#         active_requests[request_id] = status
-        
-#         def background_process():
-#             try:
-#                 reply, new_br = call_bedrock(
-#                     br_history, image, text.strip(),
-#                     int(max_tokens), float(temperature),
-#                     float(top_p), int(top_k)
-#                 )
-                
-#                 img_path = None
-#                 if image:
-#                     img_path = cache_image_optimized(sess_id, image)
-                
-#                 # Log in background
-#                 append_log_threaded(sess_id, display_user, reply, img_path)
-                
-#                 # Update status
-#                 status.result = (reply, new_br)
-#                 status.is_complete = True
-                
-#             except Exception as e:
-#                 status.error = str(e)
-#                 status.is_complete = True
-        
-#         # Start background processing
-#         executor.submit(background_process)
-        
-#         return (chat_log, chat_log, br_history, sess_id, request_id, 
-#                 None, "", "🔄 Processing...", False, True)
-
-#     # ---- Status checker ---- #
-#     def check_status(chat_log, br_history, request_id):
-#         if not request_id or request_id not in active_requests:
-#             return chat_log, chat_log, br_history, "Ready", True, False
-        
-#         status = active_requests[request_id]
-        
-#         if not status.is_complete:
-#             elapsed = time.time() - status.start_time
-#             return (chat_log, chat_log, br_history, 
-#                    f"⏱️ Processing... ({elapsed:.1f}s)", False, True)
-        
-#         # Request completed
-#         if status.error:
-#             # Update last message with error
-#             if chat_log:
-#                 chat_log[-1] = (chat_log[-1][0], f"❌ Error: {status.error}")
-#             status_msg = "❌ Request failed"
-#         else:
-#             # Update last message with result
-#             reply, new_br = status.result
-#             if chat_log:
-#                 chat_log[-1] = (chat_log[-1][0], reply)
-#             br_history = new_br
-#             status_msg = "✅ Complete"
-        
-#         # Clean up
-#         del active_requests[request_id]
-        
-#         return chat_log, chat_log, br_history, status_msg, True, False
-
-#     # ---- Event handlers ---- #
-#     send_btn.click(
-#         chat_optimized,
-#         inputs=[chat_state, br_state, sess_state, request_id_state,
-#                 img_in, txt_in,
-#                 max_tk, temp, top_p, top_k],
-#         outputs=[chatbot, chat_state, br_state, sess_state, request_id_state,
-#                 img_in, txt_in, status_text, send_btn, stop_btn],
-#         queue=True
-#     )
-
-#     # Auto-refresh status every 1 second
-#     status_checker = gr.Timer(1.0)
-#     status_checker.tick(
-#         check_status,
-#         inputs=[chat_state, br_state, request_id_state],
-#         outputs=[chatbot, chat_state, br_state, status_text, send_btn, stop_btn],
-#         queue=False
-#     )
-
-#     # ---- Clear chat ---- #
-#     def reset():
-#         return [], [], "", "", None, "", "Ready", True, False
-
-#     clear_btn.click(
-#         reset,
-#         inputs=None,
-#         outputs=[chatbot, chat_state, sess_state, request_id_state,
-#                 img_in, txt_in, status_text, send_btn, stop_btn],
-#         queue=False,
-#     )
-
-#     # ---- Stop request ---- #
-#     def stop_request(request_id):
-#         if request_id in active_requests:
-#             del active_requests[request_id]
-#         return "⏹️ Stopped", True, False, ""
-
-#     stop_btn.click(
-#         stop_request,
-#         inputs=[request_id_state],
-#         outputs=[status_text, send_btn, stop_btn, request_id_state],
-#         queue=False
-#     )
-
-# # ====== Cleanup on exit ====== #
-# import atexit
-
-# def cleanup():
-#     executor.shutdown(wait=False)
-#     active_requests.clear()
-#     response_cache.clear()
-
-# atexit.register(cleanup)
-
-# # ====== Launch ====== #
-# if __name__ == "__main__":
-#     demo.queue(max_size=20)  # Enable queuing with reasonable limit
-#     demo.launch(
-#         share=True,
-#         server_name="0.0.0.0",
-#         server_port=7860,
-#         show_error=True
-#     )
+    demo.queue(max_size=100)
+    demo.launch(share=True)