quantalogic 0.50.12__tar.gz → 0.50.17__tar.gz

{quantalogic-0.50.12 → quantalogic-0.50.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantalogic
-Version: 0.50.12
+Version: 0.50.17
 Summary: QuantaLogic ReAct Agents
 Author: Raphaël MANSUY
 Author-email: raphael.mansuy@gmail.com

{quantalogic-0.50.12 → quantalogic-0.50.17}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "quantalogic"
-version = "0.50.12"
+version = "0.50.17"
 description = "QuantaLogic ReAct Agents"
 authors = ["Raphaël MANSUY <raphael.mansuy@gmail.com>"]
 readme = "README.md"
@@ -30,6 +30,12 @@ optional = false
 
 [tool.poetry.group.file-tools.dependencies]
 python-dotenv = "^1.0.1"
+
+# Optional group for git-related tools
+[tool.poetry.group.git-tools]
+optional = true
+
+[tool.poetry.group.git-tools.dependencies]
 gitpython = "^3.1.44"
 
 # Optional group for search-related tools

quantalogic-0.50.17/quantalogic/agent_config.py

@@ -0,0 +1,262 @@
+"""Module for agent configuration and creation."""
+
+# Standard library imports
+
+# Local application imports
+import logging
+
+from dotenv import load_dotenv
+
+from quantalogic.agent import Agent
+from quantalogic.console_print_token import console_print_token
+from quantalogic.tools import (
+    AgentTool,
+    DownloadHttpFileTool,
+    DuckDuckGoSearchTool,
+    EditWholeContentTool,
+    ExecuteBashCommandTool,
+    InputQuestionTool,
+    ListDirectoryTool,
+    LLMTool,
+    LLMVisionTool,
+    MarkitdownTool,
+    NodeJsTool,
+    PythonTool,
+    ReadFileBlockTool,
+    ReadFileTool,
+    ReadHTMLTool,
+    ReplaceInFileTool,
+    RipgrepTool,
+    SearchDefinitionNames,
+    TaskCompleteTool,
+    WikipediaSearchTool,
+    WriteFileTool,
+)
+from quantalogic.tools.image_generation import LLMImageGenerationTool
+
+load_dotenv()
+
+MODEL_NAME = "deepseek/deepseek-chat"
+
+logger = logging.getLogger(__name__)
+
+_current_model_name: str = ""
+
+
+def get_current_model() -> str:
+    """Retrieve the currently active model name."""
+    if not _current_model_name:
+        raise ValueError("No model initialized")
+    return _current_model_name
+
+
+def create_agent(
+    model_name: str,
+    vision_model_name: str | None,
+    no_stream: bool = False,
+    compact_every_n_iteration: int | None = None,
+    max_tokens_working_memory: int | None = None,
+) -> Agent:
+    global _current_model_name
+    _current_model_name = model_name
+    """Create an agent with the specified model and tools.
+
+    Args:
+        model_name (str): Name of the model to use
+        vision_model_name (str | None): Name of the vision model to use
+        no_stream (bool, optional): If True, the agent will not stream results.
+        compact_every_n_iteration (int | None, optional): Frequency of memory compaction.
+        max_tokens_working_memory (int | None, optional): Maximum tokens for working memory.
+
+    Returns:
+        Agent: An agent with the specified model and tools
+    """
+    tools = [
+        TaskCompleteTool(),
+        ReadFileTool(),
+        ReadFileBlockTool(),
+        WriteFileTool(),
+        EditWholeContentTool(),
+        InputQuestionTool(),
+        ListDirectoryTool(),
+        ExecuteBashCommandTool(),
+        ReplaceInFileTool(),
+        RipgrepTool(),
+        SearchDefinitionNames(),
+        MarkitdownTool(),
+        LLMTool(model_name=model_name, on_token=console_print_token if not no_stream else None),
+        DownloadHttpFileTool(), 
+        LLMImageGenerationTool(
+            provider="dall-e", model_name="openai/dall-e-3", on_token=console_print_token if not no_stream else None
+        ),
+        ReadHTMLTool(),
+       # SafePythonInterpreterTool(allowed_modules=["math", "numpy"])
+    ]
+
+    if vision_model_name:
+        tools.append(
+            LLMVisionTool(model_name=vision_model_name, on_token=console_print_token if not no_stream else None)
+        )
+
+    return Agent(
+        model_name=model_name,
+        tools=tools,
+        compact_every_n_iterations=compact_every_n_iteration,
+        max_tokens_working_memory=max_tokens_working_memory,
+    )
+
+
+def create_interpreter_agent(
+    model_name: str,
+    vision_model_name: str | None,
+    no_stream: bool = False,
+    compact_every_n_iteration: int | None = None,
+    max_tokens_working_memory: int | None = None,
+) -> Agent:
+    """Create an interpreter agent with the specified model and tools.
+
+    Args:
+        model_name (str): Name of the model to use
+        vision_model_name (str | None): Name of the vision model to use
+        no_stream (bool, optional): If True, the agent will not stream results.
+        compact_every_n_iteration (int | None, optional): Frequency of memory compaction.
+        max_tokens_working_memory (int | None, optional): Maximum tokens for working memory.
+
+    Returns:
+        Agent: An interpreter agent with the specified model and tools
+    """
+    tools = [
+        TaskCompleteTool(),
+        ReadFileTool(),
+        ReadFileBlockTool(),
+        WriteFileTool(),
+        EditWholeContentTool(),
+        InputQuestionTool(),
+        ListDirectoryTool(),
+        ExecuteBashCommandTool(),
+        ReplaceInFileTool(),
+        RipgrepTool(),
+        PythonTool(),
+        NodeJsTool(),
+        SearchDefinitionNames(),
+        MarkitdownTool(),
+        LLMTool(model_name=model_name, on_token=console_print_token if not no_stream else None),
+        DownloadHttpFileTool(),
+        ReadHTMLTool(),
+    ]
+    return Agent(
+        model_name=model_name,
+        tools=tools,
+        compact_every_n_iterations=compact_every_n_iteration,
+        max_tokens_working_memory=max_tokens_working_memory,
+    )
+
+
+def create_full_agent(
+    model_name: str,
+    vision_model_name: str | None,
+    no_stream: bool = False,
+    compact_every_n_iteration: int | None = None,
+    max_tokens_working_memory: int | None = None,
+) -> Agent:
+    """Create an agent with the specified model and many tools.
+
+    Args:
+        model_name (str): Name of the model to use
+        vision_model_name (str | None): Name of the vision model to use
+        no_stream (bool, optional): If True, the agent will not stream results.
+        compact_every_n_iteration (int | None, optional): Frequency of memory compaction.
+        max_tokens_working_memory (int | None, optional): Maximum tokens for working memory.
+
+    Returns:
+        Agent: An agent with the specified model and tools
+
+    """
+    tools = [
+        TaskCompleteTool(),
+        ReadFileTool(),
+        ReadFileBlockTool(),
+        WriteFileTool(),
+        EditWholeContentTool(),
+        InputQuestionTool(),
+        ListDirectoryTool(),
+        ExecuteBashCommandTool(),
+        ReplaceInFileTool(),
+        RipgrepTool(),
+        PythonTool(),
+        NodeJsTool(),
+        SearchDefinitionNames(),
+        MarkitdownTool(),
+        LLMTool(model_name=model_name, on_token=console_print_token if not no_stream else None),
+        DownloadHttpFileTool(),
+        WikipediaSearchTool(),
+        DuckDuckGoSearchTool(),
+        ReadHTMLTool(),
+        #  SafePythonInterpreterTool(allowed_modules=["math", "numpy"])
+    ]
+
+    if vision_model_name:
+        tools.append(
+            LLMVisionTool(model_name=vision_model_name, on_token=console_print_token if not no_stream else None)
+        )
+
+    return Agent(
+        model_name=model_name,
+        tools=tools,
+        compact_every_n_iterations=compact_every_n_iteration,
+        max_tokens_working_memory=max_tokens_working_memory,
+    )
+
+
+def create_basic_agent(
+    model_name: str,
+    vision_model_name: str | None = None,
+    no_stream: bool = False,
+    compact_every_n_iteration: int | None = None,
+    max_tokens_working_memory: int | None = None,
+) -> Agent:
+    """Create an agent with the specified model and tools.
+
+    Args:
+        model_name (str): Name of the model to use
+        vision_model_name (str | None): Name of the vision model to use
+        no_stream (bool, optional): If True, the agent will not stream results.
+        compact_every_n_iteration (int | None, optional): Frequency of memory compaction.
+        max_tokens_working_memory (int | None, optional): Maximum tokens for working memory.
+
+    Returns:
+        Agent: An agent with the specified model and tools
+    """
+    # Rebuild AgentTool to resolve forward references
+    AgentTool.model_rebuild()
+
+    tools = [
+        TaskCompleteTool(),
+        ListDirectoryTool(),
+        ReadFileBlockTool(),
+        SearchDefinitionNames(),
+        ReadFileTool(),
+        ReplaceInFileTool(),
+        WriteFileTool(),
+        EditWholeContentTool(),
+        ReplaceInFileTool(),
+        InputQuestionTool(),
+        ExecuteBashCommandTool(),
+        LLMTool(model_name=model_name, on_token=console_print_token if not no_stream else None),
+        ReadHTMLTool(),
+        #    SafePythonInterpreterTool(allowed_modules=["math", "numpy"])
+    ]
+
+    if vision_model_name:
+        tools.append(
+            LLMVisionTool(model_name=vision_model_name, on_token=console_print_token if not no_stream else None)
+        )
+
+    return Agent(
+        model_name=model_name,
+        tools=tools,
+        compact_every_n_iterations=compact_every_n_iteration,
+        max_tokens_working_memory=max_tokens_working_memory,
+    )
+
+

{quantalogic-0.50.12 → quantalogic-0.50.17}/quantalogic/agent_factory.py

@@ -5,7 +5,6 @@ from loguru import logger
 from quantalogic.agent import Agent
 from quantalogic.agent_config import (
     create_basic_agent,
-    create_custom_agent,
     create_full_agent,
     create_interpreter_agent,
 )
@@ -171,17 +170,17 @@ def create_agent_for_mode(
             max_tokens_working_memory=max_tokens_working_memory,
         )
         return agent
-    if mode == "custom":
-        agent = create_custom_agent(
-            model_name,
-            vision_model_name,
-            no_stream=no_stream,
-            compact_every_n_iteration=compact_every_n_iteration,
-            max_tokens_working_memory=max_tokens_working_memory,
-            specific_expertise=specific_expertise,
-            tools=tools,
-            memory=memory
-        )
-        return agent
+#    if mode == "custom":
+#        agent = create_custom_agent(
+#            model_name,
+#            vision_model_name,
+#            no_stream=no_stream,
+#            compact_every_n_iteration=compact_every_n_iteration,
+#            max_tokens_working_memory=max_tokens_working_memory,
+#            specific_expertise=specific_expertise,
+#            tools=tools,
+#            memory=memory
+#        )
+#        return agent
     else:
         raise ValueError(f"Unknown agent mode: {mode}")

{quantalogic-0.50.12 → quantalogic-0.50.17}/quantalogic/coding_agent.py

@@ -52,7 +52,7 @@ def create_coding_agent(
     specific_expertise = (
         "Software expert focused on pragmatic solutions."
         "Validates codebase pre/post changes."
-        "Employs SearchDefinitionNames for code search; ReplaceInFileTool for updates."
+        "Employs SearchDefinitionNamesTool for code search; ReplaceInFileTool for updates."
         "Exercise caution with the surrounding context during search/replace operations."
         "For refactoring tasks, take the time to develop a comprehensive plan for implementing the proposed changes."
     )

quantalogic-0.50.17/quantalogic/create_custom_agent.py

@@ -0,0 +1,254 @@
+# Import statements
+# import os
+# from typing import Any
+# from loguru import logger
+# from quantalogic.agent import Agent, AgentMemory
+# from quantalogic.agent_tools import (
+#     AgentTool, 
+#     DownloadHttpFileTool, 
+#     DuckDuckGoSearchTool, 
+#     EditWholeContentTool, 
+#     ExecuteBashCommandTool, 
+#     InputQuestionTool, 
+#     ListDirectoryTool, 
+#     LLMTool, 
+#     LLMVisionTool, 
+#     LLMImageGenerationTool, 
+#     MarkitdownTool, 
+#     NodeJsTool, 
+#     PythonTool, 
+#     ReadFileBlockTool, 
+#     ReadFileTool, 
+#     ReadHTMLTool, 
+#     ReplaceInFileTool, 
+#     RipgrepTool, 
+#     SafePythonInterpreterTool, 
+#     SearchDefinitionNames, 
+#     TaskCompleteTool, 
+#     WikipediaSearchTool, 
+#     WriteFileTool,
+#     GoogleNewsTool,
+#     PresentationLLMTool,
+#     SequenceTool,
+#     SQLQueryTool,
+#     SQLQueryToolAdvanced,
+#     CloneRepoTool,
+#     BitbucketCloneTool,
+#     BitbucketOperationsTool,
+#     GitOperationsTool,
+#     MarkdownToPdfTool,
+#     MarkdownToPptxTool,
+#     MarkdownToHtmlTool,
+#     MarkdownToEpubTool,
+#     MarkdownToIpynbTool,
+#     MarkdownToLatexTool,
+#     MarkdownToDocxTool,
+#     CSVProcessorTool,
+#     MermaidValidatorTool,
+#     PrepareDownloadTool,
+#     ComposioTool,
+#     NasaNeoWsTool,
+#     NasaApodTool,
+#     ProductHuntTool,
+#     RagTool
+# )
+# from quantalogic.event_emitter import EventEmitter
+# from quantalogic.console_token_printer import console_print_token
+
+# Function to create a custom agent
+# def create_custom_agent(
+#     model_name: str, 
+#     vision_model_name: str | None = None, 
+#     no_stream: bool = False, 
+#     compact_every_n_iteration: int | None = None,
+#     max_tokens_working_memory: int | None = None,
+#     specific_expertise: str = "",
+#     tools: list[Any] | None = None,
+#     memory: AgentMemory | None = None
+# ) -> Agent:
+#     """Create an agent with the specified model and tools.
+
+#     Args:
+#         model_name (str): Name of the model to use
+#         vision_model_name (str | None): Name of the vision model to use
+#         no_stream (bool, optional): If True, the agent will not stream results.
+#         compact_every_n_iteration (int | None, optional): Frequency of memory compaction.
+#         max_tokens_working_memory (int | None, optional): Maximum tokens for working memory.
+#         specific_expertise (str, optional): Specific expertise of the agent.
+#         tools (list[Any], optional): List of tool configurations to add to the agent.
+#             Each tool config should have:
+#             - type: str - The type of tool
+#             - parameters: dict - The parameters required for the tool
+#         memory (AgentMemory, optional): Memory object to use for the agent.
+
+#     Returns:
+#         Agent: An agent with the specified model and tools
+#     """
+#     # Create storage directory for RAG
+#     # storage_dir = os.path.join(os.path.dirname(__file__), "storage", "rag")
+#     # os.makedirs(storage_dir, exist_ok=True)
+    
+#     # Rebuild AgentTool to resolve forward references
+#     # AgentTool.model_rebuild()
+
+#     # Create event emitter
+#     # event_emitter = EventEmitter()
+
+#     # Define tool mapping with their parameter requirements
+#     # tool_mapping = {
+#     #     "llm": lambda params: LLMTool(
+#     #         model_name=params.get("model_name", model_name),
+#     #         on_token=console_print_token if not no_stream else None,
+#     #         event_emitter=event_emitter
+#     #     ),
+#     #     "llm_vision": lambda params: LLMVisionTool(
+#     #         model_name=params.get("vision_model_name") or vision_model_name,
+#     #         on_token=console_print_token if not no_stream else None,
+#     #         event_emitter=event_emitter
+#     #     ),
+#     #     "llm_image_generation": lambda params: LLMImageGenerationTool(
+#     #         provider="dall-e",
+#     #         model_name="openai/dall-e-3",
+#     #         on_token=console_print_token if not no_stream else None,
+#     #     ),
+#     #     "download_http_file": lambda params: DownloadHttpFileTool(),
+#     #     "duck_duck_go_search": lambda params: DuckDuckGoSearchTool(),
+#     #     "edit_whole_content": lambda params: EditWholeContentTool(),
+#     #     "execute_bash_command": lambda params: ExecuteBashCommandTool(),
+#     #     "input_question": lambda params: InputQuestionTool(),
+#     #     "list_directory": lambda params: ListDirectoryTool(),
+#     #     "markitdown": lambda params: MarkitdownTool(),
+#     #     "nodejs": lambda params: NodeJsTool(),
+#     #     "python": lambda params: PythonTool(),
+#     #     "read_file_block": lambda params: ReadFileBlockTool(),
+#     #     "read_file": lambda params: ReadFileTool(),
+#     #     "read_html": lambda params: ReadHTMLTool(),
+#     #     "replace_in_file": lambda params: ReplaceInFileTool(),
+#     #     "ripgrep": lambda params: RipgrepTool(),
+#     #     "safe_python_interpreter": lambda params: SafePythonInterpreterTool(),
+#     #     "search_definition_names": lambda params: SearchDefinitionNames(),
+#     #     "wikipedia_search": lambda params: WikipediaSearchTool(),
+#     #     "write_file": lambda params: WriteFileTool(),
+#     #     "google_news": lambda params: GoogleNewsTool(
+#     #         model_name=params.get("model_name", model_name),
+#     #         on_token=console_print_token if not no_stream else None,
+#     #         event_emitter=event_emitter
+#     #     ),
+#     #     "presentation_llm": lambda params: PresentationLLMTool(
+#     #         model_name=params.get("model_name", model_name),
+#     #         additional_info=params.get("additional_info", ""),
+#     #         on_token=console_print_token if not no_stream else None,
+#     #         event_emitter=event_emitter
+#     #     ),
+#     #     "sequence": lambda params: SequenceTool(
+#     #         model_name=params.get("model_name", model_name),
+#     #         on_token=console_print_token if not no_stream else None,
+#     #         event_emitter=event_emitter
+#     #     ),
+#     #     "sql_query": lambda params: SQLQueryTool(
+#     #         connection_string=params.get("connection_string", ""),
+#     #         model_name=params.get("model_name", model_name),
+#     #         on_token=console_print_token if not no_stream else None,
+#     #         event_emitter=event_emitter
+#     #     ),
+#     #     "sql_query_advanced": lambda params: SQLQueryToolAdvanced(
+#     #         connection_string=params.get("connection_string", ""),
+#     #         model_name=params.get("model_name", model_name),
+#     #         on_token=console_print_token if not no_stream else None,
+#     #         event_emitter=event_emitter
+#     #     ),
+#     #     "clone_repo_tool": lambda params: CloneRepoTool(auth_token=params.get("auth_token", "")),
+#     #     "bitbucket_clone_repo_tool": lambda params: BitbucketCloneTool(access_token=params.get("access_token", "")),
+#     #     "bitbucket_operations_tool": lambda params: BitbucketOperationsTool(access_token=params.get("access_token", "")),
+#     #     "git_operations_tool": lambda params: GitOperationsTool(auth_token=params.get("auth_token", "")),
+#     #     "markdown_to_pdf": lambda params: MarkdownToPdfTool(),
+#     #     "markdown_to_pptx": lambda params: MarkdownToPptxTool(),
+#     #     "markdown_to_html": lambda params: MarkdownToHtmlTool(),
+#     #     "markdown_to_epub": lambda params: MarkdownToEpubTool(),
+#     #     "markdown_to_ipynb": lambda params: MarkdownToIpynbTool(),
+#     #     "markdown_to_latex": lambda params: MarkdownToLatexTool(),
+#     #     "markdown_to_docx": lambda params: MarkdownToDocxTool(),
+#     #     "csv_processor": lambda params: CSVProcessorTool(),
+#     #     "mermaid_validator_tool": lambda params: MermaidValidatorTool(),
+#     #     "download_file_tool": lambda params: PrepareDownloadTool(),
+#     #     "email_tool": lambda params: ComposioTool(
+#     #         action="GMAIL_SEND_EMAIL",
+#     #         name="email_tool",
+#     #         description="Send emails via Gmail",
+#     #         need_validation=False
+#     #     ),
+#     #     "callendar_tool": lambda params: ComposioTool(
+#     #         action="GOOGLECALENDAR_CREATE_EVENT",
+#     #         name="callendar_tool",
+#     #         description="Create events in Google Calendar",
+#     #         need_validation=False
+#     #     ),
+#     #     "weather_tool": lambda params: ComposioTool(
+#     #         action="WEATHERMAP_WEATHER",
+#     #         name="weather_tool",
+#     #         description="Get weather information for a location"
+#     #     ),
+#     #     "nasa_neows_tool": lambda params: NasaNeoWsTool(),
+#     #     "nasa_apod_tool": lambda params: NasaApodTool(),
+#     #     "product_hunt_tool": lambda params : ProductHuntTool(),
+#     #     "rag_tool": lambda params: RagTool(
+#     #         vector_store=params.get("vector_store", "chroma"),
+#     #         embedding_model=params.get("embedding_model", "openai"),
+#     #         persist_dir=storage_dir,
+#     #         document_paths=params.get("document_paths", [])
+#     #     )
+#     # }
+
+#     # Define write tools that should trigger automatic download tool addition
+#     # write_tools = {"write_file", "edit_whole_content", "replace_in_file"} 
+    
+#     # Initialize agent tools list
+#     # agent_tools = []
+#     # Check if any write tools are present
+#     # has_write_tool = any(
+#     #     tool_config.get("type") in write_tools 
+#     #     for tool_config in (tools or [])
+#     # )
+
+#     # Add tools only if they are provided
+#     # if tools:
+#     #     for tool_config in tools:
+#     #         tool_type = tool_config.get("type")
+#     #         logger.debug(f"Processing tool type: {tool_type}")
+            
+#     #         if tool_type in tool_mapping:
+#     #             try:
+#     #                 # Get tool parameters or empty dict if not provided
+#     #                 tool_params = tool_config.get("parameters", {})
+                    
+#     #                 # Create tool instance with parameters
+#     #                 tool = tool_mapping[tool_type](tool_params)
+#     #                 logger.debug(f"Created tool instance: {tool}")
+                    
+#     #                 if tool:  # Some tools (like llm_vision) might return None
+#     #                     agent_tools.append(tool)
+#     #                     logger.info(f"Added tool: {tool_type}")
+#     #             except Exception as e:
+#     #                 logger.error(f"Failed to create tool {tool_type}: {str(e)}")
+
+#     # If any write tool was added, also add the download tool
+#     # if has_write_tool:
+#     #     try:
+#     #         agent_tools.append(PrepareDownloadTool())
+#     #         logger.info("Added download tool automatically")
+#     #     except Exception as e:
+#     #         logger.error(f"Failed to add download tool: {str(e)}")
+
+#     # Always add TaskCompleteTool
+#     # agent_tools.append(TaskCompleteTool())
+    
+#     # Return the configured Agent
+#     # return Agent(
+#     #     model_name=model_name,
+#     #     tools=agent_tools,
+#     #     event_emitter=event_emitter,
+#     #     compact_every_n_iterations=compact_every_n_iteration,
+#     #     max_tokens_working_memory=max_tokens_working_memory,
+#     #     specific_expertise=specific_expertise,
+#     #     memory=memory,
+#     # )

quantalogic-0.50.17/quantalogic/tools/__init__.py

@@ -0,0 +1,70 @@
+"""Tools for the QuantaLogic agent."""
+
+from loguru import logger
+
+# Direct imports of tools
+from .agent_tool import AgentTool
+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 .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
+
+# Define __all__ to control what gets imported with `from quantalogic.tools import *`
+__all__ = [
+    'AgentTool',
+    'DownloadHttpFileTool',
+    'DuckDuckGoSearchTool',
+    'EditWholeContentTool',
+    'ElixirTool',
+    'ExecuteBashCommandTool',
+    'GrepAppTool',
+    'InputQuestionTool',
+    'JinjaTool',
+    'ListDirectoryTool',
+    'LLMTool',
+    'LLMVisionTool',
+    'MarkitdownTool',
+    'NodeJsTool',
+    'PythonTool',
+    'ReadFileBlockTool',
+    'ReadFileTool',
+    'ReadHTMLTool',
+    'ReplaceInFileTool',
+    'RipgrepTool',
+    'SafePythonInterpreterTool',
+    'SearchDefinitionNames',
+    'SequenceTool',
+    'SerpApiSearchTool',
+    'SQLQueryTool',
+    'TaskCompleteTool',
+    'Tool',
+    'ToolArgument',
+    'UnifiedDiffTool',
+    'WikipediaSearchTool',
+    'WriteFileTool'
+]

quantalogic-0.50.17/quantalogic/tools/composio/__init__.py

@@ -0,0 +1,18 @@
+"""
+Composio Tools Module
+
+This module provides tools and utilities from the Composio integration.
+"""
+
+from loguru import logger
+
+# Explicit imports of all tools in the module
+from .composio import ComposioTool
+
+# Define __all__ to control what is imported with `from ... import *`
+__all__ = [
+    'ComposioTool',
+]
+
+# Optional: Add logging for import confirmation
+logger.info("Composio tools module initialized successfully.")