local-deep-research 0.5.0__py3-none-any.whl → 0.5.3__py3-none-any.whl

local_deep_research/web/services/research_service.py

@@ -1,5 +1,4 @@
 import hashlib
-import json
 import threading
 from datetime import datetime
 from pathlib import Path
@@ -15,9 +14,10 @@ from ...utilities.log_utils import log_for_research
 from ...utilities.search_utilities import extract_links_from_search_results
 from ...utilities.db_utils import get_db_session
 from ...utilities.threading_utils import thread_context, thread_with_app_context
-from ..database.models import ResearchStrategy
-from ..models.database import calculate_duration, get_db_connection
+from ..database.models import ResearchStrategy, ResearchHistory
+from ..models.database import calculate_duration
 from .socket_service import SocketIOService
+from ...error_handling.report_generator import ErrorReportGenerator
 
 # Output directory for research results
 _PROJECT_ROOT = Path(__file__).parents[4]
@@ -336,36 +336,19 @@ def run_research_process(
                     active_research[research_id]["progress"] = adjusted_progress
 
                 # Update progress in the research_history table (for backward compatibility)
-                conn = get_db_connection()
-                cursor = conn.cursor()
+                db_session = get_db_session()
 
                 # Update the progress and log separately to avoid race conditions
-                if adjusted_progress is not None:
-                    cursor.execute(
-                        "UPDATE research_history SET progress = ? WHERE id = ?",
-                        (adjusted_progress, research_id),
-                    )
-
-                # Add the log entry to the progress_log
-                cursor.execute(
-                    "SELECT progress_log FROM research_history WHERE id = ?",
-                    (research_id,),
-                )
-                log_result = cursor.fetchone()
-
-                if log_result:
-                    try:
-                        current_log = json.loads(log_result[0])
-                    except Exception:
-                        current_log = []
-
-                    cursor.execute(
-                        "UPDATE research_history SET progress_log = ? WHERE id = ?",
-                        (json.dumps(current_log), research_id),
-                    )
-
-                conn.commit()
-                conn.close()
+                with db_session:
+                    if adjusted_progress is not None:
+                        research = (
+                            db_session.query(ResearchHistory)
+                            .filter(ResearchHistory.id == research_id)
+                            .first()
+                        )
+                        if research:
+                            research.progress = adjusted_progress
+                            db_session.commit()
 
                 # Emit a socket event
                 try:
@@ -675,8 +658,40 @@ def run_research_process(
                 )
 
                 try:
-                    # Get the synthesized content from the LLM directly
-                    clean_markdown = raw_formatted_findings
+                    # Check if we have an error in the findings and use enhanced error handling
+                    if isinstance(
+                        raw_formatted_findings, str
+                    ) and raw_formatted_findings.startswith("Error:"):
+                        logger.info(
+                            "Generating enhanced error report using ErrorReportGenerator"
+                        )
+
+                        # Get LLM for error explanation if available
+                        try:
+                            llm = get_llm(research_id=research_id)
+                        except Exception:
+                            llm = None
+                            logger.warning(
+                                "Could not get LLM for error explanation"
+                            )
+
+                        # Generate comprehensive error report
+                        error_generator = ErrorReportGenerator(llm)
+                        clean_markdown = error_generator.generate_error_report(
+                            error_message=raw_formatted_findings,
+                            query=query,
+                            partial_results=results,
+                            search_iterations=results.get("iterations", 0),
+                            research_id=research_id,
+                        )
+
+                        logger.info(
+                            "Generated enhanced error report with %d characters",
+                            len(clean_markdown),
+                        )
+                    else:
+                        # Get the synthesized content from the LLM directly
+                        clean_markdown = raw_formatted_findings
 
                     # Extract all sources from findings to add them to the summary
                     all_links = []
@@ -743,32 +758,28 @@ def run_research_process(
                     logger.info(
                         "Updating database for research_id: %s", research_id
                     )
-                    # Get the start time from the database
-                    conn = get_db_connection()
-                    cursor = conn.cursor()
-                    cursor.execute(
-                        "SELECT created_at FROM research_history WHERE id = ?",
-                        (research_id,),
-                    )
-                    result = cursor.fetchone()
-
-                    # Use the helper function for consistent duration calculation
-                    duration_seconds = calculate_duration(result[0])
-
-                    # Update the record
-                    cursor.execute(
-                        "UPDATE research_history SET status = ?, completed_at = ?, duration_seconds = ?, report_path = ?, metadata = ? WHERE id = ?",
-                        (
-                            "completed",
-                            completed_at,
-                            duration_seconds,
-                            str(report_path),
-                            json.dumps(metadata),
-                            research_id,
-                        ),
-                    )
-                    conn.commit()
-                    conn.close()
+
+                    db_session = get_db_session()
+                    with db_session:
+                        research = (
+                            db_session.query(ResearchHistory)
+                            .filter_by(id=research_id)
+                            .first()
+                        )
+
+                        # Use the helper function for consistent duration calculation
+                        duration_seconds = calculate_duration(
+                            research.created_at, research.completed_at
+                        )
+
+                        research.status = "completed"
+                        research.completed_at = completed_at
+                        research.duration_seconds = duration_seconds
+                        research.report_path = str(report_path)
+                        research.research_meta = metadata
+
+                        db_session.commit()
+
                     logger.info(
                         f"Database updated successfully for research_id: {research_id}"
                     )
@@ -837,31 +848,26 @@ def run_research_process(
             now = datetime.utcnow()
             completed_at = now.isoformat()
 
-            # Get the start time from the database
-            conn = get_db_connection()
-            cursor = conn.cursor()
-            cursor.execute(
-                "SELECT created_at FROM research_history WHERE id = ?",
-                (research_id,),
-            )
-            result = cursor.fetchone()
-
-            # Use the helper function for consistent duration calculation
-            duration_seconds = calculate_duration(result[0])
-
-            cursor.execute(
-                "UPDATE research_history SET status = ?, completed_at = ?, duration_seconds = ?, report_path = ?, metadata = ? WHERE id = ?",
-                (
-                    "completed",
-                    completed_at,
-                    duration_seconds,
-                    str(report_path),
-                    json.dumps(metadata),
-                    research_id,
-                ),
-            )
-            conn.commit()
-            conn.close()
+            db_session = get_db_session()
+            with db_session:
+                research = (
+                    db_session.query(ResearchHistory)
+                    .filter_by(id=research_id)
+                    .first()
+                )
+
+                # Use the helper function for consistent duration calculation
+                duration_seconds = calculate_duration(
+                    research.created_at, research.completed_at
+                )
+
+                research.status = "completed"
+                research.completed_at = completed_at
+                research.duration_seconds = duration_seconds
+                research.report_path = str(report_path)
+                research.research_meta = metadata
+
+                db_session.commit()
 
             progress_callback(
                 "Research completed successfully",
@@ -905,18 +911,82 @@ def run_research_process(
                     "solution": "Check API configuration and credentials."
                 }
 
+            # Generate enhanced error report for failed research
+            enhanced_report_content = None
+            try:
+                # Get LLM for error explanation if available
+                try:
+                    llm = get_llm(research_id=research_id)
+                except Exception:
+                    llm = None
+                    logger.warning(
+                        "Could not get LLM for error explanation in failure handler"
+                    )
+
+                # Get partial results if they exist
+                partial_results = results if "results" in locals() else None
+                search_iterations = (
+                    results.get("iterations", 0) if partial_results else 0
+                )
+
+                # Generate comprehensive error report
+                error_generator = ErrorReportGenerator(llm)
+                enhanced_report_content = error_generator.generate_error_report(
+                    error_message=f"Research failed: {str(e)}",
+                    query=query,
+                    partial_results=partial_results,
+                    search_iterations=search_iterations,
+                    research_id=research_id,
+                )
+
+                logger.info(
+                    "Generated enhanced error report for failed research (length: %d)",
+                    len(enhanced_report_content),
+                )
+
+                # Save enhanced error report as the actual report file
+                try:
+                    reports_folder = OUTPUT_DIR
+                    report_filename = f"research_{research_id}_error_report.md"
+                    report_path = reports_folder / report_filename
+
+                    with open(report_path, "w", encoding="utf-8") as f:
+                        f.write(enhanced_report_content)
+
+                    logger.info(
+                        "Saved enhanced error report to: %s", report_path
+                    )
+
+                    # Store the report path so it can be retrieved later
+                    report_path_to_save = str(
+                        report_path.relative_to(reports_folder.parent)
+                    )
+
+                except Exception as report_error:
+                    logger.exception(
+                        "Failed to save enhanced error report: %s", report_error
+                    )
+                    report_path_to_save = None
+
+            except Exception as error_gen_error:
+                logger.exception(
+                    "Failed to generate enhanced error report: %s",
+                    error_gen_error,
+                )
+                enhanced_report_content = None
+                report_path_to_save = None
+
             # Update metadata with more context about the error
             metadata = {"phase": "error", "error": user_friendly_error}
             if error_context:
                 metadata.update(error_context)
+            if enhanced_report_content:
+                metadata["has_enhanced_report"] = True
 
             # If we still have an active research record, update its log
             if research_id in active_research:
                 progress_callback(user_friendly_error, None, metadata)
 
-            conn = get_db_connection()
-            cursor = conn.cursor()
-
             # If termination was requested, mark as suspended instead of failed
             status = (
                 "suspended"
@@ -938,28 +1008,37 @@ def run_research_process(
 
             # Get the start time from the database
             duration_seconds = None
-            cursor.execute(
-                "SELECT created_at FROM research_history WHERE id = ?",
-                (research_id,),
-            )
-            result = cursor.fetchone()
-
-            # Use the helper function for consistent duration calculation
-            if result and result[0]:
-                duration_seconds = calculate_duration(result[0])
-
-            cursor.execute(
-                "UPDATE research_history SET status = ?, completed_at = ?, duration_seconds = ?, metadata = ? WHERE id = ?",
-                (
-                    status,
-                    completed_at,
-                    duration_seconds,
-                    json.dumps(metadata),
-                    research_id,
-                ),
-            )
-            conn.commit()
-            conn.close()
+            db_session = get_db_session()
+            with db_session:
+                research = (
+                    db_session.query(ResearchHistory)
+                    .filter_by(id=research_id)
+                    .first()
+                )
+                assert research is not None, "Research not in database"
+
+                duration_seconds = calculate_duration(research.created_at)
+
+            db_session = get_db_session()
+            with db_session:
+                research = (
+                    db_session.query(ResearchHistory)
+                    .filter_by(id=research_id)
+                    .first()
+                )
+                assert research is not None, "Research not in database"
+
+                # Update the ResearchHistory object with the new status and completion time
+                research.status = status
+                research.completed_at = completed_at
+                research.duration_seconds = duration_seconds
+                research.metadata = metadata
+
+                # Add error report path if available
+                if "report_path_to_save" in locals() and report_path_to_save:
+                    research.report_path = report_path_to_save
+
+                db_session.commit()
 
             try:
                 SocketIOService().emit_to_subscribers(
@@ -993,15 +1072,17 @@ def cleanup_research_resources(research_id, active_research, termination_flags):
     # Get the current status from the database to determine the final status message
     current_status = "completed"  # Default
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-        cursor.execute(
-            "SELECT status FROM research_history WHERE id = ?", (research_id,)
-        )
-        result = cursor.fetchone()
-        if result and result[0]:
-            current_status = result[0]
-        conn.close()
+        db_session = get_db_session()
+        with db_session:
+            research = (
+                db_session.query(ResearchHistory)
+                .filter(ResearchHistory.id == research_id)
+                .first()
+            )
+            if research:
+                current_status = research.status
+            else:
+                logger.error("Research with ID %s not found", research_id)
     except Exception:
         logger.exception("Error retrieving research status during cleanup")
 
@@ -1063,33 +1144,23 @@ def handle_termination(research_id, active_research, termination_flags):
         active_research: Dictionary of active research processes
         termination_flags: Dictionary of termination flags
     """
-    # Explicitly set the status to suspended in the database
-    conn = get_db_connection()
-    cursor = conn.cursor()
-
-    # Calculate duration up to termination point - using UTC consistently
     now = datetime.utcnow()
     completed_at = now.isoformat()
 
-    # Get the start time from the database
-    cursor.execute(
-        "SELECT created_at FROM research_history WHERE id = ?",
-        (research_id,),
-    )
-    result = cursor.fetchone()
+    # Fetch the start time from the database using the ORM
+    session = get_db_session()
+    research = session.query(ResearchHistory).filter_by(id=research_id).first()
 
-    # Calculate the duration
-    duration_seconds = (
-        calculate_duration(result[0]) if result and result[0] else None
-    )
+    if research:
+        duration_seconds = calculate_duration(research.created_at)
 
-    # Update the database with suspended status
-    cursor.execute(
-        "UPDATE research_history SET status = ?, completed_at = ?, duration_seconds = ? WHERE id = ?",
-        ("suspended", completed_at, duration_seconds, research_id),
-    )
-    conn.commit()
-    conn.close()
+        # Update the database with suspended status using the ORM
+        research.status = "suspended"
+        research.completed_at = completed_at
+        research.duration_seconds = duration_seconds
+        session.commit()
+    else:
+        logger.error(f"Research with ID {research_id} not found.")
 
     # Clean up resources
     cleanup_research_resources(research_id, active_research, termination_flags)
@@ -1097,7 +1168,7 @@ def handle_termination(research_id, active_research, termination_flags):
 
 def cancel_research(research_id):
     """
-    Cancel/terminate a research process
+    Cancel/terminate a research process using ORM.
 
     Args:
         research_id: The ID of the research to cancel
@@ -1122,27 +1193,14 @@ def cancel_research(research_id):
         return True
     else:
         # Update database directly if not found in active_research
-        from ..models.database import get_db_connection
-
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        # First check if the research exists
-        cursor.execute(
-            "SELECT status FROM research_history WHERE id = ?", (research_id,)
+        session = get_db_session()
+        research = (
+            session.query(ResearchHistory).filter_by(id=research_id).first()
         )
-        result = cursor.fetchone()
-
-        if not result:
-            conn.close()
+        if not research:
             return False
 
         # If it exists but isn't in active_research, still update status
-        cursor.execute(
-            "UPDATE research_history SET status = ? WHERE id = ?",
-            ("suspended", research_id),
-        )
-        conn.commit()
-        conn.close()
-
+        research.status = "suspended"
+        session.commit()
         return True

local_deep_research/web/static/js/components/progress.js

@@ -630,18 +630,20 @@
                 cancelButton.style.display = 'none';
             }
         } else if (data.status === 'failed' || data.status === 'cancelled') {
-            // Show error message
-            if (window.ui) {
-                window.ui.showError(data.error || 'Research was unsuccessful');
+            // For failed research, try to show the error report if available
+            if (data.status === 'failed') {
+                if (viewResultsButton) {
+                    viewResultsButton.textContent = 'View Error Report';
+                    viewResultsButton.href = `/research/results/${currentResearchId}`;
+                    viewResultsButton.style.display = 'inline-block';
+                }
             } else {
-                console.error('Research failed:', data.error || 'Unknown error');
-            }
-
-            // Update button to go back to home
-            if (viewResultsButton) {
-                viewResultsButton.textContent = 'Start New Research';
-                viewResultsButton.href = '/';
-                viewResultsButton.style.display = 'inline-block';
+                // For cancelled research, go back to home
+                if (viewResultsButton) {
+                    viewResultsButton.textContent = 'Start New Research';
+                    viewResultsButton.href = '/';
+                    viewResultsButton.style.display = 'inline-block';
+                }
             }
 
             // Hide cancel button
@@ -917,8 +919,12 @@
             cancelButton.style.display = 'none';
         }
 
-        // Show results button (might have partial results)
-        showResultsButton();
+        // Show error report button
+        if (viewResultsButton) {
+            viewResultsButton.textContent = 'View Error Report';
+            viewResultsButton.href = `/research/results/${currentResearchId}`;
+            viewResultsButton.style.display = 'inline-block';
+        }
 
         // Show notification if enabled
         showNotification('Research Error', `There was an error with your research: ${data.error}`);

local_deep_research/web/static/js/components/results.js

@@ -98,7 +98,7 @@
             resultsContainer.innerHTML = '<div class="text-center my-5"><i class="fas fa-spinner fa-pulse"></i><p class="mt-3">Loading research results...</p></div>';
 
             // Fetch result from API
-            const response = await fetch(`/research/api/report/${researchId}`);
+            const response = await fetch(`/research/api/history/report/${researchId}`);
 
             if (!response.ok) {
                 throw new Error(`HTTP error ${response.status}`);

local_deep_research/web/templates/pages/research.html

@@ -48,7 +48,7 @@
                             <label for="mode-quick" class="mode-option active" data-mode="quick" role="radio" aria-checked="true" tabindex="0">
                                 <div class="mode-icon"><i class="fas fa-bolt" aria-hidden="true"></i></div>
                                 <div class="mode-info">
-                                    <h3>Quick Summary</h3>
+                                    <h2>Quick Summary</h2>
                                     <p>Generated in a few minutes</p>
                                 </div>
                             </label>
@@ -57,7 +57,7 @@
                             <label for="mode-detailed" class="mode-option" data-mode="detailed" role="radio" aria-checked="false" tabindex="-1">
                                 <div class="mode-icon"><i class="fas fa-microscope" aria-hidden="true"></i></div>
                                 <div class="mode-info">
-                                    <h3>Detailed Report</h3>
+                                    <h2>Detailed Report</h2>
                                     <p>In-depth analysis (takes longer)</p>
                                 </div>
                             </label>

{local_deep_research-0.5.0.dist-info → local_deep_research-0.5.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: local-deep-research
-Version: 0.5.0
+Version: 0.5.3
 Summary: AI-powered research assistant with deep, iterative analysis using LLMs and web searches
 Author-Email: LearningCircuit <185559241+LearningCircuit@users.noreply.github.com>, HashedViking <6432677+HashedViking@users.noreply.github.com>
 License: MIT License