Add application file

.env

@@ -0,0 +1,41 @@
+# Application Settings
+FLASK_DEBUG=true
+FLASK_SECRET_KEY=your-secret-key-here
+UPLOAD_FOLDER=output
+
+# AI Provider Selection (options: g4f, openai, huggingface, together)
+AI_PROVIDER=openai
+
+# OpenAI Configuration
+OPENAI_API_KEY=your-openai-api-key-here
+OPENAI_ORG_ID=your-organization-id-if-applicable
+OPENAI_BASE_URL=https://christian-heidie-randai-0573d5c0.koyeb.app/v1  # Change for Azure/LocalAI/other proxies
+OPENAI_MAX_TOKENS=1000
+OPENAI_TEMPERATURE=0.7
+
+# HuggingFace Configuration
+HUGGINGFACE_API_KEY=your-hf-api-key-here
+HUGGINGFACE_API_URL=https://api-inference.huggingface.co/models
+HUGGINGFACE_MAX_TOKENS=1000
+HUGGINGFACE_TEMPERATURE=0.7
+
+# Together AI Configuration
+TOGETHER_API_KEY=your-together-api-key-here
+TOGETHER_API_URL=https://api.together.xyz/v1/completions
+TOGETHER_MAX_TOKENS=1000
+TOGETHER_TEMPERATURE=0.7
+
+# g4f Configuration (usually doesn't need API keys)
+G4F_PROXY=  # Optional proxy URL if needed
+
+# Pandoc Configuration (for Word document conversion)
+PANDOC_PATH=pandoc  # Path to pandoc if not in system PATH
+REFERENCE_DOCX=reference.docx  # Path to custom reference Word template
+
+# Rate Limiting (optional)
+MAX_RETRIES=3
+INITIAL_DELAY=1
+BACKOFF_FACTOR=2
+
+# Caching Settings
+MODEL_CACHE_TTL=3600  # 1 hour cache for model lists

app.py

@@ -1,565 +1,18 @@
-from flask import Flask, render_template, request, jsonify, send_from_directory, Response, copy_current_request_context
-import g4f
-import os
-import subprocess
-from datetime import datetime
-from typing import List, Tuple
-import uuid
-from werkzeug.utils import secure_filename
-import json
-import time
-from functools import wraps
-
-app = Flask(__name__)
-app.config['UPLOAD_FOLDER'] = 'output'
-
-from functools import wraps
-import time
-import random
-
-def retry(max_retries=3, initial_delay=1, backoff_factor=2):
-    def decorator(func):
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            retries = 0
-            delay = initial_delay
-            
-            while retries < max_retries:
-                try:
-                    return func(*args, **kwargs)
-                except (SystemExit, KeyboardInterrupt):
-                    raise
-                except Exception as e:
-                    retries += 1
-                    if retries >= max_retries:
-                        raise  # Re-raise the last exception if max retries reached
-                    
-                    # Exponential backoff with some randomness
-                    time.sleep(delay + random.uniform(0, 0.5))
-                    delay *= backoff_factor
-        return wrapper
-    return decorator
-# Initialize output directory
-os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
-
-def get_available_models() -> List[str]:
-    """Get list of available models from g4f"""
-    try:
-        models = sorted(g4f.models._all_models)
-        # Ensure gpt-4o is first if available
-        if 'gpt-4o' in models:
-            models.remove('gpt-4o')
-            models.insert(0, 'gpt-4o')
-        return models
-    except Exception:
-        return ['gpt-4o', 'gpt-4', 'gpt-3.5-turbo', 'llama2-70b', 'claude-2']
+from flask import Flask
+from config import Config
+from routes.api import api_bp
+from routes.views import views_bp
+
+def create_app():
+    app = Flask(__name__)
+    app.config.from_object(Config)
     
-def generate_filename() -> Tuple[str, str]:
-    """Generate filenames with unique ID"""
-    unique_id = str(uuid.uuid4())[:8]
-    md_filename = f"research_paper_{unique_id}.md"
-    docx_filename = f"research_paper_{unique_id}.docx"
-    return md_filename, docx_filename
-
-def generate_index_content(model: str, research_subject: str, manual_chapters: List[str] = None) -> str:
-    """Generate index content for the research paper"""
-    try:
-        if manual_chapters:
-            prompt = f"Generate a detailed index/table of contents for a research paper about {research_subject} with these chapters: " + \
-                    ", ".join(manual_chapters) + ". Include section headings in markdown format."
-        else:
-            prompt = f"Generate a detailed index/table of contents for a research paper about {research_subject}. Include chapter titles and section headings in markdown format."
-        
-        response = g4f.ChatCompletion.create(
-            model=model,
-            messages=[{"role": "user", "content": prompt}],
-        )
-        return str(response) if response else "[Empty response from model]"
-    except Exception as e:
-        raise Exception(f"Failed to generate index: {str(e)}")
-
-def extract_chapters(index_content: str) -> List[str]:
-    """Extract chapter titles from index content"""
-    chapters = []
-    for line in index_content.split('\n'):
-        if line.strip().startswith('## '):
-            chapter_title = line.strip()[3:].strip()
-            if chapter_title.lower() not in ['introduction', 'conclusion', 'references']:
-                chapters.append(chapter_title)
-    return chapters if chapters else ["Literature Review", "Methodology", "Results and Discussion"]
-
-def generate_automatic_sections(model: str, research_subject: str) -> List[Tuple[str, str]]:
-    """Generate sections automatically based on AI-generated index"""
-    try:
-        index_content = generate_index_content(model, research_subject)
-        chapters = extract_chapters(index_content)
-        
-        sections = [
-            ("Index", index_content),
-            ("Introduction", f"Write a comprehensive introduction for a research paper about {research_subject}. Include background information, research objectives, and significance of the study.")
-        ]
-        
-        for i, chapter in enumerate(chapters, 1):
-            sections.append(
-                (f"Chapter {i}: {chapter}", 
-                 f"Write a detailed chapter about '{chapter}' for a research paper about {research_subject}. "
-                 f"Provide comprehensive coverage of this aspect, including relevant theories, examples, and analysis.")
-            )
-        
-        sections.append(
-            ("Conclusion", f"Write a conclusion section for a research paper about {research_subject}. Summarize key findings, discuss implications, and suggest future research directions.")
-        )
-        
-        return sections
-    except Exception as e:
-        raise Exception(f"Failed to generate automatic structure: {str(e)}")
-
-def get_manual_sections(research_subject: str) -> List[Tuple[str, str]]:
-    """Get predefined manual sections"""
-    return [
-        ("Index", "[Index will be generated first]"),
-        ("Introduction", f"Write a comprehensive introduction for a research paper about {research_subject}."),
-        ("Chapter 1: Literature Review", f"Create a detailed literature review chapter about {research_subject}."),
-        ("Chapter 2: Methodology", f"Describe the research methodology for a study about {research_subject}."),
-        ("Chapter 3: Results and Discussion", f"Present hypothetical results and discussion for a research paper about {research_subject}. Analyze findings and compare with existing literature."),
-        ("Conclusion", f"Write a conclusion section for a research paper about {research_subject}.")
-    ]
-
-@retry(max_retries=3, initial_delay=1, backoff_factor=2)
-def generate_section_content(model: str, prompt: str) -> str:
-    """Generate content for a single section with retry logic"""
-    try:
-        response = g4f.ChatCompletion.create(
-            model=model,
-            messages=[{"role": "user", "content": prompt}],
-            stream=False  # Disable streaming to avoid async issues
-        )
-        return str(response) if response else "[Empty response from model]"
-    except Exception as e:
-        raise Exception(f"Failed to generate section content: {str(e)}")
-
-def write_research_paper(md_filename: str, research_subject: str, sections: List[Tuple[str, str]], model: str) -> None:
-    """Write the research paper to a markdown file"""
-    full_path = os.path.join(app.config['UPLOAD_FOLDER'], md_filename)
-    with open(full_path, "w", encoding="utf-8") as f:
-        f.write(f"# Research Paper: {research_subject}\n\n")
-        
-        for section_title, prompt in sections:
-            try:
-                if isinstance(prompt, str) and (prompt.startswith("##") or prompt.startswith("#")):
-                    content = f"{prompt}\n\n"
-                else:
-                    response = generate_section_content(model, prompt)
-                    content = f"## {section_title}\n\n{response}\n\n"
-                f.write(content)
-            except Exception as e:
-                f.write(f"## {section_title}\n\n[Error generating this section: {str(e)}]\n\n")
-
-def convert_to_word(md_filename: str, docx_filename: str) -> None:
-    """Convert markdown file to Word document using Pandoc"""
-    md_path = os.path.join(app.config['UPLOAD_FOLDER'], md_filename)
-    docx_path = os.path.join(app.config['UPLOAD_FOLDER'], docx_filename)
-    
-    command = [
-        "pandoc", md_path,
-        "-o", docx_path,
-        "--standalone",
-        "--table-of-contents",
-        "--toc-depth=3"
-    ]
-    
-    if os.path.exists("reference.docx"):
-        command.extend(["--reference-doc", "reference.docx"])
+    # Register blueprints
+    app.register_blueprint(views_bp)
+    app.register_blueprint(api_bp, url_prefix='/api')
     
