Upload folder using huggingface_hub

deep_research.py

@@ -3,11 +3,12 @@ from dotenv import load_dotenv
 from research_manager import ResearchManager
 import markdown
 import re
+from file_processor import process_file, get_file_icon, format_file_size
 
 load_dotenv(override=True)
 
 
-async def run_research(query: str, model_choice: str, conversation_history: list, progress=gr.Progress()):
+async def run_research(query: str, model_choice: str, conversation_history: list, attachments: list, progress=gr.Progress()):
     """Run research and yield updates for both report and references"""
     status_messages = []
     final_report_md = ""
@@ -39,7 +40,7 @@ async def run_research(query: str, model_choice: str, conversation_history: list
     '''
 
     # Collect all chunks and parse structured messages
-    async for chunk in ResearchManager(model_choice).run(query, conversation_history):
+    async for chunk in ResearchManager(model_choice).run(query, conversation_history, attachments):
         # Parse structured messages (format: TYPE|data)
         if "|" in chunk:
             msg_type, msg_data = chunk.split("|", 1)
@@ -254,7 +255,7 @@ def format_references_html(references):
     return html
 
 
-async def run_simple_search(query: str, model_choice: str, conversation_history: list, progress=gr.Progress()):
+async def run_simple_search(query: str, model_choice: str, conversation_history: list, attachments: list, progress=gr.Progress()):
     """Run a quick follow-up search without full research workflow"""
     progress(0, desc="🔍 Quick search starting...")
 
@@ -277,7 +278,7 @@ async def run_simple_search(query: str, model_choice: str, conversation_history:
 
     answer_text = ""
 
-    async for chunk in ResearchManager(model_choice).run_simple_search(query, conversation_history):
+    async for chunk in ResearchManager(model_choice).run_simple_search(query, conversation_history, attachments):
         # Parse structured messages
         if "|" in chunk:
             msg_type, msg_data = chunk.split("|", 1)
@@ -779,6 +780,29 @@ textarea:not(.chat-input textarea):focus {
     box-shadow: 0 0 0 2px rgba(16, 185, 129, 0.15) !important;
 }
 
+/* Attach button */
+.attach-button {
+    background: rgba(55, 55, 55, 0.4) !important;
+    border: 1px solid rgba(55, 65, 81, 0.4) !important;
+    color: #9CA3AF !important;
+    border-radius: 8px !important;
+    font-weight: 500 !important;
+    padding: 0.4rem 1.25rem !important;
+    font-size: 0.875rem !important;
+    transition: all 0.2s cubic-bezier(0.4, 0, 0.2, 1) !important;
+    box-shadow: none !important;
+    text-transform: none !important;
+    flex: 0 0 auto;
+    min-height: 0 !important;
+}
+
+.attach-button:hover {
+    background: rgba(59, 130, 246, 0.1) !important;
+    border-color: rgba(59, 130, 246, 0.4) !important;
+    color: #3B82F6 !important;
+    transform: translateY(-1px) !important;
+}
+
 /* Clear button */
 .clear-button {
     background: rgba(55, 55, 55, 0.4) !important;
@@ -802,6 +826,61 @@ textarea:not(.chat-input textarea):focus {
     transform: translateY(-1px) !important;
 }
 
+/* Attachments display area */
+.attachments-display-area {
+    margin-bottom: 0.75rem;
+    min-height: 0;
+}
+
+.attachments-container {
+    background: rgba(45, 45, 45, 0.3);
+    border: 1px solid rgba(55, 65, 81, 0.3);
+    border-radius: 8px;
+    padding: 0.75rem;
+    color: #E5E7EB;
+    font-size: 0.875rem;
+}
+
+.attachments-header {
+    color: #10B981;
+    font-weight: 600;
+    margin-bottom: 0.5rem;
+}
+
+/* Attachment badges */
+.attachment-badge {
+    display: inline-block;
+    background: rgba(16, 185, 129, 0.1);
+    border: 1px solid rgba(16, 185, 129, 0.3);
+    border-radius: 6px;
+    padding: 0.375rem 0.75rem;
+    margin: 0.25rem 0.25rem 0.25rem 0;
+    color: #10B981;
+    font-size: 0.8rem;
+    transition: all 0.2s;
+}
+
+.attachment-badge:hover {
+    background: rgba(16, 185, 129, 0.15);
+    border-color: rgba(16, 185, 129, 0.4);
+}
+
+.remove-attachment {
+    background: none;
+    border: none;
+    color: #EF4444;
+    cursor: pointer;
+    margin-left: 0.5rem;
+    font-weight: bold;
+    font-size: 0.9rem;
+    padding: 0;
+    transition: color 0.2s;
+}
+
+.remove-attachment:hover {
+    color: #DC2626;
+}
+
 /* Modern Minimal Tabs */
 .tab-nav {
     background: transparent;
@@ -1074,6 +1153,8 @@ with gr.Blocks(theme=luntre_theme, css=custom_css, title="Luntre AI - Deep Resea
     conversation_history_state = gr.State([])
     # State to track current mode: "research" or "search"
     current_mode_state = gr.State("research")
+    # State to store attachments
+    attachments_state = gr.State([])
 
     # Header
     gr.HTML("""
@@ -1099,6 +1180,19 @@ with gr.Blocks(theme=luntre_theme, css=custom_css, title="Luntre AI - Deep Resea
 
     # Input Section at the BOTTOM (chat-style)
     with gr.Group(elem_classes="input-container-bottom"):
+        # Attachments display area
+        attachments_display = gr.HTML(value="", elem_classes="attachments-display-area")
+
+        # Hidden file upload component
+        file_upload = gr.File(
+            label="Upload Files",
+            file_types=[".txt", ".md", ".pdf", ".docx", ".doc", ".xlsx", ".xls", ".csv",
+                       ".json", ".py", ".js", ".ts", ".java", ".cpp", ".html", ".log"],
+            file_count="multiple",
+            visible=False,
+            elem_id="file-upload-input"
+        )
+
         query_input = gr.Textbox(
             label="",
             placeholder="What would you like to research? (e.g., 'What are the latest developments in quantum computing?')",
@@ -1112,6 +1206,7 @@ with gr.Blocks(theme=luntre_theme, css=custom_css, title="Luntre AI - Deep Resea
         with gr.Row(elem_classes="controls-row"):
             research_mode_btn = gr.Button("Research", variant="primary", elem_classes="mode-button research-mode active-mode", elem_id="research-mode-btn")
             search_mode_btn = gr.Button("Search", variant="secondary", elem_classes="mode-button search-mode", elem_id="search-mode-btn")
+            attach_btn = gr.Button("📎 Attach", variant="secondary", elem_classes="attach-button", elem_id="attach-btn")
             clear_conv_btn = gr.Button("🗑️ Clear", variant="secondary", elem_classes="clear-button")
             model_selector = gr.Dropdown(
                 choices=[
@@ -1187,6 +1282,56 @@ with gr.Blocks(theme=luntre_theme, css=custom_css, title="Luntre AI - Deep Resea
         """Switch to search mode"""
         return "search"
 
+    def handle_file_upload(files, current_attachments):
+        """Process uploaded files and update attachments state"""
+        if not files:
+            return current_attachments, format_attachments_display(current_attachments)
+
+        # Handle single file or list of files
+        if not isinstance(files, list):
+            files = [files]
+
+        for file in files:
+            if file is not None:
+                # Process the file
+                file_data = process_file(file.name)
+                if file_data:
+                    current_attachments.append(file_data)
+
+        display_html = format_attachments_display(current_attachments)
+        return current_attachments, display_html
+
+    def format_attachments_display(attachments):
+        """Generate HTML for attachment badges"""
+        if not attachments:
+            return ""
+
+        html = '<div class="attachments-container">'
+        html += f'<div class="attachments-header">📎 Attached Files ({len(attachments)})</div>'
+
+        for idx, att in enumerate(attachments):
+            size_str = format_file_size(att['size_bytes'])
+            icon = get_file_icon(att['file_type'])
+            html += f'''
+            <span class="attachment-badge" id="attachment-{idx}">
+                {icon} {att['filename']} ({size_str})
+                <button class="remove-attachment" onclick="document.getElementById('remove-att-{idx}').click();">✕</button>
+            </span>
+            '''
+
+        html += '</div>'
+        return html
+
+    def remove_attachment(attachments, idx):
+        """Remove attachment at given index"""
+        if 0 <= idx < len(attachments):
+            attachments.pop(idx)
+        return attachments, format_attachments_display(attachments)
+
+    def clear_attachments():
+        """Clear all attachments"""
+        return [], ""
+
     # Mode switching - Research button
     research_mode_btn.click(
         fn=switch_to_research_mode,
@@ -1221,6 +1366,33 @@ with gr.Blocks(theme=luntre_theme, css=custom_css, title="Luntre AI - Deep Resea
         """
     )
 
+    # Attach button - trigger file upload dialog
+    attach_btn.click(
+        fn=None,
+        inputs=[],
+        outputs=[],
+        js="""
+        () => {
+            // Trigger the hidden file input
+            const fileInput = document.getElementById('file-upload-input');
+            if (fileInput) {
+                const actualInput = fileInput.querySelector('input[type="file"]');
+                if (actualInput) {
+                    actualInput.click();
+                }
+            }
+        }
+        """
+    )
+
+    # File upload handler
+    file_upload.change(
+        fn=handle_file_upload,
+        inputs=[file_upload, attachments_state],
+        outputs=[attachments_state, attachments_display],
+        queue=False
+    )
+
     # Edit and rerun
     edit_event = edit_btn.click(
         fn=load_query_for_edit,
@@ -1232,24 +1404,26 @@ with gr.Blocks(theme=luntre_theme, css=custom_css, title="Luntre AI - Deep Resea
     # Rewrite (run again with same query)
     rewrite_event = rewrite_btn.click(
         fn=run_research,
-        inputs=[current_query_state, model_selector, conversation_history_state],
+        inputs=[current_query_state, model_selector, conversation_history_state, attachments_state],
         outputs=[report_output, references_output]
     )
 
     # Clear conversation
     def reset_conversation():
-        """Reset conversation and display welcome message"""
+        """Reset conversation, display welcome message, and clear attachments"""
         return (
-            [],
-            "<div class='welcome-message'>Welcome! Enter your research query below to get started.</div>",
-            "<div class='no-references'>No references yet. Run a research query to see sources.</div>",
-            "research"  # Reset to research mode
+            [],  # conversation_history
+            "<div class='welcome-message'>Welcome! Enter your research query below to get started.</div>",  # report_output
+            "<div class='no-references'>No references yet. Run a research query to see sources.</div>",  # references_output
+            "research",  # current_mode
+            [],  # attachments
+            ""  # attachments_display
         )
 
     clear_conv_event = clear_conv_btn.click(
         fn=reset_conversation,
         inputs=[],
-        outputs=[conversation_history_state, report_output, references_output, current_mode_state],
+        outputs=[conversation_history_state, report_output, references_output, current_mode_state, attachments_state, attachments_display],
         queue=False,
         js="""
         () => {
@@ -1267,12 +1441,12 @@ with gr.Blocks(theme=luntre_theme, css=custom_css, title="Luntre AI - Deep Resea
     # Store the event handler reference
     submit_event_state = gr.State(None)
 
-    def run_based_on_mode(query, model, history, mode):
+    def run_based_on_mode(query, model, history, attachments, mode):
         """Wrapper to route to correct function based on mode"""
         if mode == "research":
-            return run_research(query, model, history)
+            return run_research(query, model, history, attachments)
         else:
-            return run_simple_search(query, model, history)
+            return run_simple_search(query, model, history, attachments)
 
     query_input.submit(
         fn=update_query_state,
@@ -1291,7 +1465,7 @@ with gr.Blocks(theme=luntre_theme, css=custom_css, title="Luntre AI - Deep Resea
         queue=False
     ).then(
         fn=run_based_on_mode,
-        inputs=[current_query_state, model_selector, conversation_history_state, current_mode_state],
+        inputs=[current_query_state, model_selector, conversation_history_state, attachments_state, current_mode_state],
         outputs=[report_output, references_output]
     ).then(
         fn=lambda mode: "search" if mode == "research" else mode,

file_processor.py

@@ -0,0 +1,254 @@
+"""
+File processor for attachment feature
+Supports: txt, md, py, js, json, csv, pdf, docx, xlsx
+"""
+
+import os
+from typing import Dict, Optional
+import datetime
+
+
+def process_file(file_path: str) -> Optional[Dict]:
+    """
+    Extract text content from uploaded file
+
+    Args:
+        file_path: Path to the uploaded file
+
+    Returns:
+        Dictionary with file metadata and content, or None if processing failed
+    """
+    try:
+        filename = os.path.basename(file_path)
+        file_size = os.path.getsize(file_path)
+        file_ext = os.path.splitext(filename)[1].lower()
+
+        # Process based on file type
+        content = extract_content(file_path, file_ext)
+
+        if content is None:
+            return None
+
+        # Truncate if too large (keep first 20,000 chars for context)
+        original_length = len(content)
+        max_chars = 20000
+
+        if original_length > max_chars:
+            content = content[:max_chars]
+            content += f"\n\n[📏 Content truncated - original file was {original_length:,} characters, showing first {max_chars:,}]"
+
+        return {
+            "filename": filename,
+            "content": content,
+            "size_bytes": file_size,
+            "file_type": file_ext[1:],  # Remove the dot
+            "uploaded_at": datetime.datetime.now().isoformat(),
+            "char_count": len(content)
+        }
+
+    except Exception as e:
+        print(f"Error processing file {file_path}: {str(e)}")
+        return None
+
+
+def extract_content(file_path: str, file_ext: str) -> Optional[str]:
+    """Extract text content based on file extension"""
+
+    # Plain text files
+    if file_ext in ['.txt', '.md', '.log', '.json', '.html', '.xml', '.css', '.sql']:
+        return read_text_file(file_path)
+
+    # Code files
+    elif file_ext in ['.py', '.js', '.ts', '.jsx', '.tsx', '.java', '.cpp', '.c', '.h',
+                      '.cs', '.php', '.rb', '.go', '.rs', '.swift', '.kt', '.sh', '.yml', '.yaml']:
+        return read_text_file(file_path)
+
+    # CSV files
+    elif file_ext == '.csv':
+        return read_csv_file(file_path)
+
+    # PDF files
+    elif file_ext == '.pdf':
+        return read_pdf_file(file_path)
+
+    # Word documents
+    elif file_ext in ['.docx', '.doc']:
+        return read_docx_file(file_path)
+
+    # Excel files
+    elif file_ext in ['.xlsx', '.xls']:
+        return read_excel_file(file_path)
+
+    else:
+        return f"[❌ Unsupported file type: {file_ext}]"
+
+
+def read_text_file(file_path: str) -> Optional[str]:
+    """Read plain text file with multiple encoding attempts"""
+    encodings = ['utf-8', 'utf-16', 'latin-1', 'cp1252']
+
+    for encoding in encodings:
+        try:
+            with open(file_path, 'r', encoding=encoding) as f:
+                return f.read()
+        except UnicodeDecodeError:
+            continue
+        except Exception as e:
+            print(f"Error reading text file with {encoding}: {e}")
+            continue
+
+    return "[❌ Could not decode text file - unsupported encoding]"
+
+
+def read_csv_file(file_path: str) -> Optional[str]:
+    """Read CSV file and convert to formatted text"""
+    try:
+        import csv
+
+        with open(file_path, 'r', encoding='utf-8', newline='') as f:
+            reader = csv.reader(f)
+            rows = list(reader)
+
+            if not rows:
+                return "[Empty CSV file]"
+
+            # Format as text with column alignment
+            output = []
+            output.append(f"CSV Data ({len(rows)} rows):\n")
+            output.append("=" * 50)
+
+            # Header
+            if rows:
+                output.append(" | ".join(rows[0]))
+                output.append("-" * 50)
+
+            # Data rows (limit to first 100 rows for context)
+            for row in rows[1:101]:
+                output.append(" | ".join(str(cell) for cell in row))
+
+            if len(rows) > 101:
+                output.append(f"\n[... {len(rows) - 101} more rows]")
+
+            return "\n".join(output)
+
+    except Exception as e:
+        return f"[❌ Error reading CSV: {str(e)}]"
+
+
+def read_pdf_file(file_path: str) -> Optional[str]:
+    """Extract text from PDF file"""
+    try:
+        import pdfplumber
+
+        with pdfplumber.open(file_path) as pdf:
+            pages_text = []
+
+            for i, page in enumerate(pdf.pages[:50]):  # Limit to first 50 pages
+                text = page.extract_text()
+                if text:
+                    pages_text.append(f"--- Page {i + 1} ---\n{text}")
+
+            if len(pdf.pages) > 50:
+                pages_text.append(f"\n[... {len(pdf.pages) - 50} more pages not shown]")
+
+            content = "\n\n".join(pages_text)
+
+            if not content.strip():
+                return "[❌ PDF appears to be empty or contains only images]"
+
+            return content
+
+    except ImportError:
+        return "[❌ pdfplumber not installed - run: pip install pdfplumber]"
+    except Exception as e:
+        return f"[❌ Error reading PDF: {str(e)}]"
+
+
+def read_docx_file(file_path: str) -> Optional[str]:
+    """Extract text from Word document"""
+    try:
+        from docx import Document
+
+        doc = Document(file_path)
+        paragraphs = []
+
+        for para in doc.paragraphs:
+            if para.text.strip():
+                paragraphs.append(para.text)
+
+        # Also extract text from tables
+        for table in doc.tables:
+            for row in table.rows:
+                row_text = " | ".join(cell.text.strip() for cell in row.cells)
+                if row_text.strip():
+                    paragraphs.append(row_text)
+
+        content = "\n\n".join(paragraphs)
+
+        if not content.strip():
+            return "[❌ Word document appears to be empty]"
+
+        return content
+
+    except ImportError:
+        return "[❌ python-docx not installed - run: pip install python-docx]"
+    except Exception as e:
+        return f"[❌ Error reading Word document: {str(e)}]"
+
+
+def read_excel_file(file_path: str) -> Optional[str]:
+    """Extract text from Excel file"""
+    try:
+        import pandas as pd
+
+        # Read all sheets
+        excel_file = pd.ExcelFile(file_path)
+        output = []
+
+        output.append(f"Excel File - {len(excel_file.sheet_names)} sheet(s)\n")
+        output.append("=" * 50)
+
+        for sheet_name in excel_file.sheet_names:
+            df = pd.read_excel(file_path, sheet_name=sheet_name)
+
+            output.append(f"\n📊 Sheet: {sheet_name}")
+            output.append(f"Dimensions: {df.shape[0]} rows × {df.shape[1]} columns")
+            output.append("-" * 50)
+
+            # Convert to string representation (limit rows)
+            if len(df) > 50:
+                output.append(df.head(50).to_string(index=False))
+                output.append(f"\n[... {len(df) - 50} more rows]")
+            else:
+                output.append(df.to_string(index=False))
+
+            output.append("\n")
+
+        return "\n".join(output)
+
+    except ImportError:
+        return "[❌ pandas/openpyxl not installed - run: pip install pandas openpyxl]"
+    except Exception as e:
+        return f"[❌ Error reading Excel file: {str(e)}]"
+
+
+def get_file_icon(file_type: str) -> str:
+    """Return emoji icon for file type"""
+    icons = {
+        'txt': '📄', 'md': '📝', 'pdf': '📕', 'doc': '📘', 'docx': '📘',
+        'xls': '📊', 'xlsx': '📊', 'csv': '📊',
+        'json': '📋', 'xml': '📋', 'html': '🌐',
+        'py': '🐍', 'js': '📜', 'ts': '📜', 'java': '☕', 'cpp': '⚙️',
+        'log': '📋', 'sql': '🗄️', 'yml': '⚙️', 'yaml': '⚙️'
+    }
+    return icons.get(file_type, '📎')
+
+
+def format_file_size(size_bytes: int) -> str:
+    """Format file size in human-readable format"""
+    if size_bytes < 1024:
+        return f"{size_bytes} B"
+    elif size_bytes < 1024 * 1024:
+        return f"{size_bytes / 1024:.1f} KB"
+    else:
+        return f"{size_bytes / (1024 * 1024):.1f} MB"

requirements.txt

@@ -6,3 +6,9 @@ sendgrid
 requests
 openai
 markdown
+
+# Attachment feature dependencies
+pdfplumber>=0.10.0
+python-docx>=1.0.0
+openpyxl>=3.1.0
+pandas>=2.0.0

research_manager.py

@@ -42,39 +42,69 @@ class ResearchManager:
         # Record this request
         self.request_times.append(current_time)
 
-    def format_conversation_history(self, conversation_history: list) -> str:
-        """Format conversation history for context injection into agent prompts"""
-        if not conversation_history:
+    def format_attachments_context(self, attachments: list) -> str:
+        """Format attachments for context injection into agent prompts"""
+        if not attachments:
             return ""
 
-        formatted = "\n\n=== PREVIOUS CONVERSATION HISTORY ===\n\n"
-        for idx, turn in enumerate(conversation_history, 1):
-            if turn.get("type") == "query":
-                formatted += f"--- Previous Query {idx} ---\n{turn['content']}\n\n"
-            elif turn.get("type") in ["report", "simple_search"]:
-                # Truncate long reports to first 1000 chars to save context
-                content = turn['content']
-                if len(content) > 2000:
-                    content = content[:2000] + "\n... [Report truncated for context] ..."
-                formatted += f"--- Previous {'Report' if turn['type'] == 'report' else 'Answer'} {idx} ---\n{content}\n\n"
-
-        formatted += "=== END OF PREVIOUS CONVERSATION ===\n\n"
+        formatted = "\n\n=== ATTACHED DOCUMENTS ===\n\n"
+        formatted += f"The user has attached {len(attachments)} document(s) for context:\n\n"
+
+        for idx, att in enumerate(attachments, 1):
+            formatted += f"📎 Document {idx}: {att['filename']} ({att['file_type'].upper()} file, {att.get('char_count', 0):,} characters)\n"
+            formatted += f"Content:\n{att['content']}\n\n"
+            formatted += "---\n\n"
+
+        formatted += "=== END ATTACHED DOCUMENTS ===\n\n"
+        formatted += "IMPORTANT: Use the attached documents as primary reference material when answering the user's query.\n\n"
+
+        return formatted
+
+    def format_conversation_history(self, conversation_history: list, attachments: list = None) -> str:
+        """Format conversation history + attachments for context injection into agent prompts"""
+        formatted = ""
+
+        # Add attachments first (at the top of context)
+        if attachments:
+            formatted += self.format_attachments_context(attachments)
+
+        # Then add conversation history
+        if conversation_history:
+            formatted += "\n=== PREVIOUS CONVERSATION HISTORY ===\n\n"
+            for idx, turn in enumerate(conversation_history, 1):
+                if turn.get("type") == "query":
+                    formatted += f"--- Previous Query {idx} ---\n{turn['content']}\n\n"
+                elif turn.get("type") in ["report", "simple_search"]:
+                    # Truncate long reports to first 2000 chars to save context
+                    content = turn['content']
+                    if len(content) > 2000:
+                        content = content[:2000] + "\n... [Report truncated for context] ..."
+                    formatted += f"--- Previous {'Report' if turn['type'] == 'report' else 'Answer'} {idx} ---\n{content}\n\n"
+
+            formatted += "=== END OF PREVIOUS CONVERSATION ===\n\n"
+
         return formatted
 
-    async def run(self, query: str, conversation_history: list = None):
+    async def run(self, query: str, conversation_history: list = None, attachments: list = None):
         """ Run the deep research process, yielding the status updates and the final report"""
         if conversation_history is None:
             conversation_history = []
+        if attachments is None:
+            attachments = []
 
         trace_id = gen_trace_id()
         model_display = get_model_display_name(self.model_choice)
 
         with trace("Research trace", trace_id=trace_id):
             print(f"Using Brave Search API and {model_display}")
-            yield f"INIT|Using Brave Search API and {model_display}"
+            if attachments:
+                print(f"With {len(attachments)} attached document(s)")
+                yield f"INIT|Using Brave Search API and {model_display} (with {len(attachments)} attachment(s))"
+            else:
+                yield f"INIT|Using Brave Search API and {model_display}"
             print("Starting research...")
 
-            search_plan = await self.plan_searches(query, conversation_history)
+            search_plan = await self.plan_searches(query, conversation_history, attachments)
             num_searches = len(search_plan.searches)
             yield f"PLANNING_COMPLETE|{num_searches}"
 
@@ -90,7 +120,7 @@ class ResearchManager:
             yield "SEARCH_COMPLETE|All searches finished"
 
             yield "WRITING_START|Starting to write report..."
-            report = await self.write_report(query, results, conversation_history)
+            report = await self.write_report(query, results, conversation_history, attachments)
             print(f"DEBUG: Report object created, markdown_report length: {len(report.markdown_report)}")
 
             # Yield the report BEFORE sending email
@@ -101,10 +131,12 @@ class ResearchManager:
             yield "COMPLETE|Research complete"
         
 
-    async def plan_searches(self, query: str, conversation_history: list = None) -> WebSearchPlan:
+    async def plan_searches(self, query: str, conversation_history: list = None, attachments: list = None) -> WebSearchPlan:
         """ Plan the searches to perform for the query """
         if conversation_history is None:
             conversation_history = []
+        if attachments is None:
+            attachments = []
 
         print("Planning searches...")
         await self.wait_for_rate_limit()
@@ -118,8 +150,8 @@ class ResearchManager:
             output_type=WebSearchPlan,
         )
 
-        # Format the input with conversation history if available
-        context = self.format_conversation_history(conversation_history)
+        # Format the input with conversation history and attachments if available
+        context = self.format_conversation_history(conversation_history, attachments)
         input_text = f"{context}Current Query: {query}"
 
         result = await Runner.run(
@@ -179,15 +211,17 @@ class ResearchManager:
                     return None
         return None
 
-    async def write_report(self, query: str, search_results: list[str], conversation_history: list = None) -> ReportData:
+    async def write_report(self, query: str, search_results: list[str], conversation_history: list = None, attachments: list = None) -> ReportData:
         """ Write the report for the query with retry logic """
         if conversation_history is None:
             conversation_history = []
+        if attachments is None:
+            attachments = []
 
         print("Thinking about report...")
 
-        # Format the input with conversation history if available
-        context = self.format_conversation_history(conversation_history)
+        # Format the input with conversation history and attachments if available
+        context = self.format_conversation_history(conversation_history, attachments)
         input = f"{context}Current Query: {query}\n\nNew Search Results: {search_results}"
 
         # Create writer with selected model
@@ -263,19 +297,25 @@ class ResearchManager:
                     print(f"Email sending failed: {str(e)}")
                     return report
 
-    async def run_simple_search(self, query: str, conversation_history: list = None):
+    async def run_simple_search(self, query: str, conversation_history: list = None, attachments: list = None):
         """Run a quick follow-up search without full research workflow"""
         if conversation_history is None:
             conversation_history = []
+        if attachments is None:
+            attachments = []
 
         print("Running simple search...")
-        yield "SIMPLE_SEARCH_START|Starting quick search..."
+        if attachments:
+            print(f"With {len(attachments)} attached document(s)")
+            yield f"SIMPLE_SEARCH_START|Starting quick search (with {len(attachments)} attachment(s))..."
+        else:
+            yield "SIMPLE_SEARCH_START|Starting quick search..."
 
         # Import simple search agent
         from simple_search_agent import simple_search_agent
 
-        # Format conversation history for context
-        context = self.format_conversation_history(conversation_history)
+        # Format conversation history and attachments for context
+        context = self.format_conversation_history(conversation_history, attachments)
         input_text = f"{context}Current Question: {query}"
 
         try: