quantalogic 0.2.14__tar.gz → 0.2.15__tar.gz

{quantalogic-0.2.14 → quantalogic-0.2.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantalogic
-Version: 0.2.14
+Version: 0.2.15
 Summary: QuantaLogic ReAct Agents
 Author: Raphaël MANSUY
 Author-email: raphael.mansuy@gmail.com
@@ -10,6 +10,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: boto3 (>=1.35.86,<2.0.0)
 Requires-Dist: click (>=8.1.8,<9.0.0)
+Requires-Dist: duckduckgo-search (>=7.2.1,<8.0.0)
 Requires-Dist: fastapi (>=0.115.6,<0.116.0)
 Requires-Dist: google-auth (>=2.20.0,<3.0.0)
 Requires-Dist: google-search-results (>=2.4.2,<3.0.0)

{quantalogic-0.2.14 → quantalogic-0.2.15}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "quantalogic"
-version = "0.2.14"
+version = "0.2.15"
 description = "QuantaLogic ReAct Agents"
 authors = ["Raphaël MANSUY <raphael.mansuy@gmail.com>"]
 readme = "README.md"
@@ -36,6 +36,7 @@ toml = "^0.10.2"
 types-requests = "^2.32.0.20241016"
 google-search-results = "^2.4.2"
 serpapi = "^0.1.5"
+duckduckgo-search = "^7.2.1"
 
 [tool.poetry.scripts]
 quantalogic = "quantalogic.main:cli"

{quantalogic-0.2.14 → quantalogic-0.2.15}/quantalogic/agent_config.py

@@ -24,6 +24,8 @@ from quantalogic.tools import (
     SearchDefinitionNames,
     TaskCompleteTool,
     WriteFileTool,
+    DuckDuckGoSearchTool,
+    WikipediaSearchTool,
 )
 
 MODEL_NAME = "deepseek/deepseek-chat"
@@ -124,6 +126,8 @@ def create_full_agent(model_name: str, vision_model_name: str | None) -> Agent:
         MarkitdownTool(),
         LLMTool(model_name=model_name),
         DownloadHttpFileTool(),
+        WikipediaSearchTool(),
+        DuckDuckGoSearchTool(),
     ]
 
     if vision_model_name:

{quantalogic-0.2.14 → quantalogic-0.2.15}/quantalogic/generative_model.py

@@ -1,5 +1,7 @@
 """Generative model module for AI-powered text generation."""
 
+import functools
+
 import openai
 from litellm import completion, exceptions, get_max_tokens, get_model_info, token_counter
 from loguru import logger
@@ -83,6 +85,7 @@ class GenerativeModel:
         logger.debug(f"Initializing GenerativeModel with model={model}, temperature={temperature}")
         self.model = model
         self.temperature = temperature