-    subprocess.run(command, check=True)
-
-@app.route('/')
-def index():
-    models = get_available_models()
-    return render_template('index.html', models=models)
-
-def sse_stream_required(f):
-    """Decorator to ensure SSE stream has request context"""
-    @wraps(f)
-    def decorated(*args, **kwargs):
-        @copy_current_request_context
-        def generator():
-            return f(*args, **kwargs)
-        return generator()
-    return decorated
-
-@app.route('/stream')
-@sse_stream_required
-def stream():
-    research_subject = request.args.get('subject', '').strip()
-    selected_model = request.args.get('model', 'gpt-4o')
-    structure_type = request.args.get('structure', 'automatic')
-
-    def generate():
-        try:
-            if not research_subject:
-                yield "data: " + json.dumps({"error": "Research subject is required"}) + "\n\n"
-                return
-            
-            # Generate filenames
-            md_filename, docx_filename = generate_filename()
-            
-            # Initial steps
-            steps = [
-                {"id": 0, "text": "Preparing document structure...", "status": "pending"},
-                {"id": 1, "text": "Generating index/table of contents...", "status": "pending"},
-                {"id": 2, "text": "Determining chapters...", "status": "pending"},
-                {"id": 3, "text": "Writing content...", "status": "pending", "subSteps": []},
-                {"id": 4, "text": "Finalizing document...", "status": "pending"},
-                {"id": 5, "text": "Converting to Word format...", "status": "pending"}
-            ]
-            
-            # Initial progress update
-            yield "data: " + json.dumps({"steps": steps, "progress": 0}) + "\n\n"
-            
-            # Step 0: Prepare
-            steps[0]["status"] = "in-progress"
-            yield "data: " + json.dumps({
-                "steps": steps,
-                "progress": 0,
-                "current_step": 0
-            }) + "\n\n"
-            
-            sections = []
-            chapter_steps = []
-            
-            if structure_type == 'automatic':
-                try:
-                    # Step 1: Generate index
-                    steps[1]["status"] = "in-progress"
-                    yield "data: " + json.dumps({
-                        "steps": steps,
-                        "progress": 10,
-                        "current_step": 1
-                    }) + "\n\n"
-                    
-                    index_content = generate_index_content(selected_model, research_subject)
-                    sections.append(("Index", index_content))
-                    
-                    steps[1]["status"] = "complete"
-                    yield "data: " + json.dumps({
-                        "steps": steps,
-                        "progress": 20,
-                        "current_step": 1
-                    }) + "\n\n"
-                    
-                    # Step 2: Determine chapters
-                    steps[2]["status"] = "in-progress"
-                    yield "data: " + json.dumps({
-                        "steps": steps,
-                        "progress": 30,
-                        "current_step": 2
-                    }) + "\n\n"
-                    
-                    chapters = extract_chapters(index_content)
-                    
-                    # Create sub-steps for each chapter with initial timing info
-                    chapter_substeps = [
-                        {
-                            "id": f"chapter_{i}", 
-                            "text": chapter, 
-                            "status": "pending",
-                            "start_time": None,
-                            "duration": None
-                        }
-                        for i, chapter in enumerate(chapters)
-                    ]
-                    
-                    steps[3]["subSteps"] = chapter_substeps
-                    
-                    steps[2]["status"] = "complete"
-                    yield "data: " + json.dumps({
-                        "steps": steps,
-                        "progress": 40,
-                        "current_step": 2,
-                        "update_steps": True
-                    }) + "\n\n"
-                    
-                    # Add introduction and conclusion
-                    sections.append((
-                        "Introduction", 
-                        f"Write a comprehensive introduction for a research paper about {research_subject}."
-                    ))
-                    
-                    for i, chapter in enumerate(chapters, 1):
-                        sections.append((
-                            f"Chapter {i}: {chapter}", 
-                            f"Write a detailed chapter about '{chapter}' for a research paper about {research_subject}."
-                        ))
-                    
-                    sections.append((
-                        "Conclusion",
-                        f"Write a conclusion section for a research paper about {research_subject}."
-                    ))
-                    
-                    # Generate content for each chapter with timing
-                    for i, chapter in enumerate(chapters):
-                        # Update chapter start time
-                        steps[3]["subSteps"][i]["start_time"] = time.time()
-                        steps[3]["subSteps"][i]["status"] = "in-progress"
-                        
-                        yield "data: " + json.dumps({
-                            "steps": steps,
-                            "progress": 40 + (i * 50 / len(chapters)),
-                            "current_step": 3,
-                            "chapter_progress": {
-                                "current": i + 1,
-                                "total": len(chapters),
-                                "chapter": chapter,
-                                "percent": ((i + 1) / len(chapters)) * 100
-                            }
-                        }) + "\n\n"
-                        
-                        try:
-                            response = generate_section_content(
-                                selected_model,
-                                f"Write a detailed chapter about '{chapter}' for a research paper about {research_subject}."
-                            )
-                            
-                            # Calculate and store duration
-                            duration = time.time() - steps[3]["subSteps"][i]["start_time"]
-                            steps[3]["subSteps"][i]["duration"] = f"{duration:.1f}s"
-                            steps[3]["subSteps"][i]["status"] = "complete"
-                            
-                            yield "data: " + json.dumps({
-                                "steps": steps,
-                                "progress": 40 + ((i + 1) * 50 / len(chapters)),
-                                "current_step": 3,
-                                "chapter_progress": {
-                                    "current": i + 1,
-                                    "total": len(chapters),
-                                    "chapter": chapter,
-                                    "percent": ((i + 1) / len(chapters)) * 100,
-                                    "duration": f"{duration:.1f}s"
-                                }
-                            }) + "\n\n"
-                        except Exception as e:
-                            duration = time.time() - steps[3]["subSteps"][i]["start_time"]
-                            steps[3]["subSteps"][i]["duration"] = f"{duration:.1f}s"
-                            steps[3]["subSteps"][i]["status"] = "error"
-                            steps[3]["subSteps"][i]["message"] = str(e)
-                            
-                            yield "data: " + json.dumps({
-                                "steps": steps,
-                                "progress": 40 + ((i + 1) * 50 / len(chapters)),
-                                "current_step": 3,
-                                "warning": f"Failed to generate chapter {i+1} after retries",
-                                "chapter_progress": {
-                                    "current": i + 1,
-                                    "total": len(chapters),
-                                    "chapter": chapter,
-                                    "percent": ((i + 1) / len(chapters)) * 100,
-                                    "error": str(e)
-                                }
-                            }) + "\n\n"
-                    
-                    steps[3]["status"] = "complete"
-                    yield "data: " + json.dumps({
-                        "steps": steps,
-                        "progress": 90,
-                        "current_step": 3,
-                        "chapter_progress": {
-                            "complete": True,
-                            "total_chapters": len(chapters)
-                        }
-                    }) + "\n\n"
-                    
-                except Exception as e:
-                    steps[1]["status"] = "error"
-                    steps[1]["message"] = str(e)
-                    yield "data: " + json.dumps({
-                        "steps": steps,
-                        "progress": 20,
-                        "current_step": 1
-                    }) + "\n\n"
-                    
-                    # Fallback to manual structure
-                    sections = get_manual_sections(research_subject)
-                    steps[1]["message"] = "Falling back to manual structure"
-                    yield "data: " + json.dumps({
-                        "steps": steps,
-                        "progress": 20,
-                        "current_step": 1
-                    }) + "\n\n"
-                    
-                    try:
-                        index_content = generate_index_content(selected_model, research_subject, [s[0] for s in sections[1:]])
-                        sections[0] = ("Index", index_content)
-                        
-                        steps[1]["status"] = "complete"
-                        yield "data: " + json.dumps({
-                            "steps": steps,
-                            "progress": 25,
-                            "current_step": 1
-                        }) + "\n\n"
-                    except Exception as e:
-                        steps[1]["status"] = "error"
-                        steps[1]["message"] = str(e)
-                        yield "data: " + json.dumps({
-                            "steps": steps,
-                            "progress": 20,
-                            "current_step": 1,
-                            "error": "Failed to generate even fallback content"
-                        }) + "\n\n"
-                        return
-            else:
-                sections = get_manual_sections(research_subject)
-                steps[1]["status"] = "in-progress"
-                yield "data: " + json.dumps({
-                    "steps": steps,
-                    "progress": 10,
-                    "current_step": 1
-                }) + "\n\n"
-                
-                try:
-                    index_content = generate_index_content(selected_model, research_subject, [s[0] for s in sections[1:]])
-                    sections[0] = ("Index", index_content)
-                    
-                    steps[1]["status"] = "complete"
-                    yield "data: " + json.dumps({
-                        "steps": steps,
-                        "progress": 20,
-                        "current_step": 1
-                    }) + "\n\n"
-                except Exception as e:
-                    steps[1]["status"] = "error"
-                    steps[1]["message"] = str(e)
-                    yield "data: " + json.dumps({
-                        "steps": steps,
-                        "progress": 20,
-                        "current_step": 1,
-                        "error": "Failed to generate manual index"
-                    }) + "\n\n"
-                    return
-            
-            # Write introduction
-            steps[3]["status"] = "in-progress"
-            yield "data: " + json.dumps({
-                "steps": steps,
-                "progress": 40,
-                "current_step": 3
-            }) + "\n\n"
-            
-            try:
-                introduction_content = generate_section_content(
-                    selected_model,
-                    f"Write a comprehensive introduction for a research paper about {research_subject}."
-                )
-                
-                steps[3]["status"] = "complete"
-                yield "data: " + json.dumps({
-                    "steps": steps,
-                    "progress": 60,
-                    "current_step": 3
-                }) + "\n\n"
-            except Exception as e:
-                steps[3]["status"] = "error"
-                steps[3]["message"] = str(e)
-                yield "data: " + json.dumps({
-                    "steps": steps,
-                    "progress": 60,
-                    "current_step": 3,
-                    "warning": "Failed to generate introduction after retries"
-                }) + "\n\n"
-            
-            # Write conclusion
-            steps[4]["status"] = "in-progress"
-            yield "data: " + json.dumps({
-                "steps": steps,
-                "progress": 80,
-                "current_step": 4
-            }) + "\n\n"
-            
-            try:
-                conclusion_content = generate_section_content(
-                    selected_model,
-                    f"Write a conclusion section for a research paper about {research_subject}."
-                )
-                
-                steps[4]["status"] = "complete"
-                yield "data: " + json.dumps({
-                    "steps": steps,
-                    "progress": 90,
-                    "current_step": 4
-                }) + "\n\n"
-            except Exception as e:
-                steps[4]["status"] = "error"
-                steps[4]["message"] = str(e)
-                yield "data: " + json.dumps({
-                    "steps": steps,
-                    "progress": 90,
-                    "current_step": 4,
-                    "warning": "Failed to generate conclusion after retries"
-                }) + "\n\n"
-            
-            # Write the complete paper
-            full_path = os.path.join(app.config['UPLOAD_FOLDER'], md_filename)
-            with open(full_path, "w", encoding="utf-8") as f:
-                f.write(f"# Research Paper: {research_subject}\n\n")
-                
-                for section_title, prompt in sections:
-                    try:
-                        if isinstance(prompt, str) and (prompt.startswith("##") or prompt.startswith("#")):
-                            content = f"{prompt}\n\n"
-                        else:
-                            try:
-                                response = generate_section_content(selected_model, prompt)
-                                content = f"## {section_title}\n\n{response}\n\n"
-                            except Exception as e:
-                                content = f"## {section_title}\n\n[Error generating this section: {str(e)}]\n\n"
-                        f.write(content)
-                    except Exception as e:
-                        f.write(f"## {section_title}\n\n[Error generating this section: {str(e)}]\n\n")
-            
-            # Convert to Word
-            steps[5]["status"] = "in-progress"
-            yield "data: " + json.dumps({
-                "steps": steps,
-                "progress": 95,
-                "current_step": 5
-            }) + "\n\n"
-            
-            try:
-                convert_to_word(md_filename, docx_filename)
-                steps[5]["status"] = "complete"
-                yield "data: " + json.dumps({
-                    "steps": steps,
-                    "progress": 100,
-                    "current_step": 5,
-                    "status": "complete",
-                    "docx_file": docx_filename,
-                    "md_file": md_filename
-                }) + "\n\n"
-            except Exception as e:
-                steps[5]["status"] = "error"
-                steps[5]["message"] = str(e)
-                yield "data: " + json.dumps({
-                    "steps": steps,
-                    "progress": 100,
-                    "current_step": 5,
-                    "status": "partial_success",
-                    "message": f'Paper generated but Word conversion failed: {str(e)}',
-                    "md_file": md_filename
-                }) + "\n\n"
-            
-        except Exception as e:
-            yield "data: " + json.dumps({"error": f"Failed to generate paper: {str(e)}"}) + "\n\n"
-    
-    return Response(generate(), mimetype="text/event-stream")
-
-@app.route('/download/<filename>')
-def download(filename):
-    safe_filename = secure_filename(filename)
-    return send_from_directory(
-        app.config['UPLOAD_FOLDER'],
-        safe_filename,
-        as_attachment=True
-    )
+    return app
 
 if __name__ == '__main__':
