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

quantalogic/agent_config.py

@@ -3,24 +3,51 @@
 # Standard library imports
 
 # Local application imports
+import logging
+import os
+from typing import Any
+
 from dotenv import load_dotenv
 
 from quantalogic.agent import Agent
 from quantalogic.console_print_token import console_print_token
+from quantalogic.event_emitter import EventEmitter
+from quantalogic.memory import AgentMemory
 from quantalogic.tools import (
     AgentTool,
+    BitbucketCloneTool,
+    BitbucketOperationsTool,
+    CloneRepoTool,
+    ComposioTool,
+    CSVProcessorTool,
     DownloadHttpFileTool,
     DuckDuckGoSearchTool,
     EditWholeContentTool,
     ExecuteBashCommandTool,
+    GitOperationsTool,
+    GoogleNewsTool,
     InputQuestionTool,
     ListDirectoryTool,
     LLMImageGenerationTool,
     LLMTool,
     LLMVisionTool,
+    MarkdownToDocxTool,
+    MarkdownToEpubTool,
+    MarkdownToHtmlTool,
+    MarkdownToIpynbTool,
+    MarkdownToLatexTool,
+    MarkdownToPdfTool,
+    MarkdownToPptxTool,
     MarkitdownTool,
+    MermaidValidatorTool,
+    NasaApodTool,
+    NasaNeoWsTool,
     NodeJsTool,
+    PrepareDownloadTool,
+    PresentationLLMTool,
+    ProductHuntTool,
     PythonTool,
+    RagTool,
     ReadFileBlockTool,
     ReadFileTool,
     ReadHTMLTool,
@@ -28,6 +55,9 @@ from quantalogic.tools import (
     RipgrepTool,
     SafePythonInterpreterTool,
     SearchDefinitionNames,
+    SequenceTool,
+    SQLQueryTool,
+    SQLQueryToolAdvanced,
     TaskCompleteTool,
     WikipediaSearchTool,
     WriteFileTool,
@@ -37,21 +67,24 @@ 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, 
+    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
+    max_tokens_working_memory: int | None = None,
 ) -> Agent:
     global _current_model_name
     _current_model_name = model_name
@@ -81,18 +114,18 @@ def create_agent(
         SearchDefinitionNames(),
         MarkitdownTool(),
         LLMTool(model_name=model_name, on_token=console_print_token if not no_stream else None),
-        DownloadHttpFileTool(),
+        DownloadHttpFileTool(), 
         LLMImageGenerationTool(
-                provider="dall-e",
-                model_name="openai/dall-e-3",
-                on_token=console_print_token if not no_stream else None
-            ),
+            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))
+        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,
@@ -103,11 +136,11 @@ def create_agent(
 
 
 def create_interpreter_agent(
-    model_name: str, 
-    vision_model_name: str | None, 
-    no_stream: bool = False, 
+    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
+    max_tokens_working_memory: int | None = None,
 ) -> Agent:
     """Create an interpreter agent with the specified model and tools.
 
@@ -141,7 +174,7 @@ def create_interpreter_agent(
         ReadHTMLTool(),
     ]
     return Agent(
-        model_name=model_name, 
+        model_name=model_name,
         tools=tools,
         compact_every_n_iterations=compact_every_n_iteration,
         max_tokens_working_memory=max_tokens_working_memory,
@@ -149,11 +182,11 @@ def create_interpreter_agent(
 
 
 def create_full_agent(
-    model_name: str, 
-    vision_model_name: str | None, 
-    no_stream: bool = False, 
+    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
+    max_tokens_working_memory: int | None = None,
 ) -> Agent:
     """Create an agent with the specified model and many tools.
 
@@ -188,11 +221,13 @@ def create_full_agent(
         WikipediaSearchTool(),
         DuckDuckGoSearchTool(),
         ReadHTMLTool(),
-      #  SafePythonInterpreterTool(allowed_modules=["math", "numpy"])
+        #  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))
+        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,
@@ -203,11 +238,11 @@ def create_full_agent(
 
 
 def create_basic_agent(
-    model_name: str, 
-    vision_model_name: str | None = None, 
-    no_stream: bool = False, 
+    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
+    max_tokens_working_memory: int | None = None,
 ) -> Agent:
     """Create an agent with the specified model and tools.
 
@@ -224,7 +259,6 @@ def create_basic_agent(
     # Rebuild AgentTool to resolve forward references
     AgentTool.model_rebuild()
 
-
     tools = [
         TaskCompleteTool(),
         ListDirectoryTool(),
@@ -239,11 +273,13 @@ def create_basic_agent(
         ExecuteBashCommandTool(),
         LLMTool(model_name=model_name, on_token=console_print_token if not no_stream else None),
         ReadHTMLTool(),
-    #    SafePythonInterpreterTool(allowed_modules=["math", "numpy"])
+        #    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))
+        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,
@@ -251,3 +287,199 @@ def create_basic_agent(
         compact_every_n_iterations=compact_every_n_iteration,
         max_tokens_working_memory=max_tokens_working_memory,
     )
+
+
+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
+    """
+    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=params.get("provider", "dall-e"),
+            provider="dall-e",
+            # model_name=params.get("model_name", "openai/dall-e-3"),
+            model_name="openai/dall-e-3",
+            on_token=console_print_token if not no_stream else None,
+            # event_emitter=event_emitter
+        ),
+        "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"} 
+    
+    agent_tools = []
+    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)}")
+
+    agent_tools.append(TaskCompleteTool())
+    
+    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/agent_factory.py