+        self._get_model_info_cached = functools.lru_cache(maxsize=32)(self._get_model_info_impl)
 
     # Define retriable exceptions based on LiteLLM's exception mapping
     RETRIABLE_EXCEPTIONS = (
@@ -235,21 +238,46 @@ class GenerativeModel:
         litellm_messages.append({"role": "user", "content": str(prompt)})
         return token_counter(model=self.model, messages=litellm_messages)
 
-    def get_model_info(self) -> dict | None:
-        """Get information about the model."""
-        logger.debug(f"Retrieving model info for {self.model}")
-        model_info = get_model_info(self.model)
-
-        if not model_info:
-            logger.debug("Model info not found, trying without openrouter/ prefix")
-            model_info = get_model_info(self.model.replace("openrouter/", ""))
-
-        if model_info:
-            logger.debug(f"Model info retrieved: {model_info.keys()}")
-        else:
-            logger.debug("No model info available")
-
-        return model_info
+    def _get_model_info_impl(self, model_name: str) -> dict:
+        """Get information about the model with prefix fallback logic.
+        
+        Attempts to find model info by progressively removing provider prefixes.
+        Raises ValueError if no valid model configuration is found.
+        Results are cached to improve performance.
+        
+        Example:
+            openrouter/openai/gpt-4o-mini → openai/gpt-4o-mini → gpt-4o-mini
+        """
+        original_model = model_name
+        
+        while True:
+            try:
+                logger.debug(f"Attempting to retrieve model info for: {model_name}")
+                model_info = get_model_info(model_name)
+                if model_info:
+                    logger.debug(f"Found model info for {model_name}: {model_info}")
+                    return model_info
+            except Exception:
+                pass
+                
+            # Try removing one prefix level
+            parts = model_name.split('/')
+            if len(parts) <= 1:
+                break
+            model_name = '/'.join(parts[1:])
+            
+        error_msg = f"Could not find model info for {original_model} after trying: {self.model} → {model_name}"
+        logger.error(error_msg)
+        raise ValueError(error_msg)
+
+    def get_model_info(self, model_name: str = None) -> dict:
+        """Get cached information about the model.
+        
+        If no model name is provided, uses the current model.
+        """
+        if model_name is None:
+            model_name = self.model
+        return self._get_model_info_cached(model_name)
 
     def get_model_max_input_tokens(self) -> int:
         """Get the maximum number of input tokens for the model."""

{quantalogic-0.2.14 → quantalogic-0.2.15}/quantalogic/search_agent.py

@@ -1,16 +1,26 @@
 from quantalogic.agent import Agent
-from quantalogic.tools import InputQuestionTool, SerpApiSearchTool, TaskCompleteTool, WikipediaSearchTool, ReadFileBlockTool,ReadFileTool, MarkitdownTool, RipgrepTool
+from quantalogic.tools import (
+    InputQuestionTool,
+    SerpApiSearchTool,
+    DuckDuckGoSearchTool,
+    TaskCompleteTool,
+    WikipediaSearchTool,
+    ReadFileBlockTool,
+    ReadFileTool,
+    MarkitdownTool,
+    RipgrepTool
+)
 
 
 def create_search_agent(model_name: str) -> Agent:
-    """Creates and configures a search agent with web and knowledge search tools.
+    """Creates and configures a search agent with web, knowledge, and privacy-focused search tools.
 
     Args:
         model_name (str): Name of the language model to use for the agent's core capabilities
 
     Returns:
         Agent: A fully configured search agent instance with:
-            - Web search capabilities (SerpAPI)
+            - Web search capabilities (SerpAPI, DuckDuckGo)
             - Knowledge search capabilities (Wikipedia)
             - Basic interaction tools
     """
@@ -22,6 +32,7 @@ def create_search_agent(model_name: str) -> Agent:
     tools = [
         # Search tools
         SerpApiSearchTool(),  # Web search capabilities
+        DuckDuckGoSearchTool(),  # Privacy-focused web search
         WikipediaSearchTool(),  # Knowledge search capabilities
         # Basic interaction tools
         TaskCompleteTool(),  # Marks task completion

{quantalogic-0.2.14 → quantalogic-0.2.15}/quantalogic/tools/__init__.py

@@ -18,6 +18,7 @@ from .replace_in_file_tool import ReplaceInFileTool
 from .ripgrep_tool import RipgrepTool
 from .search_definition_names import SearchDefinitionNames
 from .serpapi_search_tool import SerpApiSearchTool
+from .duckduckgo_search_tool import DuckDuckGoSearchTool
 from .task_complete_tool import TaskCompleteTool
 from .tool import Tool, ToolArgument
 from .unified_diff_tool import UnifiedDiffTool
@@ -27,6 +28,7 @@ from .write_file_tool import WriteFileTool
 __all__ = [
     "WikipediaSearchTool",
     "SerpApiSearchTool",
+    "DuckDuckGoSearchTool",
     "Tool",
     "ToolArgument",
     "TaskCompleteTool",

quantalogic-0.2.15/quantalogic/tools/duckduckgo_search_tool.py

@@ -0,0 +1,214 @@
+"""Tool for interacting with DuckDuckGo for search results."""
+
+from duckduckgo_search import DDGS
+
+from quantalogic.tools.tool import Tool, ToolArgument
+
+
+class DuckDuckGoSearchTool(Tool):
+    """Tool for retrieving search results from DuckDuckGo.
+
+    This tool provides a convenient interface to DuckDuckGo's search capabilities,
+    supporting multiple search types and structured JSON output.
+
+    Example usage:
+    ```python
+    tool = DuckDuckGoSearchTool()
+    results = tool.execute(
+        query="machine learning",
+        search_type="text",
+        max_results=10,
+        region="us-en",
+        safesearch="moderate"
+    )
+    print(results)
+    ```
+
+    The tool handles:
+    - Query validation
+    - API error handling
+    - Multiple search types (text, images, videos, news)
+    - Scope filtering (region, safesearch, timelimit)
+    - JSON result formatting
+    """
+
+    name: str = "duckduckgo_tool"
+    description: str = (
+        "Retrieves search results from DuckDuckGo. "
+        "Provides structured output of search results."
+    )
+    arguments: list = [
+        ToolArgument(
+            name="query",
+            arg_type="string",
+            description="The search query to execute",
+            required=True,
+            example="machine learning",
+        ),
+        ToolArgument(
+            name="max_results",
+            arg_type="int",
+            description="Maximum number of results to retrieve (1-50)",
+            required=True,
+            default="10",
+            example="20",
+        ),
+        ToolArgument(
+            name="search_type",
+            arg_type="string",
+            description="Type of search to perform (text, images, videos, news)",
+            required=False,
+            default="text",
+            example="images",
+        ),
+        ToolArgument(
+            name="region",
+            arg_type="string",
+            description="Region for search results (e.g., 'wt-wt', 'us-en')",
+            required=False,
+            default="wt-wt",
+            example="us-en",
+        ),
+        ToolArgument(
+            name="safesearch",
+            arg_type="string",
+            description="Safesearch level ('on', 'moderate', 'off')",
+            required=False,
+            default="moderate",
+            example="moderate",
+        ),
+        ToolArgument(
+            name="timelimit",
+            arg_type="string",
+            description="Time limit for results (e.g., 'd' for day, 'w' for week)",
+            required=False,
+            default=None,
+            example="d",
+        ),
+    ]
+
+    def execute(
+        self,
+        query: str,
+        max_results: int = 10,
+        search_type: str = "text",
+        region: str = "wt-wt",
+        safesearch: str = "moderate",
+        timelimit: str = None,
+    ) -> str:
+        """Execute a search query using DuckDuckGo and return results.
+
+        Args:
+            query: The search query to execute
+            max_results: Maximum number of results to retrieve (1-50)
+            search_type: Type of search to perform (text, images, videos, news)
+            region: Region for search results (e.g., "wt-wt", "us-en")
+            safesearch: Safesearch level ("on", "moderate", "off")
+            timelimit: Time limit for results (e.g., "d" for day, "w" for week)
+
+        Returns:
+            Pretty-printed JSON string of search results.
+
+        Raises:
+            ValueError: If any parameter is invalid
+            RuntimeError: If search fails
+        """
+        # Handle empty string parameters by setting to defaults
+        query = str(query) if query else query
+        search_type = search_type if search_type else "text"
+        region = region if region else "wt-wt"
+        safesearch = safesearch if safesearch else "moderate"
+        timelimit = timelimit if timelimit else None
+
+        # Validate and convert query
+        if not query:
+            raise ValueError("Query must be a non-empty string")
+        try:
+            query = str(query)
+        except (TypeError, ValueError) as e:
+            raise ValueError(f"Query must be convertible to string: {str(e)}")
+
+        # Validate and convert max_results
+        try:
+            max_results = int(max_results)
+            if max_results < 1 or max_results > 50:
+                raise ValueError("Number of results must be between 1 and 50")
+        except (TypeError, ValueError) as e:
+            raise ValueError(f"Invalid number of results: {str(e)}")
+
+        # Validate search_type
+        if search_type not in ["text", "images", "videos", "news"]:
+            raise ValueError("search_type must be one of: text, images, videos, news")
+
+        # Validate safesearch
+        if safesearch not in ["on", "moderate", "off"]:
+            raise ValueError("safesearch must be one of: on, moderate, off")
+
+        try:
+            ddgs = DDGS()
+
+            # Perform the appropriate search based on search_type
+            if search_type == "text":
+                results = ddgs.text(
+                    keywords=query,
+                    region=region,
+                    safesearch=safesearch,
+                    timelimit=timelimit,
+                    max_results=max_results,
+                )
+            elif search_type == "images":
+                results = ddgs.images(
+                    keywords=query,
+                    region=region,
+                    safesearch=safesearch,
+                    timelimit=timelimit,
+                    max_results=max_results,
+                )
+            elif search_type == "videos":
+                results = ddgs.videos(
+                    keywords=query,
+                    region=region,
+                    safesearch=safesearch,
+                    timelimit=timelimit,
+                    max_results=max_results,
+                )
+            elif search_type == "news":
+                results = ddgs.news(
+                    keywords=query,
+                    region=region,
+                    safesearch=safesearch,
+                    timelimit=timelimit,
+                    max_results=max_results,
+                )
+
+            # Return pretty-printed JSON
+            import json
+            return json.dumps(results, indent=4, ensure_ascii=False)
+
+        except Exception as e:
+            raise RuntimeError(f"Search failed: {str(e)}")
+
+
+def main():
+    """Demonstrate DuckDuckGoSearchTool functionality."""
+    try:
+        tool = DuckDuckGoSearchTool()
+
+        # Test basic search functionality
+        print("Testing DuckDuckGoSearchTool with sample query...")
+        results = tool.execute(query="Python programming", max_results=3)
+        print(results)
+
+        # Test error handling
+        print("\nTesting error handling with invalid query...")
+        try:
+            tool.execute(query="")
+        except ValueError as e:
+            print(f"Caught expected ValueError: {e}")
+
+    except Exception as e:
+        print(f"Error in main: {e}")
+
+
+if __name__ == "__main__":
+    main()

{quantalogic-0.2.14 → quantalogic-0.2.15}/quantalogic/tools/markitdown_tool.py

@@ -47,50 +47,53 @@ class MarkitdownTool(Tool):
         Returns:
             str: The Markdown content or a success message.
         """
-        # Handle tilde expansion for local paths
-        if file_path.startswith("~"):
-            file_path = os.path.expanduser(file_path)
-
-        # Handle URL paths
-        if file_path.startswith(("http://", "https://")):
-            try:
-                # Create a temporary file
-                with tempfile.NamedTemporaryFile(delete=False) as temp_file:
-                    temp_path = temp_file.name
-                    # Download the file from URL
-                    download_http_file(file_path, temp_path)
-                    # Use the temporary file path for conversion
-                    file_path = temp_path
-                    is_temp_file = True
-            except Exception as e:
-                return f"Error downloading file from URL: {str(e)}"
-        else:
-            is_temp_file = False
-
         try:
-            from markitdown import MarkItDown
+            # Handle URL paths first
+            if file_path.startswith(("http://", "https://")):
+                try:
+                    with tempfile.NamedTemporaryFile(delete=False) as temp_file:
+                        temp_path = temp_file.name
+                        download_http_file(file_path, temp_path)
+                        file_path = temp_path
+                        is_temp_file = True
+                except Exception as e:
+                    return f"Error downloading file from URL: {str(e)}"
+            else:
+                is_temp_file = False
+                # Handle local paths
+                if file_path.startswith("~"):
+                    file_path = os.path.expanduser(file_path)
+                if not os.path.isabs(file_path):
+                    file_path = os.path.abspath(file_path)
+                
+                # Verify file exists
+                if not os.path.exists(file_path):
+                    return f"Error: File not found at path: {file_path}"
 
+            from markitdown import MarkItDown
             md = MarkItDown()
             result = md.convert(file_path)
 
             if output_file_path:
+                # Ensure output directory exists
+                output_dir = os.path.dirname(output_file_path)
+                if output_dir and not os.path.exists(output_dir):
+                    os.makedirs(output_dir)
+                    
                 with open(output_file_path, "w", encoding="utf-8") as f:
                     f.write(result.text_content)
-                output_message = f"Markdown content successfully written to {output_file_path}"
-            else:
-                # Truncate content if it exceeds MAX_LINES
-                lines = result.text_content.splitlines()
-                if len(lines) > MAX_LINES:
-                    truncated_content = "\n".join(lines[:MAX_LINES])
-                    output_message = f"Markdown content truncated to {MAX_LINES} lines:\n{truncated_content}"
-                else:
-                    output_message = result.text_content
-
-            return output_message
+                return f"Markdown content successfully written to {output_file_path}"
+            
+            # Handle content truncation
+            lines = result.text_content.splitlines()
+            if len(lines) > MAX_LINES:
+                truncated_content = "\n".join(lines[:MAX_LINES])
+                return f"Markdown content truncated to {MAX_LINES} lines:\n{truncated_content}"
+            return result.text_content
+
         except Exception as e:
             return f"Error converting file to Markdown: {str(e)}"
         finally:
-            # Clean up temporary file if it was created
             if is_temp_file and os.path.exists(file_path):
                 os.remove(file_path)