+    app = create_app()
     app.run(debug=True)

config.py

@@ -0,0 +1,35 @@
+import os
+
+class Config:
+    UPLOAD_FOLDER = 'output'
+    SECRET_KEY = os.environ.get('SECRET_KEY') or 'dev-key-123'
+    MAX_RETRIES = 3
+    INITIAL_DELAY = 1
+    BACKOFF_FACTOR = 2
+    AI_PROVIDER = os.getenv('AI_PROVIDER', 'g4f')  # Options: g4f, huggingface, together, openai
+    
+    AI_PROVIDER_CONFIG = {
+        'g4f': {
+            # g4f specific configuration
+        },
+        'huggingface': {
+            'api_key': os.getenv('HUGGINGFACE_API_KEY'),
+            'max_tokens': 1000,
+            'temperature': 0.7
+        },
+        'together': {
+            'api_key': os.getenv('TOGETHER_API_KEY'),
+            'max_tokens': 1000,
+            'temperature': 0.7
+        },
+         'openai': {
+            'api_key': os.getenv('OPENAI_API_KEY'),
+            'organization': os.getenv('OPENAI_ORG_ID'),
+            'base_url': os.getenv('OPENAI_BASE_URL', "https://api.openai.com/v1"),  # Default OpenAI endpoint
+            'max_tokens': 1000,
+            'temperature': 0.7,
+            'top_p': 0.9,
+            'frequency_penalty': 0,
+            'presence_penalty': 0
+        }
+    }

d.sh

@@ -0,0 +1,3 @@
+git add .
+git commit -m "Add application file"
+git push

etc/app.py