@@ -1,20 +1,22 @@
-from typing import Dict, Optional
+from typing import Any, Dict, List, Optional
 
 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,
 )
 from quantalogic.coding_agent import create_coding_agent
+from quantalogic.memory import AgentMemory
 from quantalogic.search_agent import create_search_agent  # noqa: E402
 
 
 class AgentRegistry:
     """Registry for managing agent instances by name."""
-    
+
     _instance = None
     _agents: Dict[str, Agent] = {}
 
@@ -26,7 +28,7 @@ class AgentRegistry:
     @classmethod
     def register_agent(cls, name: str, agent: Agent) -> None:
         """Register an agent instance with a name.
-        
+
         Args:
             name: Unique name for the agent
             agent: Agent instance to register
@@ -38,13 +40,13 @@ class AgentRegistry:
     @classmethod
     def get_agent(cls, name: str) -> Agent:
         """Retrieve a registered agent by name.
-        
+
         Args:
             name: Name of the agent to retrieve
-            
+
         Returns:
             Registered Agent instance
-            
+
         Raises:
             KeyError: If no agent with that name exists
         """
@@ -53,12 +55,13 @@ class AgentRegistry:
     @classmethod
     def list_agents(cls) -> Dict[str, str]:
         """List all registered agents.
-        
+
         Returns:
             Dictionary mapping agent names to their types
         """
         return {name: type(agent).__name__ for name, agent in cls._agents.items()}
 
+
 """Agent factory module for creating different types of agents."""
 
 
@@ -66,23 +69,33 @@ def create_agent_for_mode(
     mode: str,
     model_name: str,
     vision_model_name: Optional[str],
+    thinking_model_name: Optional[str],
     no_stream: bool = False,
     compact_every_n_iteration: Optional[int] = None,
-    max_tokens_working_memory: Optional[int] = None
+    max_tokens_working_memory: Optional[int] = None,
+    tools: Optional[List[Any]] = None,
+    event_emitter: Any = None,
+    specific_expertise: str = "",
+    memory: AgentMemory | None = None
 ) -> Agent:
     """Create an agent based on the specified mode.
-    
+
     Args:
         mode: The mode of operation for the agent
         model_name: The name of the language model to use
         vision_model_name: Optional name of the vision model
+        thinking_model_name: Optional name for a thinking model
         no_stream: Whether to disable streaming mode
         compact_every_n_iteration: Optional number of iterations before compacting memory
         max_tokens_working_memory: Optional maximum tokens for working memory
+        tools: Optional list of tools to include in the agent
+        event_emitter: Optional event emitter to use in the agent
+        specific_expertise: Optional specific expertise for the agent
+        memory: Optional AgentMemory instance to use in the agent
         
     Returns:
         Agent: The created agent instance
