quantalogic 0.35.0__py3-none-any.whl → 0.40.0__py3-none-any.whl

quantalogic/{llm.py → quantlitellm.py}

@@ -1,21 +1,8 @@
-"""LLM wrapper module for handling LiteLLM operations."""
-
-__all__ = [
-    "generate_completion",
-    "generate_image",
-    "count_tokens",
-    "get_model_max_input_tokens",
-    "get_model_max_output_tokens",
-]
-
+# quantlitellm.py
 import os
-from typing import Any, Dict, List
+from typing import Any, Dict
 
-from litellm import (
-    completion,
-    image_generation,
-    token_counter,
-)
+from litellm import aimage_generation, exceptions, token_counter
 from loguru import logger
 
 from quantalogic.get_model_info import (
@@ -25,11 +12,6 @@ from quantalogic.get_model_info import (
 )
 
 
-def get_model_info(model_name: str) -> dict | None:
-    """Get model information for a given model name."""
-    return model_info.get(model_name, None)
-
-
 class ModelProviderConfig:
     def __init__(self, prefix: str, provider: str, base_url: str, env_var: str):
         self.prefix = prefix
@@ -53,44 +35,47 @@ PROVIDERS = {
         prefix="dashscope/",
         provider="openai",
         base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
-        env_var="DASHSCOPE_API_KEY"
+        env_var="DASHSCOPE_API_KEY",
     ),
     "nvidia": ModelProviderConfig(
-        prefix="nvidia/",
-        provider="openai",
-        base_url="https://integrate.api.nvidia.com/v1",
-        env_var="NVIDIA_API_KEY"
+        prefix="nvidia/", provider="openai", base_url="https://integrate.api.nvidia.com/v1", env_var="NVIDIA_API_KEY"
     ),
     "ovh": ModelProviderConfig(
         prefix="ovh/",
         provider="openai",
         base_url="https://deepseek-r1-distill-llama-70b.endpoints.kepler.ai.cloud.ovh.net/api/openai_compat/v1",
-        env_var="OVH_API_KEY"
-    )
+        env_var="OVH_API_KEY",
+    ),
 }
 
 
-def generate_completion(**kwargs: Dict[str, Any]) -> Any:
+async def acompletion(**kwargs: Dict[str, Any]) -> Any:
     """Wraps litellm completion with proper type hints."""
     model = kwargs.get("model", "")
-    
+
     # Find matching provider
     for provider_name, provider_config in PROVIDERS.items():
         if model.startswith(provider_config.prefix):
             provider_config.configure(model, kwargs)
             break
-    
-    return completion(**kwargs)
 
+    from litellm import acompletion
 
-def generate_image(**kwargs: Dict[str, Any]) -> Any:
-    """Wraps litellm image_generation with proper type hints."""
-    return image_generation(**kwargs)
+    return await acompletion(**kwargs)
 
 
-def count_tokens(model: str, messages: List[Dict[str, Any]]) -> int:
-    """Wraps litellm token_counter with proper type hints."""
-    return token_counter(model=model, messages=messages)
+# Expose the imported litellm components directly
+__all__ = ["acompletion", "aimage_generation", "exceptions", "token_counter"]
+
+
+def suppress_lite_llm_debug_logging():
+    """Suppress debug logging from LiteLLM library."""
+    from litellm import litellm
+
+    litellm.suppress_debug_info = True  # Very important to suppress prints don't remove
+
+
+suppress_lite_llm_debug_logging()
 
 
 def _get_model_info_impl(model_name: str) -> dict:
@@ -170,4 +155,9 @@ def get_model_max_output_tokens(model_name: str) -> int | None:
 
     except Exception as e:
         logger.error(f"Error getting max output tokens for {model_name}: {e}")
-        return None
+        return None
+
+
+def get_model_info(model_name: str) -> dict | None:
+    """Get model information for a given model name."""
+    return model_info.get(model_name, None)

quantalogic/search_agent.py