@@ -0,0 +1,584 @@
+from flask import Flask
+from config import Config
+from routes.api import api_bp
+from routes.views import views_bp
+
+def create_app():
+    app = Flask(__name__)
+    app.config.from_object(Config)
+    
+    # Register blueprints
+    app.register_blueprint(views_bp)
+    app.register_blueprint(api_bp, url_prefix='/api')
+    
+    return app
+
+if __name__ == '__main__':
+    app = create_app()
+    app.run(debug=True)
+
+from flask import Flask, render_template, request, jsonify, send_from_directory, Response, copy_current_request_context
+import g4f
+import os
+import subprocess
+from datetime import datetime
+from typing import List, Tuple
+import uuid
+from werkzeug.utils import secure_filename
+import json
+import time
+from functools import wraps
+
+app = Flask(__name__)
+app.config['UPLOAD_FOLDER'] = 'output'
+
+from functools import wraps
+import time
+import random
+
+def retry(max_retries=3, initial_delay=1, backoff_factor=2):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            retries = 0
+            delay = initial_delay
+            
+            while retries < max_retries:
+                try:
+                    return func(*args, **kwargs)
+                except (SystemExit, KeyboardInterrupt):
+                    raise
+                except Exception as e:
+                    retries += 1
+                    if retries >= max_retries:
+                        raise  # Re-raise the last exception if max retries reached
+                    
+                    # Exponential backoff with some randomness
+                    time.sleep(delay + random.uniform(0, 0.5))
+                    delay *= backoff_factor
+        return wrapper
+    return decorator
+# Initialize output directory
+os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
+
+def get_available_models() -> List[str]:
+    """Get list of available models from g4f"""
+    try:
+        models = sorted(g4f.models._all_models)
+        # Ensure gpt-4o is first if available
+        if 'gpt-4o' in models:
+            models.remove('gpt-4o')
+            models.insert(0, 'gpt-4o')
+        return models
+    except Exception:
+        return ['gpt-4o', 'gpt-4', 'gpt-3.5-turbo', 'llama2-70b', 'claude-2']
+    
+def generate_filename() -> Tuple[str, str]:
+    """Generate filenames with unique ID"""
+    unique_id = str(uuid.uuid4())[:8]
+    md_filename = f"research_paper_{unique_id}.md"
+    docx_filename = f"research_paper_{unique_id}.docx"
+    return md_filename, docx_filename
+
+def generate_index_content(model: str, research_subject: str, manual_chapters: List[str] = None) -> str:
+    """Generate index content for the research paper"""
+    try:
+        if manual_chapters:
+            prompt = f"Generate a detailed index/table of contents for a research paper about {research_subject} with these chapters: " + \
+                    ", ".join(manual_chapters) + ". Include section headings in markdown format."
+        else:
+            prompt = f"Generate a detailed index/table of contents for a research paper about {research_subject}. Include chapter titles and section headings in markdown format."
+        
+        response = g4f.ChatCompletion.create(
+            model=model,
+            messages=[{"role": "user", "content": prompt}],
+        )
+        return str(response) if response else "[Empty response from model]"
+    except Exception as e:
+        raise Exception(f"Failed to generate index: {str(e)}")
+
+def extract_chapters(index_content: str) -> List[str]:
+    """Extract chapter titles from index content"""
+    chapters = []
+    for line in index_content.split('\n'):
+        if line.strip().startswith('## '):
+            chapter_title = line.strip()[3:].strip()
+            if chapter_title.lower() not in ['introduction', 'conclusion', 'references']:
+                chapters.append(chapter_title)
+    return chapters if chapters else ["Literature Review", "Methodology", "Results and Discussion"]
+
+def generate_automatic_sections(model: str, research_subject: str) -> List[Tuple[str, str]]:
+    """Generate sections automatically based on AI-generated index"""
+    try:
+        index_content = generate_index_content(model, research_subject)
+        chapters = extract_chapters(index_content)
+        
+        sections = [
+            ("Index", index_content),
+            ("Introduction", f"Write a comprehensive introduction for a research paper about {research_subject}. Include background information, research objectives, and significance of the study.")
+        ]
+        
+        for i, chapter in enumerate(chapters, 1):
+            sections.append(
+                (f"Chapter {i}: {chapter}", 
+                 f"Write a detailed chapter about '{chapter}' for a research paper about {research_subject}. "
+                 f"Provide comprehensive coverage of this aspect, including relevant theories, examples, and analysis.")
+            )
+        
+        sections.append(
+            ("Conclusion", f"Write a conclusion section for a research paper about {research_subject}. Summarize key findings, discuss implications, and suggest future research directions.")
+        )
+        
+        return sections
+    except Exception as e:
+        raise Exception(f"Failed to generate automatic structure: {str(e)}")
+
+def get_manual_sections(research_subject: str) -> List[Tuple[str, str]]:
+    """Get predefined manual sections"""
+    return [
+        ("Index", "[Index will be generated first]"),
+        ("Introduction", f"Write a comprehensive introduction for a research paper about {research_subject}."),
+        ("Chapter 1: Literature Review", f"Create a detailed literature review chapter about {research_subject}."),
+        ("Chapter 2: Methodology", f"Describe the research methodology for a study about {research_subject}."),
+        ("Chapter 3: Results and Discussion", f"Present hypothetical results and discussion for a research paper about {research_subject}. Analyze findings and compare with existing literature."),
+        ("Conclusion", f"Write a conclusion section for a research paper about {research_subject}.")
+    ]
+
+@retry(max_retries=3, initial_delay=1, backoff_factor=2)
+def generate_section_content(model: str, prompt: str) -> str:
+    """Generate content for a single section with retry logic"""
+    try:
+        response = g4f.ChatCompletion.create(
+            model=model,
+            messages=[{"role": "user", "content": prompt}],
+            stream=False  # Disable streaming to avoid async issues
+        )
+        return str(response) if response else "[Empty response from model]"
+    except Exception as e:
+        raise Exception(f"Failed to generate section content: {str(e)}")
+
+def write_research_paper(md_filename: str, research_subject: str, sections: List[Tuple[str, str]], model: str) -> None:
+    """Write the research paper to a markdown file"""
+    full_path = os.path.join(app.config['UPLOAD_FOLDER'], md_filename)
+    with open(full_path, "w", encoding="utf-8") as f:
+        f.write(f"# Research Paper: {research_subject}\n\n")
+        
+        for section_title, prompt in sections:
+            try:
+                if isinstance(prompt, str) and (prompt.startswith("##") or prompt.startswith("#")):
+                    content = f"{prompt}\n\n"
+                else:
+                    response = generate_section_content(model, prompt)
+                    content = f"## {section_title}\n\n{response}\n\n"
+                f.write(content)
+            except Exception as e:
+                f.write(f"## {section_title}\n\n[Error generating this section: {str(e)}]\n\n")
+
+def convert_to_word(md_filename: str, docx_filename: str) -> None:
+    """Convert markdown file to Word document using Pandoc"""
+    md_path = os.path.join(app.config['UPLOAD_FOLDER'], md_filename)
+    docx_path = os.path.join(app.config['UPLOAD_FOLDER'], docx_filename)
+    
+    command = [
+        "pandoc", md_path,
+        "-o", docx_path,
+        "--standalone",
+        "--table-of-contents",
+        "--toc-depth=3"
+    ]
+    
+    if os.path.exists("reference.docx"):
+        command.extend(["--reference-doc", "reference.docx"])
+    
+    subprocess.run(command, check=True)
+
+@app.route('/')
+def index():
+    models = get_available_models()
+    return render_template('index.html', models=models)
+
+def sse_stream_required(f):
+    """Decorator to ensure SSE stream has request context"""
+    @wraps(f)
+    def decorated(*args, **kwargs):
+        @copy_current_request_context
+        def generator():
+            return f(*args, **kwargs)
+        return generator()
+    return decorated
+
+@app.route('/stream')
+@sse_stream_required
+def stream():
+    research_subject = request.args.get('subject', '').strip()
+    selected_model = request.args.get('model', 'gpt-4o')
+    structure_type = request.args.get('structure', 'automatic')
+
+    def generate():
+        try:
+            if not research_subject:
+                yield "data: " + json.dumps({"error": "Research subject is required"}) + "\n\n"
+                return
+            
+            # Generate filenames
+            md_filename, docx_filename = generate_filename()
+            
+            # Initial steps
+            steps = [
+                {"id": 0, "text": "Preparing document structure...", "status": "pending"},
+                {"id": 1, "text": "Generating index/table of contents...", "status": "pending"},
+                {"id": 2, "text": "Determining chapters...", "status": "pending"},
+                {"id": 3, "text": "Writing content...", "status": "pending", "subSteps": []},
+                {"id": 4, "text": "Finalizing document...", "status": "pending"},
+                {"id": 5, "text": "Converting to Word format...", "status": "pending"}
+            ]
+            
+            # Initial progress update
+            yield "data: " + json.dumps({"steps": steps, "progress": 0}) + "\n\n"
+            
+            # Step 0: Prepare
+            steps[0]["status"] = "in-progress"
+            yield "data: " + json.dumps({
+                "steps": steps,
+                "progress": 0,
+                "current_step": 0
+            }) + "\n\n"
+            
+            sections = []
+            chapter_steps = []
+            
+            if structure_type == 'automatic':
+                try:
+                    # Step 1: Generate index
+                    steps[1]["status"] = "in-progress"
+                    yield "data: " + json.dumps({
+                        "steps": steps,
+                        "progress": 10,
+                        "current_step": 1
+                    }) + "\n\n"
+                    
+                    index_content = generate_index_content(selected_model, research_subject)
+                    sections.append(("Index", index_content))
+                    
+                    steps[1]["status"] = "complete"
+                    yield "data: " + json.dumps({
+                        "steps": steps,
+                        "progress": 20,
+                        "current_step": 1
+                    }) + "\n\n"
+                    
+                    # Step 2: Determine chapters
+                    steps[2]["status"] = "in-progress"
+                    yield "data: " + json.dumps({
+                        "steps": steps,
+                        "progress": 30,
+                        "current_step": 2
+                    }) + "\n\n"
+                    
+                    chapters = extract_chapters(index_content)
+                    
+                    # Create sub-steps for each chapter with initial timing info
+                    chapter_substeps = [
+                        {
+                            "id": f"chapter_{i}", 
+                            "text": chapter, 
+                            "status": "pending",
+                            "start_time": None,
+                            "duration": None
+                        }
+                        for i, chapter in enumerate(chapters)
+                    ]
+                    
+                    steps[3]["subSteps"] = chapter_substeps
+                    
+                    steps[2]["status"] = "complete"
+                    yield "data: " + json.dumps({
+                        "steps": steps,
+                        "progress": 40,
+                        "current_step": 2,
+                        "update_steps": True
+                    }) + "\n\n"
+                    
+                    # Add introduction and conclusion
+                    sections.append((
+                        "Introduction", 
+                        f"Write a comprehensive introduction for a research paper about {research_subject}."
+                    ))
+                    
+                    for i, chapter in enumerate(chapters, 1):
+                        sections.append((
+                            f"Chapter {i}: {chapter}", 
+                            f"Write a detailed chapter about '{chapter}' for a research paper about {research_subject}."
+                        ))
+                    
+                    sections.append((
+                        "Conclusion",
+                        f"Write a conclusion section for a research paper about {research_subject}."
+                    ))
+                    
+                    # Generate content for each chapter with timing
+                    for i, chapter in enumerate(chapters):
+                        # Update chapter start time
+                        steps[3]["subSteps"][i]["start_time"] = time.time()
+                        steps[3]["subSteps"][i]["status"] = "in-progress"
+                        
+                        yield "data: " + json.dumps({
+                            "steps": steps,
+                            "progress": 40 + (i * 50 / len(chapters)),
+                            "current_step": 3,
+                            "chapter_progress": {
+                                "current": i + 1,
+                                "total": len(chapters),
+                                "chapter": chapter,
+                                "percent": ((i + 1) / len(chapters)) * 100
+                            }
+                        }) + "\n\n"
+                        
+                        try:
+                            response = generate_section_content(
+                                selected_model,
+                                f"Write a detailed chapter about '{chapter}' for a research paper about {research_subject}."
+                            )
+                            
+                            # Calculate and store duration
+                            duration = time.time() - steps[3]["subSteps"][i]["start_time"]
+                            steps[3]["subSteps"][i]["duration"] = f"{duration:.1f}s"
+                            steps[3]["subSteps"][i]["status"] = "complete"
+                            
+                            yield "data: " + json.dumps({
+                                "steps": steps,
+                                "progress": 40 + ((i + 1) * 50 / len(chapters)),
+                                "current_step": 3,
+                                "chapter_progress": {
+                                    "current": i + 1,
+                                    "total": len(chapters),
+                                    "chapter": chapter,
+                                    "percent": ((i + 1) / len(chapters)) * 100,
+                                    "duration": f"{duration:.1f}s"
+                                }
+                            }) + "\n\n"
+                        except Exception as e:
+                            duration = time.time() - steps[3]["subSteps"][i]["start_time"]
+                            steps[3]["subSteps"][i]["duration"] = f"{duration:.1f}s"
+                            steps[3]["subSteps"][i]["status"] = "error"
+                            steps[3]["subSteps"][i]["message"] = str(e)
+                            
+                            yield "data: " + json.dumps({
+                                "steps": steps,
+                                "progress": 40 + ((i + 1) * 50 / len(chapters)),
+                                "current_step": 3,
+                                "warning": f"Failed to generate chapter {i+1} after retries",
+                                "chapter_progress": {
+                                    "current": i + 1,
+                                    "total": len(chapters),
+                                    "chapter": chapter,
+                                    "percent": ((i + 1) / len(chapters)) * 100,
+                                    "error": str(e)
+                                }
+                            }) + "\n\n"
+                    
+                    steps[3]["status"] = "complete"
+                    yield "data: " + json.dumps({
+                        "steps": steps,
+                        "progress": 90,
+                        "current_step": 3,
+                        "chapter_progress": {
+                            "complete": True,
+                            "total_chapters": len(chapters)
+                        }
+                    }) + "\n\n"
+                    
+                except Exception as e:
+                    steps[1]["status"] = "error"
+                    steps[1]["message"] = str(e)
+                    yield "data: " + json.dumps({
+                        "steps": steps,
+                        "progress": 20,
+                        "current_step": 1
+                    }) + "\n\n"
+                    
+                    # Fallback to manual structure
+                    sections = get_manual_sections(research_subject)
+                    steps[1]["message"] = "Falling back to manual structure"
+                    yield "data: " + json.dumps({
+                        "steps": steps,
+                        "progress": 20,
+                        "current_step": 1
+                    }) + "\n\n"
+                    
+                    try:
+                        index_content = generate_index_content(selected_model, research_subject, [s[0] for s in sections[1:]])
+                        sections[0] = ("Index", index_content)
+                        
+                        steps[1]["status"] = "complete"
+                        yield "data: " + json.dumps({
+                            "steps": steps,
+                            "progress": 25,
+                            "current_step": 1
+                        }) + "\n\n"
+                    except Exception as e:
+                        steps[1]["status"] = "error"
+                        steps[1]["message"] = str(e)
+                        yield "data: " + json.dumps({
+                            "steps": steps,
+                            "progress": 20,
+                            "current_step": 1,
+                            "error": "Failed to generate even fallback content"
+                        }) + "\n\n"
+                        return
+            else:
+                sections = get_manual_sections(research_subject)
+                steps[1]["status"] = "in-progress"
+                yield "data: " + json.dumps({
+                    "steps": steps,
+                    "progress": 10,
+                    "current_step": 1
+                }) + "\n\n"
+                
+                try:
+                    index_content = generate_index_content(selected_model, research_subject, [s[0] for s in sections[1:]])
+                    sections[0] = ("Index", index_content)
+                    
+                    steps[1]["status"] = "complete"
+                    yield "data: " + json.dumps({
+                        "steps": steps,
+                        "progress": 20,
+                        "current_step": 1
+                    }) + "\n\n"
+                except Exception as e:
+                    steps[1]["status"] = "error"
+                    steps[1]["message"] = str(e)
+                    yield "data: " + json.dumps({
+                        "steps": steps,
+                        "progress": 20,
+                        "current_step": 1,
+                        "error": "Failed to generate manual index"
+                    }) + "\n\n"
+                    return
+            
+            # Write introduction
+            steps[3]["status"] = "in-progress"
+            yield "data: " + json.dumps({
+                "steps": steps,
+                "progress": 40,
+                "current_step": 3
+            }) + "\n\n"
+            
+            try:
+                introduction_content = generate_section_content(
+                    selected_model,
+                    f"Write a comprehensive introduction for a research paper about {research_subject}."
+                )
+                
+                steps[3]["status"] = "complete"
+                yield "data: " + json.dumps({
+                    "steps": steps,
+                    "progress": 60,
+                    "current_step": 3
+                }) + "\n\n"
+            except Exception as e:
+                steps[3]["status"] = "error"
+                steps[3]["message"] = str(e)
+                yield "data: " + json.dumps({
+                    "steps": steps,
+                    "progress": 60,
+                    "current_step": 3,
+                    "warning": "Failed to generate introduction after retries"
+                }) + "\n\n"
+            
+            # Write conclusion
+            steps[4]["status"] = "in-progress"
+            yield "data: " + json.dumps({
+                "steps": steps,
+                "progress": 80,
+                "current_step": 4
+            }) + "\n\n"
+            
+            try:
+                conclusion_content = generate_section_content(
+                    selected_model,
+                    f"Write a conclusion section for a research paper about {research_subject}."
+                )
+                
+                steps[4]["status"] = "complete"
+                yield "data: " + json.dumps({
+                    "steps": steps,
+                    "progress": 90,
+                    "current_step": 4
+                }) + "\n\n"
+            except Exception as e:
+                steps[4]["status"] = "error"
+                steps[4]["message"] = str(e)
+                yield "data: " + json.dumps({
+                    "steps": steps,
+                    "progress": 90,
+                    "current_step": 4,
+                    "warning": "Failed to generate conclusion after retries"
+                }) + "\n\n"
+            
+            # Write the complete paper
+            full_path = os.path.join(app.config['UPLOAD_FOLDER'], md_filename)
+            with open(full_path, "w", encoding="utf-8") as f:
+                f.write(f"# Research Paper: {research_subject}\n\n")
+                
+                for section_title, prompt in sections:
+                    try:
+                        if isinstance(prompt, str) and (prompt.startswith("##") or prompt.startswith("#")):
+                            content = f"{prompt}\n\n"
+                        else:
+                            try:
+                                response = generate_section_content(selected_model, prompt)
+                                content = f"## {section_title}\n\n{response}\n\n"
+                            except Exception as e:
+                                content = f"## {section_title}\n\n[Error generating this section: {str(e)}]\n\n"
+                        f.write(content)
+                    except Exception as e:
+                        f.write(f"## {section_title}\n\n[Error generating this section: {str(e)}]\n\n")
+            
+            # Convert to Word
+            steps[5]["status"] = "in-progress"
+            yield "data: " + json.dumps({
+                "steps": steps,
+                "progress": 95,
+                "current_step": 5
+            }) + "\n\n"
+            
+            try:
+                convert_to_word(md_filename, docx_filename)
+                steps[5]["status"] = "complete"
+                yield "data: " + json.dumps({
+                    "steps": steps,
+                    "progress": 100,
+                    "current_step": 5,
+                    "status": "complete",
+                    "docx_file": docx_filename,
+                    "md_file": md_filename
+                }) + "\n\n"
+            except Exception as e:
+                steps[5]["status"] = "error"
+                steps[5]["message"] = str(e)
+                yield "data: " + json.dumps({
+                    "steps": steps,
+                    "progress": 100,
+                    "current_step": 5,
+                    "status": "partial_success",
+                    "message": f'Paper generated but Word conversion failed: {str(e)}',
+                    "md_file": md_filename
+                }) + "\n\n"
+            
+        except Exception as e:
+            yield "data: " + json.dumps({"error": f"Failed to generate paper: {str(e)}"}) + "\n\n"
+    
+    return Response(generate(), mimetype="text/event-stream")
+
+@app.route('/download/<filename>')
+def download(filename):
+    safe_filename = secure_filename(filename)
+    return send_from_directory(
+        app.config['UPLOAD_FOLDER'],
+        safe_filename,
+        as_attachment=True
+    )
+
+if __name__ == '__main__':
+    app.run(debug=True)

