quantalogic 0.2.14__tar.gz → 0.2.16__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantalogic
-Version: 0.2.14
+Version: 0.2.16
 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)
@@ -132,7 +133,8 @@ Options:
                                   e.g. "openrouter/A/gpt-4o-mini").
   --log [info|debug|warning]      Set logging level (info/debug/warning).
   --verbose                       Enable verbose output.
-  --mode [code|basic|interpreter|full|code-basic|search]
+  --max-iterations INTEGER        Maximum iterations for task solving (default: 30).
+  --mode [code|basic|interpreter|full|code-basic|search|search-full]
                                   Agent mode (code/search/full).
   --help                          Show this message and exit.
 
@@ -153,6 +155,7 @@ task    Execute a task with the QuantaLogic AI Assistant
 - interpreter: Interactive code execution agent
 - full: Full-featured agent with all capabilities
 - code-basic: Coding agent with basic reasoning
+- search: Web search agent with Wikipedia, DuckDuckGo and SERPApi integration
 
 #### Task Execution
 

{quantalogic-0.2.14 → quantalogic-0.2.16}/README.md

@@ -92,7 +92,8 @@ Options:
                                   e.g. "openrouter/A/gpt-4o-mini").
   --log [info|debug|warning]      Set logging level (info/debug/warning).
   --verbose                       Enable verbose output.
-  --mode [code|basic|interpreter|full|code-basic|search]
+  --max-iterations INTEGER        Maximum iterations for task solving (default: 30).
+  --mode [code|basic|interpreter|full|code-basic|search|search-full]
                                   Agent mode (code/search/full).
   --help                          Show this message and exit.
 
@@ -113,6 +114,7 @@ task    Execute a task with the QuantaLogic AI Assistant
 - interpreter: Interactive code execution agent
 - full: Full-featured agent with all capabilities
 - code-basic: Coding agent with basic reasoning
+- search: Web search agent with Wikipedia, DuckDuckGo and SERPApi integration
 
 #### Task Execution
 

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "quantalogic"
-version = "0.2.14"
+version = "0.2.16"
 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.16}/quantalogic/agent.py

