local-deep-research 0.5.2__py3-none-any.whl → 0.5.4__py3-none-any.whl

local_deep_research/__version__.py

@@ -1 +1 @@
-__version__ = "0.5.2"
+__version__ = "0.5.4"

local_deep_research/config/llm_config.py

@@ -397,6 +397,24 @@ def get_llm(
                 llm = ChatOllama(
                     model=model_name, base_url=base_url, **common_params
                 )
+
+                # Log the actual client configuration after creation
+                logger.debug(
+                    f"ChatOllama created - base_url attribute: {getattr(llm, 'base_url', 'not found')}"
+                )
+                if hasattr(llm, "_client"):
+                    client = llm._client
+                    logger.debug(f"ChatOllama _client type: {type(client)}")
+                    if hasattr(client, "_client"):
+                        inner_client = client._client
+                        logger.debug(
+                            f"ChatOllama inner client type: {type(inner_client)}"
+                        )
+                        if hasattr(inner_client, "base_url"):
+                            logger.debug(
+                                f"ChatOllama inner client base_url: {inner_client.base_url}"
+                            )
+
                 # Test invoke to validate model works
                 logger.info("Testing Ollama model with simple invocation")
                 test_result = llm.invoke("Hello")
@@ -545,7 +563,49 @@ def wrap_llm_without_think_tags(
             self.base_llm = base_llm
 
         def invoke(self, *args, **kwargs):
-            response = self.base_llm.invoke(*args, **kwargs)
+            # Log detailed request information for Ollama models
+            if hasattr(self.base_llm, "base_url"):
+                logger.debug(
+                    f"LLM Request - Base URL: {self.base_llm.base_url}"
+                )
+                logger.debug(
+                    f"LLM Request - Model: {getattr(self.base_llm, 'model', 'unknown')}"
+                )
+                logger.debug(
+                    f"LLM Request - Args count: {len(args)}, Kwargs: {list(kwargs.keys())}"
+                )
+
+                # Log the prompt if it's in args
+                if args and len(args) > 0:
+                    prompt_text = (
+                        str(args[0])[:200] + "..."
+                        if len(str(args[0])) > 200
+                        else str(args[0])
+                    )
+                    logger.debug(f"LLM Request - Prompt preview: {prompt_text}")
+
+                # Check if there's any client configuration
+                if hasattr(self.base_llm, "_client"):
+                    client = self.base_llm._client
+                    if hasattr(client, "_client") and hasattr(
+                        client._client, "base_url"
+                    ):
+                        logger.debug(
+                            f"LLM Request - Client base URL: {client._client.base_url}"
+                        )
+
+            try:
+                response = self.base_llm.invoke(*args, **kwargs)
+                logger.debug(f"LLM Response - Success, type: {type(response)}")
+            except Exception as e:
+                logger.error(f"LLM Request - Failed with error: {str(e)}")
+                # Log any URL information from the error
+                error_str = str(e)
+                if "http://" in error_str or "https://" in error_str:
+                    logger.error(
+                        f"LLM Request - Error contains URL info: {error_str}"
+                    )
+                raise
 
             # Process the response content if it has a content attribute
             if hasattr(response, "content"):

local_deep_research/error_handling/__init__.py

@@ -0,0 +1,13 @@
+"""
+Error Handling Module for Local Deep Research
+
+This module provides comprehensive error handling capabilities including:
+- Error categorization and analysis
+- User-friendly error report generation
+- Integration with partial research results
+"""
+
+from .error_reporter import ErrorReporter
+from .report_generator import ErrorReportGenerator
+
+__all__ = ["ErrorReporter", "ErrorReportGenerator"]

local_deep_research/error_handling/error_reporter.py

@@ -0,0 +1,236 @@
+"""
+ErrorReporter - Main error categorization and handling logic
+"""
+
+import re
+from enum import Enum
+from typing import Dict, Optional, Any
+from loguru import logger
+
+
+class ErrorCategory(Enum):
+    """Categories of errors that can occur during research"""
+
+    CONNECTION_ERROR = "connection_error"
+    MODEL_ERROR = "model_error"
+    SEARCH_ERROR = "search_error"
+    SYNTHESIS_ERROR = "synthesis_error"
+    FILE_ERROR = "file_error"
+    UNKNOWN_ERROR = "unknown_error"
+
+
+class ErrorReporter:
+    """
+    Analyzes and categorizes errors to provide better user feedback
+    """
+
+    def __init__(self):
+        self.error_patterns = {
+            ErrorCategory.CONNECTION_ERROR: [
+                r"POST predict.*EOF",
+                r"Connection refused",
+                r"timeout",
+                r"Connection.*failed",
+                r"HTTP error \d+",
+                r"network.*error",
+                r"\[Errno 111\]",
+                r"host\.docker\.internal",
+                r"host.*localhost.*Docker",
+                r"127\.0\.0\.1.*Docker",
+                r"localhost.*1234.*Docker",
+                r"LM.*Studio.*Docker.*Mac",
+            ],
+            ErrorCategory.MODEL_ERROR: [
+                r"Model.*not found",
+                r"Invalid.*model",
+                r"Ollama.*not available",
+                r"API key.*invalid",
+                r"Authentication.*error",
+                r"max_workers must be greater than 0",
+                r"TypeError.*Context.*Size",
+                r"'<' not supported between",
+                r"No auth credentials found",
+                r"401.*API key",
+            ],
+            ErrorCategory.SEARCH_ERROR: [
+                r"Search.*failed",
+                r"No search results",
+                r"Search engine.*error",
+                r"Rate limit.*exceeded",
+                r"The search is longer than 256 characters",
+                r"Failed to create search engine",
+                r"could not be found",
+                r"GitHub API error",
+                r"database.*locked",
+            ],
+            ErrorCategory.SYNTHESIS_ERROR: [
+                r"Error.*synthesis",
+                r"Failed.*generate",
+                r"Synthesis.*timeout",
+                r"detailed.*report.*stuck",
+                r"report.*taking.*long",
+                r"progress.*100.*stuck",
+            ],
+            ErrorCategory.FILE_ERROR: [
+                r"Permission denied",
+                r"File.*not found",
+                r"Cannot write.*file",
+                r"Disk.*full",
+                r"No module named.*local_deep_research",
+                r"HTTP error 404.*research results",
+                r"Attempt to write readonly database",
+            ],
+        }
+
+    def categorize_error(self, error_message: str) -> ErrorCategory:
+        """
+        Categorize an error based on its message
+
+        Args:
+            error_message: The error message to categorize
+
+        Returns:
+            ErrorCategory: The categorized error type
+        """
+        error_message = str(error_message).lower()
+
+        for category, patterns in self.error_patterns.items():
+            for pattern in patterns:
+                if re.search(pattern.lower(), error_message):
+                    logger.debug(
+                        f"Categorized error as {category.value}: {pattern}"
+                    )
+                    return category
+
+        return ErrorCategory.UNKNOWN_ERROR
+
+    def get_user_friendly_title(self, category: ErrorCategory) -> str:
+        """
+        Get a user-friendly title for an error category
+
+        Args:
+            category: The error category
+
+        Returns:
+            str: User-friendly title
+        """
+        titles = {
+            ErrorCategory.CONNECTION_ERROR: "Connection Issue",
+            ErrorCategory.MODEL_ERROR: "LLM Service Error",
+            ErrorCategory.SEARCH_ERROR: "Search Service Error",
+            ErrorCategory.SYNTHESIS_ERROR: "Report Generation Error",
+            ErrorCategory.FILE_ERROR: "File System Error",
+            ErrorCategory.UNKNOWN_ERROR: "Unexpected Error",
+        }
+        return titles.get(category, "Error")
+
+    def get_suggested_actions(self, category: ErrorCategory) -> list:
+        """
+        Get suggested actions for resolving an error
+
+        Args:
+            category: The error category
+
+        Returns:
+            list: List of suggested actions
+        """
+        suggestions = {
+            ErrorCategory.CONNECTION_ERROR: [
+                "Check if the LLM service (Ollama/LM Studio) is running",
+                "Verify network connectivity",
+                "Try switching to a different model provider",
+                "Check the service logs for more details",
+            ],
+            ErrorCategory.MODEL_ERROR: [
+                "Verify the model name is correct",
+                "Check if the model is downloaded and available",
+                "Validate API keys if using external services",
+                "Try switching to a different model",
+            ],
+            ErrorCategory.SEARCH_ERROR: [
+                "Check internet connectivity",
+                "Try reducing the number of search results",
+                "Wait a moment and try again",
+                "Check if search service is configured correctly",
+                "For local documents: ensure the path is absolute and folder exists",
+                "Try a different search engine if one is failing",
+            ],
+            ErrorCategory.SYNTHESIS_ERROR: [
+                "The research data was collected successfully",
+                "Try switching to a different model for report generation",
+                "Check the partial results below",
+                "Review the detailed logs for more information",
+            ],
+            ErrorCategory.FILE_ERROR: [
+                "Check disk space availability",
+                "Verify write permissions",
+                "Try changing the output directory",
+                "Restart the application",
+            ],
+            ErrorCategory.UNKNOWN_ERROR: [
+                "Check the detailed logs below for more information",
+                "Try running the research again",
+                "Report this issue if it persists",
+                "Contact support with the error details",
+            ],
+        }
+        return suggestions.get(category, ["Check the logs for more details"])
+
+    def analyze_error(
+        self, error_message: str, context: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """
+        Perform comprehensive error analysis
+
+        Args:
+            error_message: The error message to analyze
+            context: Optional context information
+
+        Returns:
+            dict: Comprehensive error analysis
+        """
+        category = self.categorize_error(error_message)
+
+        analysis = {
+            "category": category,
+            "title": self.get_user_friendly_title(category),
+            "original_error": error_message,
+            "suggestions": self.get_suggested_actions(category),
+            "severity": self._determine_severity(category),
+            "recoverable": self._is_recoverable(category),
+        }
+
+        # Add context-specific information
+        if context:
+            analysis["context"] = context
+            analysis["has_partial_results"] = bool(
+                context.get("findings")
+                or context.get("current_knowledge")
+                or context.get("search_results")
+            )
+
+        return analysis
+
+    def _determine_severity(self, category: ErrorCategory) -> str:
+        """Determine error severity level"""
+        severity_map = {
+            ErrorCategory.CONNECTION_ERROR: "high",
+            ErrorCategory.MODEL_ERROR: "high",
+            ErrorCategory.SEARCH_ERROR: "medium",
+            ErrorCategory.SYNTHESIS_ERROR: "low",  # Can often show partial results
+            ErrorCategory.FILE_ERROR: "medium",
+            ErrorCategory.UNKNOWN_ERROR: "high",
+        }
+        return severity_map.get(category, "medium")
+
+    def _is_recoverable(self, category: ErrorCategory) -> bool:
+        """Determine if error is recoverable with user action"""
+        recoverable = {
+            ErrorCategory.CONNECTION_ERROR: True,
+            ErrorCategory.MODEL_ERROR: True,
+            ErrorCategory.SEARCH_ERROR: True,
+            ErrorCategory.SYNTHESIS_ERROR: True,
+            ErrorCategory.FILE_ERROR: True,
+            ErrorCategory.UNKNOWN_ERROR: False,
+        }
+        return recoverable.get(category, False)