@@ -13,11 +13,11 @@ from quantalogic.tools import (
 
 
 def create_search_agent(
-    model_name: str, 
-    mode_full: bool = False, 
-    no_stream: bool = False, 
+    model_name: str,
+    mode_full: bool = False,
+    no_stream: bool = False,
     compact_every_n_iteration: int | None = None,
-    max_tokens_working_memory: int | None = None
+    max_tokens_working_memory: int | None = None,
 ) -> Agent:
     """Creates and configures a search agent with web, knowledge, and privacy-focused search tools.
 

quantalogic/server/models.py

@@ -1,6 +1,6 @@
 """Pydantic models for the QuantaLogic API."""
 
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional
 
 from pydantic import BaseModel
 
@@ -42,6 +42,9 @@ class TaskSubmission(BaseModel):
     task: str
     model_name: Optional[str] = MODEL_NAME
     max_iterations: Optional[int] = 30
+    mode: Optional[str] = "minimal"
+    expertise: Optional[str] = ""
+    tools: Optional[List[Dict[str, Any]]] = None
 
     model_config = {"extra": "forbid"}
 

quantalogic/task_file_reader.py

@@ -5,13 +5,13 @@ import requests
 
 def get_task_from_file(source: str) -> str:
     """Get task content from specified file path or URL.
-    
+
     Args:
         source (str): File path or URL to read task content from
-    
+
     Returns:
         str: Stripped task content from the file or URL
-    
+
     Raises:
         FileNotFoundError: If the local file does not exist
         PermissionError: If there are permission issues reading the file
@@ -20,11 +20,11 @@ def get_task_from_file(source: str) -> str:
     """
     try:
         # Check if source is a URL
-        if source.startswith(('http://', 'https://')):
+        if source.startswith(("http://", "https://")):
             response = requests.get(source, timeout=10)
             response.raise_for_status()  # Raise an exception for bad status codes
             return response.text.strip()
-        
+
         # If not a URL, treat as a local file path
         with open(source, encoding="utf-8") as f:
             return f.read().strip()

quantalogic/task_runner.py

@@ -84,16 +84,16 @@ def interactive_task_runner(
     while True:
         logger.debug("Waiting for user input...")
         task_content = get_multiline_input(console).strip()
-        
+
         if not task_content:
             logger.info("No task provided. Exiting...")
             console.print("[yellow]No task provided. Exiting...[/yellow]")
             break
 
         # Handle commands with single return
-        if task_content.startswith('/'):
+        if task_content.startswith("/"):
             command = task_content.lower()
-            if command == '/clear':
+            if command == "/clear":
                 logger.info("Clearing agent memory...")
                 console.print("[yellow]Clearing agent memory...[/yellow]")
                 agent.clear_memory()
@@ -111,7 +111,7 @@ def interactive_task_runner(
                 border_style="blue",
             )
         )
-        
+
         if not Confirm.ask("[bold]Are you sure you want to submit this task?[/bold]"):
             console.print("[yellow]Task submission cancelled.[/yellow]")
             if not Confirm.ask("[bold]Would you like to ask another question?[/bold]"):
@@ -127,14 +127,14 @@ def interactive_task_runner(
         )
 
         logger.debug(f"Solving task with agent: {task_content}")
-        result = agent.solve_task(task=task_content, max_iterations=max_iterations, streaming=not no_stream,clear_memory=False)
+        result = agent.solve_task(
+            task=task_content, max_iterations=max_iterations, streaming=not no_stream, clear_memory=False
+        )
         logger.debug(f"Task solved with result: {result} using {max_iterations} iterations")
 
         console.print(
             Panel.fit(
-                f"[bold]Task Result:[/bold]\n{result}",
-                title="[bold]Execution Output[/bold]",
-                border_style="green"
+                f"[bold]Task Result:[/bold]\n{result}", title="[bold]Execution Output[/bold]", border_style="green"
             )
         )
 
@@ -165,7 +165,7 @@ def task_runner(
         vision_model_name=config.vision_model_name,
         thinking_model_name=config.thinking_model_name,
         compact_every_n_iteration=config.compact_every_n_iteration,
-        max_tokens_working_memory=config.max_tokens_working_memory
+        max_tokens_working_memory=config.max_tokens_working_memory,
     )
 
     AgentRegistry.register_agent("main_agent", agent)
@@ -176,14 +176,14 @@ def task_runner(
         logger.debug(f"Solving task with agent: {task_content}")
         if config.max_iterations < 1:
             raise ValueError("max_iterations must be greater than 0")
-        result = agent.solve_task(task=task_content, max_iterations=config.max_iterations, streaming=not config.no_stream)
+        result = agent.solve_task(
+            task=task_content, max_iterations=config.max_iterations, streaming=not config.no_stream
+        )
         logger.debug(f"Task solved with result: {result} using {config.max_iterations} iterations")
 
         console.print(
             Panel.fit(
-                f"[bold]Task Result:[/bold]\n{result}",
-                title="[bold]Execution Output[/bold]",
-                border_style="green"
+                f"[bold]Task Result:[/bold]\n{result}", title="[bold]Execution Output[/bold]", border_style="green"
             )
         )
     else:
@@ -194,14 +194,14 @@ def task_runner(
             logger.debug(f"Solving task with agent: {task_content}")
             if config.max_iterations < 1:
                 raise ValueError("max_iterations must be greater than 0")
-            result = agent.solve_task(task=task_content, max_iterations=config.max_iterations, streaming=not config.no_stream)
+            result = agent.solve_task(
+                task=task_content, max_iterations=config.max_iterations, streaming=not config.no_stream
+            )
             logger.debug(f"Task solved with result: {result} using {config.max_iterations} iterations")
 
             console.print(
                 Panel.fit(
-                    f"[bold]Task Result:[/bold]\n{result}",
-                    title="[bold]Execution Output[/bold]",
-                    border_style="green"
+                    f"[bold]Task Result:[/bold]\n{result}", title="[bold]Execution Output[/bold]", border_style="green"
                 )
             )
         else:
@@ -234,7 +234,7 @@ def task_runner(
                 "memory_summary",
             ]
 
-            #def ask_continue(event: str, data: any) -> None:
+            # def ask_continue(event: str, data: any) -> None:
             #    ## Ask for ctrl+return
             #    if event == "task_think_end":
             #        ## Wait return on the keyboard
@@ -253,10 +253,10 @@ def task_runner(
                 if data is not None:
                     console.print(data, end="", markup=False)
 
-            #agent.event_emitter.on(
+            # agent.event_emitter.on(
             #    event="task_think_end",
             #    listener=ask_continue,
-            #)
+            # )
 
             agent.event_emitter.on(
                 event=events,

quantalogic/tool_manager.py

@@ -67,18 +67,16 @@ class ToolManager(BaseModel):
             index += 1
         return markdown
 
-
-
     def validate_and_convert_arguments(self, tool_name: str, provided_args: dict) -> dict:
         """Validates and converts arguments based on tool definition.
-        
+
         Args:
             tool_name: Name of the tool to validate against
             provided_args: Dictionary of arguments to validate
-            
+
         Returns:
             Dictionary of converted arguments with proper types
-            
+
         Raises:
             ValueError: For missing/invalid arguments or conversion errors
         """
@@ -88,7 +86,7 @@ class ToolManager(BaseModel):
             "string": lambda x: str(x),
             "int": lambda x: int(x),
             "float": lambda x: float(x),
-            "bool": lambda x: str(x).lower() in ['true', '1', 'yes']
+            "bool": lambda x: str(x).lower() in ["true", "1", "yes"],
         }
 
         for arg_def in tool.arguments:
@@ -108,12 +106,7 @@ class ToolManager(BaseModel):
             value = provided_args[arg_name]
 
             # Handle empty string for non-string types by replacing with default if available
-            if (
-                arg_type != "string"
-                and isinstance(value, str)
-                and value.strip() == ""
-                and default is not None
-            ):
+            if arg_type != "string" and isinstance(value, str) and value.strip() == "" and default is not None:
                 logger.debug(f"Replaced empty string for argument {arg_name} with default value {default}")
                 value = default
                 provided_args[arg_name] = value  # Update to ensure validation uses the default
@@ -123,9 +116,7 @@ class ToolManager(BaseModel):
                 try:
                     converted = type_conversion[arg_type](value)
                 except (ValueError, TypeError) as e:
-                    raise ValueError(
-                        f"Invalid value '{value}' for {arg_name} ({arg_type}): {str(e)}"
-                    )
+                    raise ValueError(f"Invalid value '{value}' for {arg_name} ({arg_type}): {str(e)}")
                 converted_args[arg_name] = converted
             else:
                 converted_args[arg_name] = value  # Unknown type, pass through
@@ -154,14 +145,14 @@ class ToolManager(BaseModel):
             "string": lambda x: str(x),
             "int": lambda x: int(x),
             "float": lambda x: float(x),
-            "bool": lambda x: str(x).lower() in ['true', '1', 'yes']
+            "bool": lambda x: str(x).lower() in ["true", "1", "yes"],
         }
 
         for arg_def in tool.arguments:
             arg_name = arg_def.name
             arg_type = arg_def.arg_type
             required = arg_def.required
-            default = getattr(arg_def, 'default', None)
+            default = getattr(arg_def, "default", None)
 
             # Handle missing arguments
             if arg_name not in provided_args:
@@ -177,9 +168,7 @@ class ToolManager(BaseModel):
                 try:
                     converted = type_conversion[arg_type](value)
                 except (ValueError, TypeError) as e:
-                    raise ValueError(
-                        f"Invalid value '{value}' for {arg_name} ({arg_type}): {str(e)}"
-                    )
+                    raise ValueError(f"Invalid value '{value}' for {arg_name} ({arg_type}): {str(e)}")
                 converted_args[arg_name] = converted
             else:
                 converted_args[arg_name] = value  # Unknown type, pass through
@@ -189,4 +178,4 @@ class ToolManager(BaseModel):
         if extra_args:
             raise ValueError(f"Unexpected arguments: {', '.join(extra_args)}")
 
-        return converted_args
+        return converted_args

quantalogic/tools/__init__.py

@@ -1,71 +1,101 @@
 """Tools for the QuantaLogic agent."""
 
-from .agent_tool import AgentTool
-from .dalle_e import LLMImageGenerationTool
-from .download_http_file_tool import DownloadHttpFileTool
-from .duckduckgo_search_tool import DuckDuckGoSearchTool
-from .edit_whole_content_tool import EditWholeContentTool
-from .elixir_tool import ElixirTool
-from .execute_bash_command_tool import ExecuteBashCommandTool
-from .generate_database_report_tool import GenerateDatabaseReportTool
-from .grep_app_tool import GrepAppTool
-from .input_question_tool import InputQuestionTool
-from .jinja_tool import JinjaTool
-from .list_directory_tool import ListDirectoryTool
-from .llm_tool import LLMTool
-from .llm_vision_tool import LLMVisionTool
-from .markitdown_tool import MarkitdownTool
-from .nodejs_tool import NodeJsTool
-from .python_tool import PythonTool
-from .read_file_block_tool import ReadFileBlockTool
-from .read_file_tool import ReadFileTool
-from .read_html_tool import ReadHTMLTool
-from .replace_in_file_tool import ReplaceInFileTool
-from .ripgrep_tool import RipgrepTool
-from .safe_python_interpreter_tool import SafePythonInterpreterTool
-from .search_definition_names import SearchDefinitionNames
-from .sequence_tool import SequenceTool
-from .serpapi_search_tool import SerpApiSearchTool
-from .sql_query_tool import SQLQueryTool
-from .task_complete_tool import TaskCompleteTool
-from .tool import Tool, ToolArgument
-from .unified_diff_tool import UnifiedDiffTool
-from .wikipedia_search_tool import WikipediaSearchTool
-from .write_file_tool import WriteFileTool
+import importlib
+import sys
+from typing import Any, Dict
 
-__all__ = [
-    "WikipediaSearchTool",
-    "SerpApiSearchTool",
-    "DuckDuckGoSearchTool",
-    "Tool",
-    "ToolArgument",
-    "TaskCompleteTool",
-    "ReadFileTool",
-    "WriteFileTool",
-    "InputQuestionTool",
-    "ListDirectoryTool",
-    "LLMTool",
-    "LLMVisionTool",
-    "ExecuteBashCommandTool",
-    "PythonTool",
-    "ElixirTool",
-    "NodeJsTool",
-    "UnifiedDiffTool",
-    "ReplaceInFileTool",
-    "AgentTool",
-    "ReadFileBlockTool",
-    "RipgrepTool",
-    "SearchDefinitionNames",
-    "MarkitdownTool",
-    "DownloadHttpFileTool",
-    "EditWholeContentTool",
-    "JinjaTool",
-    "LLMImageGenerationTool",
-    "ReadHTMLTool",
-    "GrepAppTool",
-    "GenerateDatabaseReportTool",
-    'SQLQueryTool',
-    'SafePythonInterpreterTool'
-    'LLMGenerationTool',
-    'SequenceTool'
-]
+
+class LazyLoader:
+    """
+    Lazily import a module only when its attributes are accessed.
+    This helps reduce startup time by deferring imports until needed.
+    """
+    def __init__(self, module_path: str):
+        self.module_path = module_path
+        self._module = None
+
+    def __getattr__(self, name: str) -> Any:
+        if self._module is None:
+            self._module = importlib.import_module(self.module_path)
+        return getattr(self._module, name)
+
+
+# Map of tool names to their import paths
+_TOOL_IMPORTS = {
+    "AgentTool": ".agent_tool",
+    "ComposioTool": ".composio.composio",
+    "GenerateDatabaseReportTool": ".database.generate_database_report_tool",
+    "SQLQueryToolAdvanced": ".database.sql_query_tool_advanced",
+    "MarkdownToDocxTool": ".document_tools.markdown_to_docx_tool",
+    "MarkdownToEpubTool": ".document_tools.markdown_to_epub_tool",
+    "MarkdownToHtmlTool": ".document_tools.markdown_to_html_tool",
+    "MarkdownToIpynbTool": ".document_tools.markdown_to_ipynb_tool",
+    "MarkdownToLatexTool": ".document_tools.markdown_to_latex_tool",
+    "MarkdownToPdfTool": ".document_tools.markdown_to_pdf_tool",
+    "MarkdownToPptxTool": ".document_tools.markdown_to_pptx_tool",
+    "DownloadHttpFileTool": ".download_http_file_tool",
+    "DuckDuckGoSearchTool": ".duckduckgo_search_tool",
+    "EditWholeContentTool": ".edit_whole_content_tool",
+    "ElixirTool": ".elixir_tool",
+    "ExecuteBashCommandTool": ".execute_bash_command_tool",
+    "BitbucketCloneTool": ".git.bitbucket_clone_repo_tool",
+    "BitbucketOperationsTool": ".git.bitbucket_operations_tool",
+    "CloneRepoTool": ".git.clone_repo_tool",
+    "GitOperationsTool": ".git.git_operations_tool",
+    "GoogleNewsTool": ".google_packages.google_news_tool",
+    "GrepAppTool": ".grep_app_tool",
+    "LLMImageGenerationTool": ".image_generation.dalle_e",
+    "InputQuestionTool": ".input_question_tool",
+    "JinjaTool": ".jinja_tool",
+    "ListDirectoryTool": ".list_directory_tool",
+    "LLMTool": ".llm_tool",
+    "LLMVisionTool": ".llm_vision_tool",
+    "MarkitdownTool": ".markitdown_tool",
+    "NasaApodTool": ".nasa_packages.nasa_apod_tool",
+    "NasaNeoWsTool": ".nasa_packages.nasa_neows_tool",
+    "NodeJsTool": ".nodejs_tool",
+    "PresentationLLMTool": ".presentation_tools.presentation_llm_tool",
+    "ProductHuntTool": ".product_hunt.product_hunt_tool",
+    "PythonTool": ".python_tool",
+    "RagTool": ".rag_tool.rag_tool",
+    "ReadFileBlockTool": ".read_file_block_tool",
+    "ReadFileTool": ".read_file_tool",
+    "ReadHTMLTool": ".read_html_tool",
+    "ReplaceInFileTool": ".replace_in_file_tool",
+    "RipgrepTool": ".ripgrep_tool",
+    "SafePythonInterpreterTool": ".safe_python_interpreter_tool",
+    "SearchDefinitionNames": ".search_definition_names",
+    "SequenceTool": ".sequence_tool",
+    "SerpApiSearchTool": ".serpapi_search_tool",
+    "SQLQueryTool": ".sql_query_tool",
+    "TaskCompleteTool": ".task_complete_tool",
+    "Tool": ".tool",
+    "ToolArgument": ".tool",
+    "UnifiedDiffTool": ".unified_diff_tool",
+    "CSVProcessorTool": ".utilities.csv_processor_tool",
+    "PrepareDownloadTool": ".utilities.download_file_tool",
+    "MermaidValidatorTool": ".utilities.mermaid_validator_tool",
+    "WikipediaSearchTool": ".wikipedia_search_tool",
+    "WriteFileTool": ".write_file_tool",
+}
+
+# Create lazy loaders for each module path
+_lazy_modules: Dict[str, LazyLoader] = {}
+for tool, path in _TOOL_IMPORTS.items():
+    full_path = f"{__package__}{path}"
+    if full_path not in _lazy_modules:
+        _lazy_modules[full_path] = LazyLoader(full_path)
+
+# Set up attributes for lazy loading
+_tools_to_lazy_modules = {}
+for tool, path in _TOOL_IMPORTS.items():
+    full_path = f"{__package__}{path}"
+    _tools_to_lazy_modules[tool] = _lazy_modules[full_path]
+
+# Define __all__ so that import * works properly
+__all__ = list(_TOOL_IMPORTS.keys())
+
+# Set up lazy loading for each tool
+for tool, lazy_module in _tools_to_lazy_modules.items():
+    # This will create properties that lazily load the requested tool
+    setattr(sys.modules[__name__], tool, getattr(lazy_module, tool))