Update app.py

app.py

@@ -22,6 +22,16 @@ CONTEXT_SIZES = {
     "200K": 200000
 }
 
+MODEL_CONTEXT_SIZES = {
+    "OpenAI ChatGPT": 4096,
+    "HuggingFace Inference": 4096,
+    "Groq API": {
+        "llama-3.1-70b-versatile": 32768,
+        "mixtral-8x7b-32768": 32768,
+        "llama-3.1-8b-instant": 8192
+    }
+}
+
 class ModelRegistry:
     def __init__(self):
         self.hf_models = {
@@ -148,49 +158,61 @@ def build_prompts(snippets: List[str], prompt_instruction: str, custom_prompt: O
     
     return "\n\n".join(prompts)
 
-def send_to_model(prompt, model_selection, hf_model_choice, hf_custom_model, hf_api_key,
-                 groq_model_choice, groq_api_key, openai_api_key):
-    """Send prompt to selected model"""
+def send_to_model(*args, **kwargs):
     try:
-        if model_selection == "HuggingFace Inference":
-            if not hf_api_key:
-                return "HuggingFace API key required.", []
-            
-            model_id = hf_custom_model if hf_model_choice == "Custom Model" else model_registry.hf_models[hf_model_choice]
-            summary = send_to_hf_inference(prompt, model_id, hf_api_key)
-            
-        elif model_selection == "Groq API":
-            if not groq_api_key:
-                return "Groq API key required.", []
-                
-            summary = send_to_groq(prompt, groq_model_choice, groq_api_key)
-            
-        elif model_selection == "OpenAI ChatGPT":
-            if not openai_api_key:
-                return "OpenAI API key required.", []
-            # Implement OpenAI API call here
-            
-        # Save summary for download
-        with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt') as summary_file:
-            summary_file.write(summary)
-            
-        return summary, [summary_file.name]
-        
+        with gr.Progress() as progress:
+            progress(0, "Preparing to send to model...")
+            result = send_to_model_impl(*args, **kwargs)
+            progress(1, "Complete!")
+            return result
     except Exception as e:
-        logging.error(f"Error sending to model: {e}")
-        return f"Error sending to model: {str(e)}", []
+        return f"Error: {str(e)}", None
+
+def send_to_model_impl(prompt, model_selection, hf_model_choice, hf_custom_model, hf_api_key,
+                    groq_model_choice, groq_api_key, openai_api_key):
+    """Implementation of send to model functionality"""
+    if model_selection == "HuggingFace Inference":
+        if not hf_api_key:
+            return "HuggingFace API key required.", []
+        
+        model_id = hf_custom_model if hf_model_choice == "Custom Model" else model_registry.hf_models[hf_model_choice]
+        summary = send_to_hf_inference(prompt, model_id, hf_api_key)
+    
+    elif model_selection == "Groq API":
+        if not groq_api_key:
+            return "Groq API key required.", []
+        summary = send_to_groq(prompt, groq_model_choice, groq_api_key)
+        
+    elif model_selection == "OpenAI ChatGPT":
+        if not openai_api_key:
+            return "OpenAI API key required.", []
+        summary = send_to_openai(prompt, openai_api_key)
+    
+    else:
+        return "Invalid model selection.", []
+        
+    if summary.startswith("Error"):
+        return summary, []
+        
+    # Save summary for download
+    with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt') as f:
+        f.write(summary)
+        
+    return summary, [f.name]
 
 def send_to_hf_inference(prompt: str, model_name: str, api_key: str) -> str:
     """Send prompt to HuggingFace using Inference API"""
     try:
-        client = InferenceClient(api_key=api_key)
-        messages = [{"role": "user", "content": prompt}]
-        completion = client.chat.completions.create(
+        client = InferenceClient(token=api_key)
+        response = client.text_generation(
+            prompt,
             model=model_name,
-            messages=messages,
-            max_tokens=500
+            max_new_tokens=500,
+            temperature=0.7,
+            details=True,  # Get full response details
+            stream=False   # Don't stream output
         )
-        return completion.choices[0].message.content
+        return response.generated_text  # Return just the generated text
     except Exception as e:
         logging.error(f"Error with HF inference: {e}")
         return f"Error with HF inference: {e}"
@@ -204,40 +226,77 @@ def send_to_groq(prompt: str, model_name: str, api_key: str) -> str:
         }
         data = {
             "model": model_name,
-            "messages": [{"role": "user", "content": prompt}]
+            "messages": [{"role": "user", "content": prompt}],
+            "temperature": 0.7,
+            "max_tokens": 500
         }
         response = requests.post(
             "https://api.groq.com/openai/v1/chat/completions",
             headers=headers,
             json=data
         )
-        return response.json()["choices"][0]["message"]["content"]
+        if response.status_code != 200:
+            return f"Error: Groq API returned status {response.status_code}"
+            
+        response_json = response.json()
+        if "choices" not in response_json or not response_json["choices"]:
+            return "Error: No response from Groq API"
+            
+        return response_json["choices"][0]["message"]["content"]
     except Exception as e:
         logging.error(f"Error with Groq API: {e}")
         return f"Error with Groq API: {e}"
 
-def copy_to_clipboard(text: str) -> str:
-    """Copy text to clipboard using JavaScript"""
-    return """
-        navigator.clipboard.writeText(text)
-            .then(() => gradioApp().querySelector('#progress_status').value = 'Copied to clipboard!')
-            .catch(() => gradioApp().querySelector('#progress_status').value = 'Failed to copy');
+def send_to_openai(prompt: str, api_key: str) -> str:
+    """Send prompt to OpenAI API"""
+    try:
+        import openai
+        openai.api_key = api_key
+        
+        response = openai.ChatCompletion.create(
+            model="gpt-3.5-turbo",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.7,
+            max_tokens=500
+        )
+        
+        return response.choices[0].message.content
+    except Exception as e:
+        logging.error(f"Error with OpenAI API: {e}")
+        return f"Error with OpenAI API: {e}"
+
+def copy_to_clipboard(element_id: str) -> str:
+    return f"""
+        () => {{
+            try {{
+                const text = document.querySelector('#{element_id} textarea').value;
+                navigator.clipboard.writeText(text);
+                return "Copied to clipboard!";
+            }} catch (e) {{
+                console.error(e);
+                return "Failed to copy to clipboard";
+            }}
+        }}
     """
 
-def open_chatgpt() -> None:
+def open_chatgpt_old() -> str:
+    webbrowser.open_new_tab('https://chat.openai.com')
+    return "Opening ChatGPT in new tab"
+
+def open_chatgpt() -> str:
     """Open ChatGPT in new browser tab"""
     return """window.open('https://chat.openai.com/', '_blank');"""
 
-def process_pdf(pdf, fmt, ctx_size, snippet_num, prompt):
-    """Generate prompt from PDF without model processing"""
+def process_pdf(pdf, fmt, ctx_size):
+    """Process PDF and return text and snippets"""
     try:
         if not pdf:
-            return "Please upload a PDF file.", "", []
+            return "Please upload a PDF file.", "", [], None
         
         # Extract text
         text = extract_text_from_pdf(pdf.name)
         if text.startswith("Error"):
-            return text, "", []
+            return text, "", [], None
         
         # Format content
         formatted_text = format_content(text, fmt)
@@ -245,164 +304,254 @@ def process_pdf(pdf, fmt, ctx_size, snippet_num, prompt):
         # Split into snippets
         snippets = split_into_snippets(formatted_text, ctx_size)
         
-        # Build prompts
+        # Save full text for download
+        with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt') as text_file:
+            text_file.write(formatted_text)
+            
+        snippet_choices = [f"Snippet {i+1} of {len(snippets)}" for i in range(len(snippets))]
+        
+        return (
+            "PDF processed successfully!", 
+            formatted_text,
+            snippets,
+            snippet_choices,
+            [text_file.name]
+        )
+        
+    except Exception as e:
+        logging.error(f"Error processing PDF: {e}")
+        return f"Error processing PDF: {str(e)}", "", [], None
+
+def generate_prompt(text, template, snippet_idx=None):
+    """Generate prompt from text or selected snippet"""
+    try:
+        if not text:
+            return "No text available.", "", None
+            
         default_prompt = "Summarize the following text:"
-        full_prompt = build_prompts(snippets, default_prompt, prompt, snippet_num)
+        prompt_template = template if template else default_prompt
         
-        if isinstance(full_prompt, str) and full_prompt.startswith("Error"):
-            return full_prompt, "", []
+        if isinstance(text, list):
+            # If text is list of snippets
+            if snippet_idx is not None:
+                if 0 <= snippet_idx < len(text):
+                    content = text[snippet_idx]
+                else:
+                    return "Invalid snippet index.", "", None
+            else:
+                content = "\n\n".join(text)
+        else:
+            content = text
+            
+        prompt = f"{prompt_template}\n---\n{content}\n---"
         
         # Save prompt for download
         with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt') as prompt_file:
-            prompt_file.write(full_prompt)
-        
-        return "Prompt generated!", full_prompt, [prompt_file.name]
+            prompt_file.write(prompt)
+            
+        return "Prompt generated!", prompt, [prompt_file.name]
         
     except Exception as e:
-        logging.error(f"Error processing PDF: {e}")
-        return f"Error processing PDF: {str(e)}", "", []
+        logging.error(f"Error generating prompt: {e}")
+        return f"Error generating prompt: {str(e)}", "", None
+
+def download_file(content: str, prefix: str = "file") -> List[str]:
+    """Create a downloadable file with content and better error handling"""
+    if not content:
+        return []
+    try:
+        with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt', prefix=prefix) as f:
+            f.write(content)
+            return [f.name]
+    except Exception as e:
+        logging.error(f"Error creating download file: {e}")
+        return []
 
 # Main Interface
 with gr.Blocks(theme=gr.themes.Default()) as demo:
-    # Store context size value
-    context_size_value = gr.State(value=32000)
+    # State variables
+    pdf_content = gr.State("")
+    snippets = gr.State([])
     
     # Header
     gr.Markdown("# 📄 Smart PDF Summarizer")
     gr.Markdown("Upload a PDF document and get AI-powered summaries using various AI models.")
     
-    # Main Content
-    with gr.Row():
-        # Left Column - Input Options
-        with gr.Column(scale=1):
-            pdf_input = gr.File(
-                label="📁 Upload PDF",
-                file_types=[".pdf"]
-            )
-            
-            with gr.Row():
-                format_type = gr.Radio(
-                    choices=["txt", "md", "html"],
-                    value="txt",
-                    label="📝 Output Format"
-                )
-            
-            # First define the slider
-            context_size = gr.Slider(
-                minimum=1000,
-                maximum=200000,
-                step=1000,
-                value=32000,
-                label="📏 Custom Context Size"
-            )
-            
-            # Then define the context size buttons
-            gr.Markdown("### Context Size")
+    with gr.Tabs() as tabs:
+        # Tab 1: PDF Processing
+        with gr.Tab("1️⃣ PDF Processing"):
             with gr.Row():
-                for size_name, size_value in CONTEXT_SIZES.items():
-                    gr.Button(
-                        size_name, 
-                        size="sm",  # Make buttons smaller
-                        scale=1     # Equal scaling
-                    ).click(
-                        lambda v=size_value: v,
-                        None,
-                        context_size
+                with gr.Column(scale=1):
+                    pdf_input = gr.File(
+                        label="📁 Upload PDF",
+                        file_types=[".pdf"]
                     )
-                        
-            context_size = gr.Slider(
-                minimum=1000,
-                maximum=200000,
-                step=1000,
-                value=32000,
-                label="📏 Custom Context Size"
-            )
-            
-            snippet_number = gr.Number(
-                label="🔢 Snippet Number",
-                value=1,
-                precision=0
-            )
-            
-            custom_prompt = gr.Textbox(
-                label="✍️ Custom Prompt",
-                placeholder="Enter your custom prompt here...",
-                lines=2
-            )
-            
-            model_choice = gr.Radio(
-                choices=["OpenAI ChatGPT", "HuggingFace Inference", "Groq API"],
-                value="OpenAI ChatGPT",
-                label="🤖 Model Selection"
-            )
-            
-            with gr.Column(visible=False) as hf_options:
-                hf_model = gr.Dropdown(
-                    choices=list(model_registry.hf_models.keys()),
-                    label="🔧 HuggingFace Model",
-                    value="Phi-3 Mini 128k"
-                )
-                hf_custom_model = gr.Textbox(
-                    label="Custom Model ID",
-                    placeholder="Enter custom model ID...",
-                    visible=False
-                )
-                hf_api_key = gr.Textbox(
-                    label="🔑 HuggingFace API Key",
-                    type="password"
-                )
-            
-            with gr.Column(visible=False) as groq_options:
-                groq_model = gr.Dropdown(
-                    choices=list(model_registry.groq_models.keys()),
-                    label="🔧 Groq Model",
-                    value=list(model_registry.groq_models.keys())[0]
-                )
-                groq_refresh_btn = gr.Button("🔄 Refresh Models")
-                groq_api_key = gr.Textbox(
-                    label="🔑 Groq API Key",
-                    type="password"
-                )
+                    
+                    format_type = gr.Radio(
+                        choices=["txt", "md", "html"],
+                        value="txt",
+                        label="📝 Output Format"
+                    )
+                    
+                    context_size = gr.Slider(
+                        minimum=1000,
+                        maximum=200000,
+                        step=1000,
+                        value=4096,
+                        label="Context Size"
+                    )
+                    
+                    with gr.Row():
+                        for size_name, size_value in CONTEXT_SIZES.items():
+                            gr.Button(
+                                size_name, 
+                                size="sm",
+                                scale=1
+                            ).click(
+                                lambda v=size_value: v,  # Simplified
+                                None,
+                                context_size
+                            )
+                    
+                    process_button = gr.Button("🔍 Process PDF", variant="primary")
+                    
+                with gr.Column(scale=1):
+                    progress_status = gr.Textbox(
+                        label="Status",
+                        interactive=False,
+                        show_label=True,
+                        visible=True  # Ensure error messages are always visible
+                    )
+                    processed_text = gr.Textbox(
+                        label="Processed Text",
+                        lines=10,
+                        max_lines=50,
+                        show_copy_button=True
+                    )
+                    download_full_text = gr.Button("📥 Download Full Text")
 
-            # In the UI section, add OpenAI API key input:
-            with gr.Column(visible=False) as openai_options:
-                openai_api_key = gr.Textbox(
-                    label="🔑 OpenAI API Key",
-                    type="password"
+        # Tab 2: Snippet Selection
+        with gr.Tab("2️⃣ Snippet Selection"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    snippet_selector = gr.Dropdown(
+                        label="Select Snippet",
+                        choices=[],
+                        interactive=True
+                    )
+                    
+                    custom_prompt = gr.Textbox(
+                        label="✍️ Custom Prompt Template",
+                        placeholder="Enter your custom prompt here...",
+                        lines=2
+                    )
+                    
+                    generate_prompt_btn = gr.Button("Generate Prompt", variant="primary")
+                    
+                with gr.Column(scale=1):
+                    generated_prompt = gr.Textbox(
+                    label="📋 Generated Prompt",
+                    lines=10,
+                    max_lines=50,
+                    show_copy_button=True,
+                    elem_id="generated_prompt"  # Add this
                 )
-
-        # Right Column - Output
-        with gr.Column(scale=1):
-            process_button = gr.Button("🚀 Process PDF", variant="primary")
-            
-            progress_status = gr.Textbox(
-                label="📊 Progress",
-                interactive=False
-            )
-            
-            generated_prompt = gr.Textbox(
-                label="📋 Generated Prompt",
-                lines=10
-            )
-            
+                    
+                    with gr.Row():
+                        copy_prompt_button = gr.Button("📋 Copy Prompt")
+                        download_prompt = gr.Button("📥 Download Prompt")
+                        download_snippet = gr.Button("📥 Download Selected Snippet")
+
+        # Tab 3: Model Processing
+        with gr.Tab("3️⃣ Model Processing"):
             with gr.Row():
-                copy_prompt_button = gr.Button("📋 Copy Prompt")
-                open_chatgpt_button = gr.Button("🌐 Open ChatGPT")
-            
-            summary_output = gr.Textbox(
-                label="📝 Summary",
-                lines=15
-            )
+                with gr.Column(scale=1):
+                    model_choice = gr.Radio(
+                        choices=["OpenAI ChatGPT", "HuggingFace Inference", "Groq API"],
+                        value="OpenAI ChatGPT",
+                        label="🤖 Model Selection"
+                    )
+                    
+                    with gr.Column(visible=False) as openai_options:
+                        openai_api_key = gr.Textbox(
+                            label="🔑 OpenAI API Key",
+                            type="password"
+                        )
+                    
+                    with gr.Column(visible=False) as hf_options:
+                        hf_model = gr.Dropdown(
+                            choices=list(model_registry.hf_models.keys()),
+                            label="🔧 HuggingFace Model",
+                            value="Phi-3 Mini 128k"
+                        )
+                        hf_custom_model = gr.Textbox(
+                            label="Custom Model ID",
+                            visible=False
+                        )
+                        hf_api_key = gr.Textbox(
+                            label="🔑 HuggingFace API Key",
+                            type="password"
+                        )
+                    
+                    with gr.Column(visible=False) as groq_options:
+                        groq_model = gr.Dropdown(
+                            choices=list(model_registry.groq_models.keys()),
+                            label="🔧 Groq Model"
+                        )
+                        groq_refresh_btn = gr.Button("🔄 Refresh Models")
+                        groq_api_key = gr.Textbox(
+                            label="🔑 Groq API Key",
+                            type="password"
+                        )
+                    
+                    send_to_model_btn = gr.Button("🚀 Send to Model", variant="primary")
+                    open_chatgpt_button = gr.Button("🌐 Open ChatGPT")
+                    
+                with gr.Column(scale=1):
+                    summary_output = gr.Textbox(
+                        label="📝 Summary",
+                        lines=15,
+                        max_lines=50,
+                        show_copy_button=True,
+                        elem_id="summary_output"  # Add this
+                    )
+                    
+                    with gr.Row():
+                        copy_summary_button = gr.Button("📋 Copy Summary")
+                        download_summary = gr.Button("📥 Download Summary")
             
-            with gr.Row():
-                copy_summary_button = gr.Button("📋 Copy Summary")
-                download_files = gr.Files(
-                    label="📥 Download Files"
-                )
+    # Hidden components for file handling
+    download_files = gr.Files(label="📥 Downloads", visible=False)
 
     # Event Handlers
-    def update_context_size(size):
-        return gr.update(value=size)
+    def update_context_size(size: int) -> None:
+        """Update context size slider with validation"""
+        if not isinstance(size, (int, float)):
+            size = 4096  # Default size
+        return gr.update(value=int(size))
+    
+    def get_model_context_size(choice: str, groq_model: str = None) -> int:
+        """Get context size for model with better defaults"""
+        if choice == "Groq API" and groq_model:
+            return MODEL_CONTEXT_SIZES["Groq API"].get(groq_model, 4096)
+        elif choice == "OpenAI ChatGPT":
+            return 4096
+        elif choice == "HuggingFace Inference":
+            return 4096
+        return 32000  # Safe default
+    
+    def update_snippet_choices(snippets_list: List[str]) -> List[str]:
+        """Create formatted snippet choices"""
+        return [f"Snippet {i+1} of {len(snippets_list)}" for i in range(len(snippets_list))]
+
+    def get_snippet_index(choice: str) -> int:
+        """Extract snippet index from choice string"""
+        if not choice:
+            return 0
+        try:
+            return int(choice.split()[1]) - 1
+        except:
+            return 0
 
     def toggle_model_options(choice):
         return (
@@ -417,12 +566,211 @@ with gr.Blocks(theme=gr.themes.Default()) as demo:
 
     def toggle_custom_model(model_name):
         return gr.update(visible=model_name == "Custom Model")
+    
+    def handle_model_change(choice):
+        """Handle model selection change"""
+        return (
+            gr.update(visible=choice == "HuggingFace Inference"),
+            gr.update(visible=choice == "Groq API"),
+            gr.update(visible=choice == "OpenAI ChatGPT"),
+            update_context_size(choice)
+        )
+
+    def handle_groq_model_change(model_name):
+        """Handle Groq model selection change"""
+        return update_context_size("Groq API", model_name)
+
+    def handle_model_selection(choice):
+        """Handle model selection and update UI"""
+        ctx_size = get_model_context_size(choice)
+        return {
+            hf_options: gr.update(visible=choice == "HuggingFace Inference"),
+            groq_options: gr.update(visible=choice == "Groq API"),
+            openai_options: gr.update(visible=choice == "OpenAI ChatGPT"),
+            context_size: gr.update(value=ctx_size)
+        }
+    
+    # PDF Processing Handlers
+    def handle_pdf_process(pdf, fmt, ctx_size):
+        """Process PDF and update UI state"""
+        if not pdf:
+            return {
+                progress_status: "Please upload a PDF file.",
+                processed_text: "",
+                pdf_content: "",
+                snippets: [],
+                snippet_selector: gr.update(choices=[], value=None),
+                download_files: None
+            }
+            
+        try:
+            # Extract and format text
+            text = extract_text_from_pdf(pdf.name)
+            if text.startswith("Error"):
+                return {
+                    progress_status: text,
+                    processed_text: "",
+                    pdf_content: "",
+                    snippets: [],
+                    snippet_selector: gr.update(choices=[], value=None),
+                    download_files: None
+                }
+                
+            formatted_text = format_content(text, fmt)
+            snippets_list = split_into_snippets(formatted_text, ctx_size)
+            
+            # Create downloadable full text
+            with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt') as f:
+                f.write(formatted_text)
+                download_file = f.name
+                
+            return {
+                progress_status: f"PDF processed successfully! Generated {len(snippets_list)} snippets.",
+                processed_text: formatted_text,
+                pdf_content: formatted_text,
+                snippets: snippets_list,
+                snippet_selector: gr.update(choices=update_snippet_choices(snippets_list), value="Snippet 1 of " + str(len(snippets_list))),
+                download_files: [download_file]
+            }
+            
+        except Exception as e:
+            error_msg = f"Error processing PDF: {str(e)}"
+            logging.error(error_msg)
+            return {
+                progress_status: error_msg,
+                processed_text: "",
+                pdf_content: "",
+                snippets: [],
+                snippet_selector: gr.update(choices=[], value=None),
+                download_files: None
+            }
+
+    def handle_snippet_selection(choice, snippets_list):
+        """Handle snippet selection and update prompt"""
+        if not snippets_list:
+            return {
+                progress_status: "No snippets available.",
+                generated_prompt: "",
+                download_files: None
+            }
+            
+        try:
+            idx = get_snippet_index(choice)
+            selected_snippet = snippets_list[idx]
+            
+            # Create downloadable snippet
+            with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt') as f:
+                f.write(selected_snippet)
+                
+            return {
+                progress_status: f"Selected snippet {idx + 1}",
+                generated_prompt: selected_snippet,
+                download_files: [f.name]
+            }
+            
+        except Exception as e:
+            error_msg = f"Error selecting snippet: {str(e)}"
+            logging.error(error_msg)
+            return {
+                progress_status: error_msg,
+                generated_prompt: "",
+                download_files: None
+            }
+        
+    # Copy button handlers
+    def copy_text_js(element_id: str) -> str:
+        return f"""
+            () => {{
+                const text = document.querySelector('#{element_id} textarea').value;
+                navigator.clipboard.writeText(text);
+                return "Copied to clipboard!";
+            }}
+        """
+
+    def handle_prompt_generation(snippet_text, template, snippet_choice, snippets_list):
+        """Generate prompt from selected snippet"""
+        if not snippet_text or not snippets_list:
+            return {
+                progress_status: "No text available for prompt generation.",
+                generated_prompt: "",
+                download_files: None
+            }
+            
+        try:
+            idx = get_snippet_index(snippet_choice)
+            prompt = generate_prompt(snippets_list[idx], template or "Summarize the following text:")
+            
+            # Create downloadable prompt
+            with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt') as f:
+                f.write(prompt)
+                
+            return {
+                progress_status: "Prompt generated successfully!",
+                generated_prompt: prompt,
+                download_files: [f.name]
+            }
+            
+        except Exception as e:
+            error_msg = f"Error generating prompt: {str(e)}"
+            logging.error(error_msg)
+            return {
+                progress_status: error_msg,
+                generated_prompt: "",
+                download_files: None
+            }
+
+    def handle_copy_action(text):
+        """Handle copy to clipboard action"""
+        return {
+            progress_status: gr.update(value="Text copied to clipboard!", visible=True)
+        }
+
+    # Connect all event handlers
+    # Core event handlers
+    process_button.click(
+        handle_pdf_process,
+        inputs=[pdf_input, format_type, context_size],
+        outputs=dict(
+            progress_status=progress_status,
+            processed_text=processed_text,
+            pdf_content=pdf_content,
+            snippets=snippets,
+            snippet_selector=snippet_selector,
+            download_files=download_files
+        )
+    )
+
+    generate_prompt_btn.click(
+        handle_prompt_generation,
+        inputs=[generated_prompt, custom_prompt, snippet_selector, snippets],
+        outputs={
+            progress_status: progress_status,
+            generated_prompt: generated_prompt,
+            download_files: download_files
+        }
+    )
+
+    # Snippet handling
+    snippet_selector.change(
+        handle_snippet_selection,
+        inputs=[snippet_selector, snippets],
+        outputs={
+            progress_status: progress_status,
+            generated_prompt: generated_prompt,
+            download_files: download_files
+        }
+    )
 
-    # Connect event handlers
+    # Model selection
     model_choice.change(
-        toggle_model_options,
+        handle_model_selection,
         inputs=[model_choice],
-        outputs=[hf_options, groq_options, openai_options]
+        outputs={
+            hf_options: hf_options,
+            groq_options: groq_options,
+            openai_options: openai_options,
+            context_size: context_size
+        }
     )
 
     hf_model.change(
@@ -431,30 +779,58 @@ with gr.Blocks(theme=gr.themes.Default()) as demo:
         outputs=[hf_custom_model]
     )
 
-    groq_refresh_btn.click(
-        refresh_groq_models_list,
-        outputs=[groq_model]
+    groq_model.change(
+        handle_groq_model_change,
+        inputs=[groq_model],
+        outputs=[context_size]
     )
 
-    process_button.click(
-        process_pdf,
-        inputs=[
-            pdf_input,
-            format_type,
-            context_size,
-            snippet_number,
-            custom_prompt
-        ],
-        outputs=[
-            progress_status,
-            generated_prompt,
-            download_files
-        ]
+    # Context size buttons
+    """
+    for size_name, size_value in CONTEXT_SIZES.items():
+        gr.Button(size_name, size="sm").click(
+            update_context_size,
+            inputs=[],
+            outputs=context_size
+        ).success(
+            lambda s=size_value: int(s),
+            None,
+            context_size
+        ) """
+
+    # Download handlers
+    for btn, content in [
+        (download_full_text, pdf_content),
+        (download_snippet, generated_prompt),
+        (download_prompt, generated_prompt),
+        (download_summary, summary_output)
+    ]:
+        btn.click(
+            lambda x: [x] if x else None,
+            inputs=[content],
+            outputs=download_files
+        )
+
+    # Copy button handlers
+    for btn, elem_id in [
+        (copy_prompt_button, "generated_prompt"),
+        (copy_summary_button, "summary_output")
+    ]:
+        btn.click(
+            fn=None,
+            _js=copy_text_js(elem_id),
+            outputs=progress_status
+        )
+
+    # ChatGPT handler
+    open_chatgpt_button.click(
+        fn=None,
+        _js="() => { window.open('https://chat.openai.com/', '_blank'); return 'Opened ChatGPT in new tab'; }",
+        outputs=progress_status
     )
 
-    # Add a new button for sending to model
-    send_button = gr.Button("🚀 Send to Model", variant="primary")
-    send_button.click(
+    # Model processing
+    send_to_model_btn.click(
         send_to_model,
         inputs=[
             generated_prompt,
@@ -472,21 +848,9 @@ with gr.Blocks(theme=gr.themes.Default()) as demo:
         ]
     )
 
-    copy_prompt_button.click(
-        copy_to_clipboard,
-        inputs=[generated_prompt],
-        outputs=[progress_status]
-    )
-
-    copy_summary_button.click(
-        copy_to_clipboard,
-        inputs=[summary_output],
-        outputs=[progress_status]
-    )
-
-    open_chatgpt_button.click(
-        open_chatgpt,
-        outputs=[progress_status]
+    groq_refresh_btn.click(
+        refresh_groq_models_list,
+        outputs=[groq_model]
     )
 
     # Instructions