-        
+
     Raises:
         ValueError: If an unknown agent mode is specified
     """
@@ -97,10 +110,11 @@ def create_agent_for_mode(
         agent = create_coding_agent(
             model_name,
             vision_model_name,
+            thinking_model_name,
             basic=False,
             no_stream=no_stream,
             compact_every_n_iteration=compact_every_n_iteration,
-            max_tokens_working_memory=max_tokens_working_memory
+            max_tokens_working_memory=max_tokens_working_memory,
         )
         return agent
     if mode == "code-basic":
@@ -110,7 +124,7 @@ def create_agent_for_mode(
             basic=True,
             no_stream=no_stream,
             compact_every_n_iteration=compact_every_n_iteration,
-            max_tokens_working_memory=max_tokens_working_memory
+            max_tokens_working_memory=max_tokens_working_memory,
         )
         return agent
     elif mode == "basic":
@@ -119,7 +133,7 @@ def create_agent_for_mode(
             vision_model_name,
             no_stream=no_stream,
             compact_every_n_iteration=compact_every_n_iteration,
-            max_tokens_working_memory=max_tokens_working_memory
+            max_tokens_working_memory=max_tokens_working_memory,
         )
         return agent
     elif mode == "full":
@@ -128,7 +142,7 @@ def create_agent_for_mode(
             vision_model_name,
             no_stream=no_stream,
             compact_every_n_iteration=compact_every_n_iteration,
-            max_tokens_working_memory=max_tokens_working_memory
+            max_tokens_working_memory=max_tokens_working_memory,
         )
         return agent
     elif mode == "interpreter":
@@ -137,7 +151,7 @@ def create_agent_for_mode(
             vision_model_name,
             no_stream=no_stream,
             compact_every_n_iteration=compact_every_n_iteration,
-            max_tokens_working_memory=max_tokens_working_memory
+            max_tokens_working_memory=max_tokens_working_memory,
         )
         return agent
     elif mode == "search":
@@ -145,7 +159,7 @@ def create_agent_for_mode(
             model_name,
             no_stream=no_stream,
             compact_every_n_iteration=compact_every_n_iteration,
-            max_tokens_working_memory=max_tokens_working_memory
+            max_tokens_working_memory=max_tokens_working_memory,
         )
         return agent
     if mode == "search-full":
@@ -154,7 +168,19 @@ def create_agent_for_mode(
             mode_full=True,
             no_stream=no_stream,
             compact_every_n_iteration=compact_every_n_iteration,
-            max_tokens_working_memory=max_tokens_working_memory
+            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
     else:

quantalogic/coding_agent.py

@@ -15,9 +15,7 @@ from quantalogic.tools import (
     ReadHTMLTool,
     ReplaceInFileTool,
     RipgrepTool,
-    SafePythonInterpreterTool,
     SearchDefinitionNames,
-    SequenceTool,
     TaskCompleteTool,
     WriteFileTool,
 )
@@ -26,18 +24,20 @@ from quantalogic.utils.get_quantalogic_rules_content import get_quantalogic_rule
 
 
 def create_coding_agent(
-    model_name: str, 
-    vision_model_name: str | None = None, 
-    basic: bool = False, 
-    no_stream: bool = False, 
+    model_name: str,
+    vision_model_name: str | None = None,
+    thinking_model_name: str | None = None,
+    basic: 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 coding agent with a comprehensive set of tools.
 
     Args:
         model_name (str): Name of the language model to use for the agent's core capabilities
         vision_model_name (str | None): Name of the vision model to use for the agent's core capabilities
+        thinking_model_name (str | None): Name of the thinking model to use for the agent's core capabilities
         basic (bool, optional): If True, the agent will be configured with a basic set of tools.
         no_stream (bool, optional): If True, the agent will not stream results.
         compact_every_n_iteration (int | None, optional): Frequency of memory compaction.
@@ -82,10 +82,20 @@ def create_coding_agent(
         GrepAppTool(),
         # SafePythonInterpreterTool(allowed_modules=["math", "numpy","decimal"])
     ]
-    
-   
+
     if vision_model_name:
-        tools.append(LLMVisionTool(model_name=vision_model_name, on_token=console_print_token if not no_stream else None))
+        tools.append(
+            LLMVisionTool(model_name=vision_model_name, on_token=console_print_token if not no_stream else None)
+        )
+
+    if thinking_model_name:
+        tools.append(
+            LLMTool(
+                model_name=thinking_model_name,
+                name="smartest_code_expert",
+                on_token=console_print_token if not no_stream else None,
+            )
+        )
 
     if not basic:
         tools.append(
@@ -115,8 +125,6 @@ def create_coding_agent(
                 on_token=console_print_token if not no_stream else None,
             )
         )
-        
-
 
     return Agent(
         model_name=model_name,

quantalogic/config.py

@@ -1,15 +1,18 @@
 from dataclasses import dataclass
+from typing import Optional
 
 
 @dataclass
 class QLConfig:
     """Central configuration for QuantaLogic agent parameters."""
+
     model_name: str
     verbose: bool
     mode: str
     log: str
-    vision_model_name: str | None
+    vision_model_name: Optional[str]
     max_iterations: int
-    compact_every_n_iteration: int | None
-    max_tokens_working_memory: int | None
-    no_stream: bool
+    compact_every_n_iteration: Optional[int]
+    max_tokens_working_memory: Optional[int]
+    no_stream: bool
+    thinking_model_name: str