routes/api.py

@@ -0,0 +1,453 @@
+from typing import List, Tuple
+from flask import Blueprint, jsonify, request, Response, send_from_directory, copy_current_request_context
+from functools import wraps
+import time
+import json
+import os
+import uuid
+import random
+from werkzeug.utils import secure_filename
+from services.model_provider import ModelProvider
+from services.document_generator import DocumentGenerator
+from config import Config
+from utils.retry_decorator import retry
+
+api_bp = Blueprint('api', __name__)
+model_provider = ModelProvider()
+doc_generator = DocumentGenerator(Config.UPLOAD_FOLDER)
+
+def sse_stream_required(f):
+    """Decorator to ensure SSE stream has request context"""
+    @wraps(f)
+    def decorated(*args, **kwargs):
+        @copy_current_request_context
+        def generator():
+            return f(*args, **kwargs)
+        return generator()
+    return decorated
+
+def extract_chapters(index_content: str) -> List[str]:
+    """Extract chapter titles from index content"""
+    chapters = []
+    for line in index_content.split('\n'):
+        if line.strip().startswith('## '):
+            chapter_title = line.strip()[3:].strip()
+            if chapter_title.lower() not in ['introduction', 'conclusion', 'references']:
+                chapters.append(chapter_title)
+    return chapters if chapters else ["Literature Review", "Methodology", "Results and Discussion"]
+
+def generate_automatic_sections(model: str, research_subject: str) -> List[Tuple[str, str]]:
+    """Generate sections automatically based on AI-generated index"""
+    try:
+        index_content = model_provider.generate_index_content(model, research_subject)
+        chapters = extract_chapters(index_content)
+        
+        sections = [
+            ("Index", index_content),
+            ("Introduction", f"Write a comprehensive introduction for a research paper about {research_subject}. Include background information, research objectives, and significance of the study.")
+        ]
+        
+        for i, chapter in enumerate(chapters, 1):
+            sections.append(
+                (f"Chapter {i}: {chapter}", 
+                 f"Write a detailed chapter about '{chapter}' for a research paper about {research_subject}. "
+                 f"Provide comprehensive coverage of this aspect, including relevant theories, examples, and analysis.")
+            )
+        
+        sections.append(
+            ("Conclusion", f"Write a conclusion section for a research paper about {research_subject}. Summarize key findings, discuss implications, and suggest future research directions.")
+        )
+        
+        return sections
+    except Exception as e:
+        raise Exception(f"Failed to generate automatic structure: {str(e)}")
+
+def get_manual_sections(research_subject: str) -> List[Tuple[str, str]]:
+    """Get predefined manual sections"""
+    return [
+        ("Index", "[Index will be generated first]"),
+        ("Introduction", f"Write a comprehensive introduction for a research paper about {research_subject}."),
+        ("Chapter 1: Literature Review", f"Create a detailed literature review chapter about {research_subject}."),
+        ("Chapter 2: Methodology", f"Describe the research methodology for a study about {research_subject}."),
+        ("Chapter 3: Results and Discussion", f"Present hypothetical results and discussion for a research paper about {research_subject}. Analyze findings and compare with existing literature."),
+        ("Conclusion", f"Write a conclusion section for a research paper about {research_subject}.")
+    ]
+
+def write_research_paper(md_filename: str, research_subject: str, sections: List[Tuple[str, str]], model: str) -> None:
+    """Write the research paper to a markdown file"""
+    full_path = os.path.join(Config.UPLOAD_FOLDER, md_filename)
+    with open(full_path, "w", encoding="utf-8") as f:
+        f.write(f"# Research Paper: {research_subject}\n\n")
+        
+        for section_title, prompt in sections:
+            try:
+                if isinstance(prompt, str) and (prompt.startswith("##") or prompt.startswith("#")):
+                    content = f"{prompt}\n\n"
+                else:
+                    response = model_provider.generate_content(model, prompt)
+                    content = f"## {section_title}\n\n{response}\n\n"
+                f.write(content)
+            except Exception as e:
+                f.write(f"## {section_title}\n\n[Error generating this section: {str(e)}]\n\n")
+
+@api_bp.route('/models')
+def get_models():
+    models = model_provider.get_available_models()
+    return jsonify(models)
+
+@api_bp.route('/stream')
+@sse_stream_required
+def stream():
+    research_subject = request.args.get('subject', '').strip()
+    selected_model = request.args.get('model', 'gpt-4o')
+    structure_type = request.args.get('structure', 'automatic')
+
+    def generate():
+        try:
+            if not research_subject:
+                yield "data: " + json.dumps({"error": "Research subject is required"}) + "\n\n"
+                return
+            
+            # Generate filenames
+            md_filename, docx_filename = doc_generator.generate_filename()
+            
+            # Initial steps
+            steps = [
+                {"id": 0, "text": "Preparing document structure...", "status": "pending"},
+                {"id": 1, "text": "Generating index/table of contents...", "status": "pending"},
+                {"id": 2, "text": "Determining chapters...", "status": "pending"},
+                {"id": 3, "text": "Writing content...", "status": "pending", "subSteps": []},
+                {"id": 4, "text": "Finalizing document...", "status": "pending"},
+                {"id": 5, "text": "Converting to Word format...", "status": "pending"}
+            ]
+            
+            # Initial progress update
+            yield "data: " + json.dumps({"steps": steps, "progress": 0}) + "\n\n"
+            
+            # Step 0: Prepare
+            steps[0]["status"] = "in-progress"
+            yield "data: " + json.dumps({
+                "steps": steps,
+                "progress": 0,
+                "current_step": 0
+            }) + "\n\n"
+            
+            sections = []
+            chapter_steps = []
+            
+            if structure_type == 'automatic':
+                try:
+                    # Step 1: Generate index
+                    steps[1]["status"] = "in-progress"
+                    yield "data: " + json.dumps({
+                        "steps": steps,
+                        "progress": 10,
+                        "current_step": 1
+                    }) + "\n\n"
+                    
+                    index_content = model_provider.generate_index_content(selected_model, research_subject)
+                    sections.append(("Index", index_content))
+                    
+                    steps[1]["status"] = "complete"
+                    yield "data: " + json.dumps({
+                        "steps": steps,
+                        "progress": 20,
+                        "current_step": 1
+                    }) + "\n\n"
+                    
+                    # Step 2: Determine chapters
+                    steps[2]["status"] = "in-progress"
+                    yield "data: " + json.dumps({
+                        "steps": steps,
+                        "progress": 30,
+                        "current_step": 2
+                    }) + "\n\n"
+                    
+                    chapters = extract_chapters(index_content)
+                    
+                    # Create sub-steps for each chapter with initial timing info
+                    chapter_substeps = [
+                        {
+                            "id": f"chapter_{i}", 
+                            "text": chapter, 
+                            "status": "pending",
+                            "start_time": None,
+                            "duration": None
+                        }
+                        for i, chapter in enumerate(chapters)
+                    ]
+                    
+                    steps[3]["subSteps"] = chapter_substeps
+                    
+                    steps[2]["status"] = "complete"
+                    yield "data: " + json.dumps({
+                        "steps": steps,
+                        "progress": 40,
+                        "current_step": 2,
+                        "update_steps": True
+                    }) + "\n\n"
+                    
+                    # Add introduction and conclusion
+                    sections.append((
+                        "Introduction", 
+                        f"Write a comprehensive introduction for a research paper about {research_subject}."
+                    ))
+                    
+                    for i, chapter in enumerate(chapters, 1):
+                        sections.append((
+                            f"Chapter {i}: {chapter}", 
+                            f"Write a detailed chapter about '{chapter}' for a research paper about {research_subject}."
+                        ))
+                    
+                    sections.append((
+                        "Conclusion",
+                        f"Write a conclusion section for a research paper about {research_subject}."
+                    ))
+                    
+                    # Generate content for each chapter with timing
+                    for i, chapter in enumerate(chapters):
+                        # Update chapter start time
+                        steps[3]["subSteps"][i]["start_time"] = time.time()
+                        steps[3]["subSteps"][i]["status"] = "in-progress"
+                        
+                        yield "data: " + json.dumps({
+                            "steps": steps,
+                            "progress": 40 + (i * 50 / len(chapters)),
+                            "current_step": 3,
+                            "chapter_progress": {
+                                "current": i + 1,
+                                "total": len(chapters),
+                                "chapter": chapter,
+                                "percent": ((i + 1) / len(chapters)) * 100
+                            }
+                        }) + "\n\n"
+                        
+                        try:
+                            response = model_provider.generate_content(
+                                selected_model,
+                                f"Write a detailed chapter about '{chapter}' for a research paper about {research_subject}."
+                            )
+                            
+                            # Calculate and store duration
+                            duration = time.time() - steps[3]["subSteps"][i]["start_time"]
+                            steps[3]["subSteps"][i]["duration"] = f"{duration:.1f}s"
+                            steps[3]["subSteps"][i]["status"] = "complete"
+                            
+                            yield "data: " + json.dumps({
+                                "steps": steps,
+                                "progress": 40 + ((i + 1) * 50 / len(chapters)),
+                                "current_step": 3,
+                                "chapter_progress": {
+                                    "current": i + 1,
+                                    "total": len(chapters),
+                                    "chapter": chapter,
+                                    "percent": ((i + 1) / len(chapters)) * 100,
+                                    "duration": f"{duration:.1f}s"
+                                }
+                            }) + "\n\n"
+                        except Exception as e:
+                            duration = time.time() - steps[3]["subSteps"][i]["start_time"]
+                            steps[3]["subSteps"][i]["duration"] = f"{duration:.1f}s"
+                            steps[3]["subSteps"][i]["status"] = "error"
+                            steps[3]["subSteps"][i]["message"] = str(e)
+                            
+                            yield "data: " + json.dumps({
+                                "steps": steps,
+                                "progress": 40 + ((i + 1) * 50 / len(chapters)),
+                                "current_step": 3,
+                                "warning": f"Failed to generate chapter {i+1} after retries",
+                                "chapter_progress": {
+                                    "current": i + 1,
+                                    "total": len(chapters),
+                                    "chapter": chapter,
+                                    "percent": ((i + 1) / len(chapters)) * 100,
+                                    "error": str(e)
+                                }
+                            }) + "\n\n"
+                    
+                    steps[3]["status"] = "complete"
+                    yield "data: " + json.dumps({
+                        "steps": steps,
+                        "progress": 90,
+                        "current_step": 3,
+                        "chapter_progress": {
+                            "complete": True,
+                            "total_chapters": len(chapters)
+                        }
+                    }) + "\n\n"
+                    
+                except Exception as e:
+                    steps[1]["status"] = "error"
+                    steps[1]["message"] = str(e)
+                    yield "data: " + json.dumps({
+                        "steps": steps,
+                        "progress": 20,
+                        "current_step": 1
+                    }) + "\n\n"
+                    
+                    # Fallback to manual structure
+                    sections = get_manual_sections(research_subject)
+                    steps[1]["message"] = "Falling back to manual structure"
+                    yield "data: " + json.dumps({
+                        "steps": steps,
+                        "progress": 20,
+                        "current_step": 1
+                    }) + "\n\n"
+                    
+                    try:
+                        index_content = model_provider.generate_index_content(selected_model, research_subject, [s[0] for s in sections[1:]])
+                        sections[0] = ("Index", index_content)
+                        
+                        steps[1]["status"] = "complete"
+                        yield "data: " + json.dumps({
+                            "steps": steps,
+                            "progress": 25,
+                            "current_step": 1
+                        }) + "\n\n"
+                    except Exception as e:
+                        steps[1]["status"] = "error"
+                        steps[1]["message"] = str(e)
+                        yield "data: " + json.dumps({
+                            "steps": steps,
+                            "progress": 20,
+                            "current_step": 1,
+                            "error": "Failed to generate even fallback content"
+                        }) + "\n\n"
+                        return
+            else:
+                sections = get_manual_sections(research_subject)
+                steps[1]["status"] = "in-progress"
+                yield "data: " + json.dumps({
+                    "steps": steps,
+                    "progress": 10,
+                    "current_step": 1
+                }) + "\n\n"
+                
+                try:
+                    index_content = model_provider.generate_index_content(selected_model, research_subject, [s[0] for s in sections[1:]])
+                    sections[0] = ("Index", index_content)
+                    
+                    steps[1]["status"] = "complete"
+                    yield "data: " + json.dumps({
+                        "steps": steps,
+                        "progress": 20,
+                        "current_step": 1
+                    }) + "\n\n"
+                except Exception as e:
+                    steps[1]["status"] = "error"
+                    steps[1]["message"] = str(e)
+                    yield "data: " + json.dumps({
+                        "steps": steps,
+                        "progress": 20,
+                        "current_step": 1,
+                        "error": "Failed to generate manual index"
+                    }) + "\n\n"
+                    return
+            
+            # Write introduction
+            steps[3]["status"] = "in-progress"
+            yield "data: " + json.dumps({
+                "steps": steps,
+                "progress": 40,
+                "current_step": 3
+            }) + "\n\n"
+            
+            try:
+                introduction_content = model_provider.generate_content(
+                    selected_model,
+                    f"Write a comprehensive introduction for a research paper about {research_subject}."
+                )
+                
+                steps[3]["status"] = "complete"
+                yield "data: " + json.dumps({
+                    "steps": steps,
+                    "progress": 60,
+                    "current_step": 3
+                }) + "\n\n"
+            except Exception as e:
+                steps[3]["status"] = "error"
+                steps[3]["message"] = str(e)
+                yield "data: " + json.dumps({
+                    "steps": steps,
+                    "progress": 60,
+                    "current_step": 3,
+                    "warning": "Failed to generate introduction after retries"
+                }) + "\n\n"
+            
+            # Write conclusion
+            steps[4]["status"] = "in-progress"
+            yield "data: " + json.dumps({
+                "steps": steps,
+                "progress": 80,
+                "current_step": 4
+            }) + "\n\n"
+            
+            try:
+                conclusion_content = model_provider.generate_content(
+                    selected_model,
+                    f"Write a conclusion section for a research paper about {research_subject}."
+                )
+                
+                steps[4]["status"] = "complete"
+                yield "data: " + json.dumps({
+                    "steps": steps,
+                    "progress": 90,
+                    "current_step": 4
+                }) + "\n\n"
+            except Exception as e:
+                steps[4]["status"] = "error"
+                steps[4]["message"] = str(e)
+                yield "data: " + json.dumps({
+                    "steps": steps,
+                    "progress": 90,
+                    "current_step": 4,
+                    "warning": "Failed to generate conclusion after retries"
+                }) + "\n\n"
+            
+            # Write the complete paper
+            write_research_paper(md_filename, research_subject, sections, selected_model)
+            
+            # Convert to Word
+            steps[5]["status"] = "in-progress"
+            yield "data: " + json.dumps({
+                "steps": steps,
+                "progress": 95,
+                "current_step": 5
+            }) + "\n\n"
+            
+            try:
+                doc_generator.convert_to_word(md_filename, docx_filename)
+                steps[5]["status"] = "complete"
+                yield "data: " + json.dumps({
+                    "steps": steps,
+                    "progress": 100,
+                    "current_step": 5,
+                    "status": "complete",
+                    "docx_file": docx_filename,
+                    "md_file": md_filename
+                }) + "\n\n"
+            except Exception as e:
+                steps[5]["status"] = "error"
+                steps[5]["message"] = str(e)
+                yield "data: " + json.dumps({
+                    "steps": steps,
+                    "progress": 100,
+                    "current_step": 5,
+                    "status": "partial_success",
+                    "message": f'Paper generated but Word conversion failed: {str(e)}',
+                    "md_file": md_filename
+                }) + "\n\n"
+            
+        except Exception as e:
+            yield "data: " + json.dumps({"error": f"Failed to generate paper: {str(e)}"}) + "\n\n"
+    
+    return Response(generate(), mimetype="text/event-stream")
+
+@api_bp.route('/download/<filename>')
+def download(filename):
+    safe_filename = secure_filename(filename)
+    return send_from_directory(
+        Config.UPLOAD_FOLDER,
+        safe_filename,
+        as_attachment=True
+    )