@@ -406,7 +406,7 @@ class Agent(BaseModel):
 
         formatted_response = (
             "\n"
-            f"--- Observations for iteration {iteration} ---\n"
+            f"--- Observations for iteration {iteration} / max {self.max_iterations} ---\n"
             "\n"
             f"\n --- Tool execution result stored in variable ${variable_name}$ --- \n"
             "\n"
@@ -428,7 +428,7 @@ class Agent(BaseModel):
         # Format the response message
         formatted_response = (
             "\n"
-            f"--- Observations for iteration {iteration} ---\n"
+            f"--- Observations for iteration {iteration} / max {self.max_iterations} ---\n"
             "\n"
             f"\n --- Tool execution result stored in variable ${variable_name}$ --- \n"
             "\n"
@@ -440,7 +440,7 @@ class Agent(BaseModel):
             "\n"
             f"--- Variables --- \n"
             "\n"
-            f"{self._get_variable_prompt()}"
+            f"{self._get_variable_prompt()}\n"
             "\n"
             "You must analyze this answer and evaluate what to do next to solve the task.\n"
             "If the step failed, take a step back and rethink your approach.\n"

{quantalogic-0.2.14 → quantalogic-0.2.16}/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.16}/quantalogic/coding_agent.py

@@ -1,5 +1,6 @@
 from quantalogic.agent import Agent
 from quantalogic.tools import (
+    DuckDuckGoSearchTool,
     EditWholeContentTool,
     ExecuteBashCommandTool,
     InputQuestionTool,
@@ -59,6 +60,7 @@ def create_coding_agent(model_name: str, vision_model_name: str | None = None, b
         ReadFileTool(),
         ExecuteBashCommandTool(),
         InputQuestionTool(),
+        DuckDuckGoSearchTool(),
     ]
 
     if vision_model_name:
@@ -69,7 +71,7 @@ def create_coding_agent(model_name: str, vision_model_name: str | None = None, b
             LLMTool(
                 model_name=model_name,
                 system_prompt="You are a software expert, your role is to answer coding questions.",
-                name="coding_consultant",  # Handles implementation-level coding questions                
+                name="coding_consultant",  # Handles implementation-level coding questions
             )
         )
         tools.append(

{quantalogic-0.2.14 → quantalogic-0.2.16}/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.16}/quantalogic/main.py

@@ -32,9 +32,9 @@ from quantalogic.agent_config import (  # noqa: E402
 )
 from quantalogic.interactive_text_editor import get_multiline_input  # noqa: E402
 from quantalogic.print_event import console_print_events  # noqa: E402
-from quantalogic.search_agent import create_search_agent
+from quantalogic.search_agent import create_search_agent  # noqa: E402
 
-AGENT_MODES = ["code", "basic", "interpreter", "full", "code-basic","search"]
+AGENT_MODES = ["code", "basic", "interpreter", "full", "code-basic", "search", "search-full"]
 
 
 def create_agent_for_mode(mode: str, model_name: str, vision_model_name: str | None) -> Agent:
@@ -53,9 +53,12 @@ def create_agent_for_mode(mode: str, model_name: str, vision_model_name: str | N
         return create_interpreter_agent(model_name, vision_model_name)
     elif mode == "search":
         return create_search_agent(model_name)
+    if mode == "search-full":
+        return create_search_agent(model_name, mode_full=True)
     else:
         raise ValueError(f"Unknown agent mode: {mode}")
 
+
 def check_new_version():
     # Randomly check for updates (1 in 10 chance)
     if random.randint(1, 10) == 1:
@@ -81,6 +84,7 @@ def check_new_version():
         except Exception:
             return
 
+
 def configure_logger(log_level: str) -> None:
     """Configure the logger with the specified log level and format."""
     logger.remove()
@@ -122,7 +126,9 @@ def get_task_from_file(file_path: str) -> str:
         raise Exception(f"Unexpected error reading file: {e}")
 
 
-def display_welcome_message(console: Console, model_name: str, vision_model_name: str | None) -> None:
+def display_welcome_message(
+    console: Console, model_name: str, vision_model_name: str | None, max_iterations: int = 50
+) -> None:
     """Display the welcome message and instructions."""
     version = get_version()
     console.print(
@@ -135,7 +141,8 @@ def display_welcome_message(console: Console, model_name: str, vision_model_name
             f"[yellow] 🤖 System Info:[/yellow]\n\n"
             "\n"
             f"- Model: {model_name}\n"
-            f"- Vision Model: {vision_model_name}\n\n"
+            f"- Vision Model: {vision_model_name}\n"
+            f"- Max Iterations: {max_iterations}\n\n"
             "[bold magenta]💡 Pro Tips:[/bold magenta]\n\n"
             "- Be as specific as possible in your task description to get the best results!\n"
             "- Use clear and concise language when describing your task\n"
@@ -167,6 +174,12 @@ def display_welcome_message(console: Console, model_name: str, vision_model_name
     default=None,
     help='Specify the vision model to use (litellm format, e.g. "openrouter/A/gpt-4o-mini").',
 )
+@click.option(
+    "--max-iterations",
+    type=int,
+    default=30,
+    help="Maximum number of iterations for task solving (default: 30).",
+)
 @click.pass_context
 def cli(
     ctx: click.Context,
@@ -176,6 +189,7 @@ def cli(
     mode: str,
     log: str,
     vision_model_name: str | None,
+    max_iterations: int,
 ) -> None:
     """QuantaLogic AI Assistant - A powerful AI tool for various tasks."""
     if version:
@@ -184,7 +198,13 @@ def cli(
         sys.exit(0)
     if ctx.invoked_subcommand is None:
         ctx.invoke(
-            task, model_name=model_name, verbose=verbose, mode=mode, log=log, vision_model_name=vision_model_name
+            task,
+            model_name=model_name,
+            verbose=verbose,
+            mode=mode,
+            log=log,
+            vision_model_name=vision_model_name,
+            max_iterations=max_iterations,
         )
 
 
@@ -208,6 +228,12 @@ def cli(
     default=None,
     help='Specify the vision model to use (litellm format, e.g. "openrouter/openai/gpt-4o-mini").',
 )
+@click.option(
+    "--max-iterations",
+    type=int,
+    default=30,
+    help="Maximum number of iterations for task solving (default: 30).",
+)
 @click.argument("task", required=False)
 def task(
     file: Optional[str],
@@ -217,12 +243,12 @@ def task(
     log: str,
     vision_model_name: str | None,
     task: Optional[str],
+    max_iterations: int,
 ) -> None:
     """Execute a task with the QuantaLogic AI Assistant."""
     console = Console()
     switch_verbose(verbose, log)
 
-
     try:
         if file:
             task_content = get_task_from_file(file)
@@ -231,7 +257,7 @@ def task(
                 check_new_version()
                 task_content = task
             else:
-                display_welcome_message(console, model_name, vision_model_name)
+                display_welcome_message(console, model_name, vision_model_name, max_iterations=max_iterations)
                 check_new_version()
                 logger.debug("Waiting for user input...")
                 task_content = get_multiline_input(console).strip()
@@ -241,14 +267,13 @@ def task(
                     console.print("[yellow]No task provided. Exiting...[/yellow]")
                     sys.exit(2)
 
-        if model_name != MODEL_NAME:
-            console.print(
-                Panel.fit(
-                    f"[bold]Task to be submitted:[/bold]\n{task_content}",
-                    title="[bold]Task Preview[/bold]",
-                    border_style="blue",
-                )
+        console.print(
+            Panel.fit(
+                f"[bold]Task to be submitted:[/bold]\n{task_content}",
+                title="[bold]Task Preview[/bold]",
+                border_style="blue",
             )
+        )
         if not Confirm.ask("[bold]Are you sure you want to submit this task?[/bold]"):
             console.print("[yellow]Task submission cancelled. Exiting...[/yellow]")
             sys.exit(0)
@@ -284,8 +309,10 @@ def task(
         logger.debug("Registered event handlers for agent events with events: {events}")
 
         logger.debug(f"Solving task with agent: {task_content}")
-        result = agent.solve_task(task=task_content, max_iterations=300)
-        logger.debug(f"Task solved with result: {result}")
+        if max_iterations < 1:
+            raise ValueError("max_iterations must be greater than 0")
+        result = agent.solve_task(task=task_content, max_iterations=max_iterations)
+        logger.debug(f"Task solved with result: {result} using {max_iterations} iterations")
 
         console.print(
             Panel.fit(

{quantalogic-0.2.14 → quantalogic-0.2.16}/quantalogic/prompts.py

@@ -90,4 +90,5 @@ Every response must contain exactly two XML blocks:
 
 ### Environment Details
 {environment}
+
 """

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

@@ -1,16 +1,27 @@
 from quantalogic.agent import Agent
-from quantalogic.tools import InputQuestionTool, SerpApiSearchTool, TaskCompleteTool, WikipediaSearchTool, ReadFileBlockTool,ReadFileTool, MarkitdownTool, RipgrepTool
+from quantalogic.tools import (
+    DuckDuckGoSearchTool,
+    InputQuestionTool,
+    MarkitdownTool,
+    ReadFileBlockTool,
+    ReadFileTool,
+    RipgrepTool,
+    SerpApiSearchTool,
+    TaskCompleteTool,
+    WikipediaSearchTool,
+)
 
 
-def create_search_agent(model_name: str) -> Agent:
-    """Creates and configures a search agent with web and knowledge search tools.
+def create_search_agent(model_name: str, mode_full: bool = False) -> Agent:
+    """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
+        mode_full (bool, optional): If True, the agent will be configured with a full set of tools.
 
     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
     """
@@ -21,7 +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
@@ -34,6 +45,14 @@ def create_search_agent(model_name: str) -> Agent:
         RipgrepTool(),  # Code search capabilities
     ]
 
+    if mode_full:
+        tools.extend(
+            [
+                # Search tools
+                SerpApiSearchTool(),  # Web search capabilities
+            ]
+        )
+
     return Agent(
         model_name=model_name,
         tools=tools,

{quantalogic-0.2.14 → quantalogic-0.2.16}/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.16/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.16}/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)