routes/views.py

@@ -0,0 +1,10 @@
+from flask import Blueprint, render_template
+from services.model_provider import ModelProvider
+
+views_bp = Blueprint('views', __name__)
+model_provider = ModelProvider()
+
+@views_bp.route('/')
+def index():
+    models = model_provider.get_available_models()
+    return render_template('index.html', models=models)

services/document_generator.py

@@ -0,0 +1,34 @@
+import os
+import uuid
+import subprocess
+from typing import List, Tuple
+
+class DocumentGenerator:
+    def __init__(self, upload_folder):
+        self.upload_folder = upload_folder
+        os.makedirs(self.upload_folder, exist_ok=True)
+
+    def generate_filename(self) -> Tuple[str, str]:
+        """Generate filenames with unique ID"""
+        unique_id = str(uuid.uuid4())[:8]
+        md_filename = f"research_paper_{unique_id}.md"
+        docx_filename = f"research_paper_{unique_id}.docx"
+        return md_filename, docx_filename
+
+    def convert_to_word(self, md_filename: str, docx_filename: str) -> None:
+        """Convert markdown file to Word document using Pandoc"""
+        md_path = os.path.join(self.upload_folder, md_filename)
+        docx_path = os.path.join(self.upload_folder, docx_filename)
+        
+        command = [
+            "pandoc", md_path,
+            "-o", docx_path,
+            "--standalone",
+            "--table-of-contents",
+            "--toc-depth=3"
+        ]
+        
+        if os.path.exists("reference.docx"):
+            command.extend(["--reference-doc", "reference.docx"])
+        
+        subprocess.run(command, check=True)

services/model_provider.py

@@ -0,0 +1,230 @@
+import os
+import g4f
+import requests
+from typing import List, Dict, Optional
+from config import Config
+from utils.retry_decorator import retry
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class BaseAIService:
+    """Base class for AI services"""
+    def __init__(self, config: Dict):
+        self.config = config
+
+    def generate_content(self, model: str, prompt: str) -> str:
+        raise NotImplementedError
+
+    def get_available_models(self) -> List[str]:
+        raise NotImplementedError
+
+class G4FService(BaseAIService):
+    """Service for g4f provider"""
+    def generate_content(self, model: str, prompt: str) -> str:
+        try:
+            response = g4f.ChatCompletion.create(
+                model=model,
+                messages=[{"role": "user", "content": prompt}],
+                stream=False
+            )
+            return str(response) if response else "[Empty response from model]"
+        except Exception as e:
+            logger.error(f"G4FService error: {str(e)}")
+            raise
+
+    def get_available_models(self) -> List[str]:
+        try:
+            models = sorted(g4f.models._all_models)
+            if 'gpt-4o' in models:
+                models.remove('gpt-4o')
+                models.insert(0, 'gpt-4o')
+            return models
+        except Exception as e:
+            logger.error(f"Failed to get G4F models: {str(e)}")
+            return ['gpt-4o', 'gpt-4', 'gpt-3.5-turbo', 'llama2-70b', 'claude-2']
+
+class HuggingFaceService(BaseAIService):
+    """Service for HuggingFace Inference API"""
+    def __init__(self, config: Dict):
+        super().__init__(config)
+        self.api_key = self.config.get('api_key', os.getenv('HUGGINGFACE_API_KEY'))
+        self.api_url = self.config.get('api_url', "https://api-inference.huggingface.co/models")
+
+    def generate_content(self, model: str, prompt: str) -> str:
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        payload = {
+            "inputs": prompt,
+            "parameters": {
+                "max_new_tokens": self.config.get('max_tokens', 1000),
+                "temperature": self.config.get('temperature', 0.7)
+            }
+        }
+
+        try:
+            response = requests.post(
+                f"{self.api_url}/{model}",
+                headers=headers,
+                json=payload
+            )
+            response.raise_for_status()
+            return response.json()[0]['generated_text']
+        except Exception as e:
+            logger.error(f"HuggingFace API error: {str(e)}")
+            raise
+
+    def get_available_models(self) -> List[str]:
+        # Note: HuggingFace doesn't provide a simple way to list all available models
+        # You would need to maintain your own list or use their API with pagination
+        return [
+            "meta-llama/Llama-2-70b-chat-hf",
+            "mistralai/Mixtral-8x7B-Instruct-v0.1",
+            "google/gemma-7b-it"
+        ]
+
+class TogetherAIService(BaseAIService):
+    """Service for Together AI API"""
+    def __init__(self, config: Dict):
+        super().__init__(config)
+        self.api_key = self.config.get('api_key', os.getenv('TOGETHER_API_KEY'))
+        self.api_url = self.config.get('api_url', "https://api.together.xyz/v1/completions")
+
+    def generate_content(self, model: str, prompt: str) -> str:
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        payload = {
+            "model": model,
+            "prompt": prompt,
+            "max_tokens": self.config.get('max_tokens', 1000),
+            "temperature": self.config.get('temperature', 0.7),
+            "top_p": self.config.get('top_p', 0.9),
+            "stop": self.config.get('stop_sequences', ["</s>"])
+        }
+
+        try:
+            response = requests.post(
+                self.api_url,
+                headers=headers,
+                json=payload
+            )
+            response.raise_for_status()
+            return response.json()['choices'][0]['text']
+        except Exception as e:
+            logger.error(f"Together AI API error: {str(e)}")
+            raise
+
+    def get_available_models(self) -> List[str]:
+        return [
+            "togethercomputer/llama-2-70b-chat",
+            "mistralai/Mixtral-8x7B-Instruct-v0.1",
+            "togethercomputer/CodeLlama-34b-Instruct"
+        ]
+
+import openai
+from typing import List, Dict
+from datetime import datetime
+
+class OpenAIService(BaseAIService):
+    """Service for OpenAI API with custom base URL support"""
+    def __init__(self, config: Dict):
+        super().__init__(config)
+        self.api_key = self.config.get('api_key', os.getenv('OPENAI_API_KEY'))
+        self.organization = self.config.get('organization', os.getenv('OPENAI_ORG_ID'))
+        self.base_url = self.config.get('base_url', "https://api.openai.com/v1")
+        
+        # Initialize the OpenAI client with custom configuration
+        self.client = openai.OpenAI(
+            api_key=self.api_key,
+            organization=self.organization,
+            base_url=self.base_url
+        )
+
+    def generate_content(self, model: str, prompt: str) -> str:
+        try:
+            response = self.client.chat.completions.create(
+                model=model,
+                messages=[{"role": "user", "content": prompt}],
+                temperature=self.config.get('temperature', 0.7),
+                max_tokens=self.config.get('max_tokens', 1000),
+                top_p=self.config.get('top_p', 0.9),
+                frequency_penalty=self.config.get('frequency_penalty', 0),
+                presence_penalty=self.config.get('presence_penalty', 0)
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            logger.error(f"OpenAI API error: {str(e)}")
+            raise
+
+    def get_available_models(self) -> List[str]:
+        try:
+            # Cache model list for 1 hour to avoid frequent API calls
+            if hasattr(self, '_cached_models') and \
+               (datetime.now() - self._cache_time).seconds < 3600:
+                return self._cached_models
+                
+            models = self.client.models.list()
+            self._cached_models = sorted([m.id for m in models.data 
+                                        if m.id.startswith('gpt-')])
+            self._cache_time = datetime.now()
+            return self._cached_models
+        except Exception as e:
+            logger.error(f"Failed to get OpenAI models: {str(e)}")
+            # Fallback to known models if API fails
+            return [
+                "gpt-4-turbo-preview",
+                "gpt-4",
+                "gpt-3.5-turbo",
+                "gpt-4-32k",
+                "gpt-4-vision-preview"
+            ]
+            
+class ModelProvider:
+    """Main provider class that routes requests to the configured service"""
+    def __init__(self):
+        self.service = self._initialize_service()
+
+    def _initialize_service(self) -> BaseAIService:
+        """Initialize the appropriate AI service based on config"""
+        provider = Config.AI_PROVIDER.lower()
+        provider_config = Config.AI_PROVIDER_CONFIG.get(provider, {})
+
+        if provider == 'g4f':
+            return G4FService(provider_config)
+        elif provider == 'huggingface':
+            return HuggingFaceService(provider_config)
+        elif provider == 'together':
+            return TogetherAIService(provider_config)
+        elif provider == 'openai':
+            return OpenAIService(provider_config)
+        else:
+            raise ValueError(f"Unsupported AI provider: {provider}")
+
+    @retry()
+    def generate_content(self, model: str, prompt: str) -> str:
+        """Generate content using the configured service"""
+        return self.service.generate_content(model, prompt)
+
+    def generate_index_content(self, model: str, research_subject: str, manual_chapters: List[str] = None) -> str:
+        """Generate index content for the research paper"""
+        try:
+            if manual_chapters:
+                prompt = f"Generate a detailed index/table of contents for a research paper about {research_subject} with these chapters: " + \
+                        ", ".join(manual_chapters) + ". Include section headings in markdown format."
+            else:
+                prompt = f"Generate a detailed index/table of contents for a research paper about {research_subject}. Include chapter titles and section headings in markdown format."
+            
+            return self.generate_content(model, prompt)
+        except Exception as e:
+            raise Exception(f"Failed to generate index: {str(e)}")
+
+    def get_available_models(self) -> List[str]:
+        """Get available models from the configured service"""
+        return self.service.get_available_models()

utils/retry_decorator.py

@@ -0,0 +1,26 @@
+import time
+import random
+from functools import wraps
+
+def retry(max_retries=3, initial_delay=1, backoff_factor=2):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            retries = 0
+            delay = initial_delay
+            
+            while retries < max_retries:
+                try:
+                    return func(*args, **kwargs)
+                except (SystemExit, KeyboardInterrupt):
+                    raise
+                except Exception as e:
+                    retries += 1
+                    if retries >= max_retries:
+                        raise  # Re-raise the last exception if max retries reached
+                    
+                    # Exponential backoff with some randomness
+                    time.sleep(delay + random.uniform(0, 0.5))
+                    delay *= backoff_factor
+        return wrapper
+    return decorator