quantalogic 0.2.18__py3-none-any.whl → 0.2.20__py3-none-any.whl

quantalogic/agent.py

@@ -56,8 +56,8 @@ class Agent(BaseModel):
 
     specific_expertise: str
     model: GenerativeModel
-    memory: AgentMemory = AgentMemory()
-    variable_store: VariableMemory = VariableMemory()
+    memory: AgentMemory = AgentMemory() # A list User / Assistant Messages
+    variable_store: VariableMemory = VariableMemory() # A dictionary of variables (var1: value1, var2: value2)
     tools: ToolManager = ToolManager()
     event_emitter: EventEmitter = EventEmitter()
     config: AgentConfig
@@ -78,13 +78,14 @@ class Agent(BaseModel):
         self,
         model_name: str = "",
         memory: AgentMemory = AgentMemory(),
+        variable_store: VariableMemory = VariableMemory(),
         tools: list[Tool] = [TaskCompleteTool()],
         ask_for_user_validation: Callable[[str], bool] = console_ask_for_user_validation,
         task_to_solve: str = "",
         specific_expertise: str = "General AI assistant with coding and problem-solving capabilities",
         get_environment: Callable[[], str] = get_environment,
-        compact_every_n_iterations: int | None = None,  # New parameter
-        max_tokens_working_memory: int | None = None,  # New parameter to set max working memory tokens
+        compact_every_n_iterations: int | None = None,  # if set the memory will be compacted every n iterations
+        max_tokens_working_memory: int | None = None,  # if set the memory will be compacted each time the max_tokens_working_memory is reached
     ):
         """Initialize the agent with model, memory, tools, and configurations."""
         try:
@@ -117,7 +118,7 @@ class Agent(BaseModel):
             super().__init__(
                 model=GenerativeModel(model=model_name, event_emitter=event_emitter),
                 memory=memory,
-                variable_store=VariableMemory(),
+                variable_store=variable_store,
                 tools=tool_manager,
                 config=config,
                 ask_for_user_validation=ask_for_user_validation,
@@ -422,7 +423,7 @@ class Agent(BaseModel):
             answer=None,
         )
 
-    def _handle_repeated_tool_call(self, tool_name: str, arguments_with_values: dict) -> ObserveResponseResult:
+    def _handle_repeated_tool_call(self, tool_name: str, arguments_with_values: dict) -> (str,str):
         """Handle the case where a tool call is repeated."""
         repeat_count = self.last_tool_call.get("count", 0)
         error_message = (
@@ -436,11 +437,7 @@ class Agent(BaseModel):
             "3. Use a different tool or modify the arguments\n"
             "4. Ensure you're making progress towards the goal"
         )
-        return ObserveResponseResult(
-            next_prompt=error_message,
-            executed_tool="",
-            answer=None,
-        )
+        return tool_name, error_message
 
     def _handle_tool_execution_failure(self, response: str) -> ObserveResponseResult:
         """Handle the case where tool execution fails."""
@@ -527,6 +524,13 @@ class Agent(BaseModel):
             tuple containing:
                 - executed_tool name (str)
                 - tool execution response (Any)
+
+        Note:
+            Predefined variable properties take precedence over dynamically provided values.
+            This ensures consistent behavior when tools have both predefined properties
+            and runtime-provided arguments. The precedence order is:
+            1. Predefined properties from tool.get_injectable_properties_in_execution()
+            2. Runtime-provided arguments from arguments_with_values
         """
         # Handle tool validation if required
         if tool.need_validation:
@@ -564,6 +568,19 @@ class Agent(BaseModel):
             arguments_with_values_interpolated = {
                 key: self._interpolate_variables(value) for key, value in arguments_with_values.items()
             }
+            # test if tool need variables in context 
+            if tool.need_variables:
+                # Inject variables into the tool if needed
+                arguments_with_values_interpolated["variables"] = self.variable_store
+            if tool.need_caller_context_memory:
+                # Inject caller context into the tool if needed
+                arguments_with_values_interpolated["caller_context_memory"] = self.memory.memory
+
+            # Add injectable variables
+            injectable_properties = tool.get_injectable_properties_in_execution()
+            for key, value in injectable_properties.items():
+                arguments_with_values_interpolated[key] = value
+
             # Call tool execute with named arguments
             response = tool.execute(**arguments_with_values_interpolated)
             executed_tool = tool.name

quantalogic/coding_agent.py

@@ -5,6 +5,7 @@ from quantalogic.tools import (
     EditWholeContentTool,
     ExecuteBashCommandTool,
     InputQuestionTool,
+    JinjaTool,
     ListDirectoryTool,
     LLMTool,
     LLMVisionTool,
@@ -72,6 +73,7 @@ def create_coding_agent(
         ExecuteBashCommandTool(),
         InputQuestionTool(),
         DuckDuckGoSearchTool(),
+        JinjaTool(),
     ]
 
     if vision_model_name:
@@ -85,6 +87,9 @@ def create_coding_agent(
                 name="coding_consultant",  # Handles implementation-level coding questions
                 on_token=console_print_token if not no_stream else None,
             )
+            # Note: system_prompt is predefined in LLMTool properties and takes precedence over
+            # dynamically provided values. This ensures consistent behavior by prioritizing
+            # the predefined system prompt. See tool.py and agent.py for implementation details.
         )
         tools.append(
             LLMTool(
@@ -94,6 +99,14 @@ def create_coding_agent(
                 on_token=console_print_token if not no_stream else None,
             )
         )
+        ## Add a generic LLMTool
+        tools.append(
+            LLMTool(
+                model_name=model_name,
+                name="llm_tool",
+                on_token=console_print_token if not no_stream else None,
+            )
+        )
 
     return Agent(
         model_name=model_name,

quantalogic/tools/__init__.py

@@ -2,10 +2,12 @@
 
 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 .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
@@ -18,7 +20,6 @@ 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
@@ -51,4 +52,5 @@ __all__ = [
     "MarkitdownTool",
     "DownloadHttpFileTool",
     "EditWholeContentTool",
+    "JinjaTool",
 ]

quantalogic/tools/jinja_tool.py

@@ -0,0 +1,91 @@
+"""Tool for rendering Jinja templates with inline template string."""
+
+from typing import Any, Dict, Optional
+
+from jinja2 import Template
+from loguru import logger
+from pydantic import Field
+
+from quantalogic.tools.tool import Tool, ToolArgument
+
+
+class JinjaTool(Tool):
+    """Tool for rendering Jinja templates with inline template string."""
+
+    name: str = "jinja_tool"
+    description: str = (
+        "Renders an inline Jinja2 template string with a predefined context.\n" 
+        "You can use the variables in the template just as var1, var2, etc.\n"
+        "Useful for simple calculations or string operations.\n"
+    )
+    arguments: list = [
+        ToolArgument(
+            name="inline_template",
+            arg_type="string",
+            description="Inline Jinja2 template string to render. Has access to variables in the context.",
+            required=True,
+            example="Hello, {{ var1 }}! You have {{ var2|length }} items.",
+        ),
+    ]
+    need_variables: bool = True
+
+    # Add context as a field with a default empty dictionary
+    context: Dict[str, Any] = Field(default_factory=dict)
+
+    def __init__(self):
+        """
+        Initialize JinjaTool with optional context.
+
+        Args:
+            context (dict, optional): Context dictionary for template rendering.
+        """
+        super().__init__()
+
+    def execute(self, inline_template: str,variables: Optional[Dict[str, Any]] = None) -> str:
+        """
+        Render an inline Jinja2 template with the predefined context.
+
+        Args:
+            inline_template (str): Inline template string to render.
+            variables (dict, optional): Additional variables to include in the context.
+
+        Returns:
+            str: Rendered template content.
+        """
+        try:
+            # Create Jinja2 template
+            template = Template(inline_template)
+
+            context = {}
+            if variables:
+                context.update(variables)
+
+            rendered_content = template.render(**context)
+
+            logger.info("Successfully rendered inline Jinja template")
+            return rendered_content
+
+        except Exception as e:
+            logger.error(f"Error rendering Jinja template: {e}")
+            raise
+
+
+if __name__ == "__main__":
+    # Example of using JinjaTool with variables
+    tool = JinjaTool(context={
+        "var1": "World", 
+        "var2": 42, 
+        "var3": ["apple", "banana", "cherry"]
+    })
+    
+    # Inline template demonstrating variable usage
+    template = "Hello {{ var1 }}! The answer is {{ var2 }}. Fruits: {% for fruit in var3 %}{{ fruit }}{% if not loop.last %}, {% endif %}{% endfor %}."
+    
+    # Render the template
+    result = tool.execute(template)
+    print("Rendered Template:")
+    print(result)
+    
+    # Print the tool's markdown representation
+    print("\nTool Markdown:")
+    print(tool.to_markdown())

quantalogic/tools/llm_tool.py

@@ -167,3 +167,8 @@ if __name__ == "__main__":
     pirate_answer = pirate.execute(system_prompt=system_prompt, prompt=question, temperature=temperature)
     print("\n")
     print(f"Anwser: {pirate_answer}")
+
+    custom_tool = LLMTool(
+        model_name="openrouter/openai/gpt-4o-mini", system_prompt="You are a pirate.", on_token=console_print_token
+    )
+    print(custom_tool.to_markdown())

quantalogic/tools/search_definition_names.py

@@ -63,6 +63,20 @@ class SearchDefinitionNames(Tool):
             required=False,
             example="**/*.py",
         ),
+        ToolArgument(
+            name="page",
+            arg_type="int",
+            description="The page number to retrieve (1-based index).",
+            required=False,
+            example="1",
+        ),
+        ToolArgument(
+            name="page_size",
+            arg_type="int",
+            description="The number of results per page (default: 10).",
+            required=False,
+            example="10",
+        ),
     ]
 
     def _get_language_handler(self, language_name: str):
@@ -89,7 +103,7 @@ class SearchDefinitionNames(Tool):
             raise ValueError(f"Unsupported language: {language_name}")
 
     def execute(
-        self, directory_path: str, language_name: str, file_pattern: str = "*", output_format: str = "text"
+        self, directory_path: str, language_name: str, file_pattern: str = "*", output_format: str = "text", page: int = 1, page_size: int = 10
     ) -> Union[str, Dict]:
         """Searches for definition names in a directory using Tree-sitter.
 
@@ -98,11 +112,19 @@ class SearchDefinitionNames(Tool):
             language_name (str): The Tree-sitter language name.
             file_pattern (str): Optional glob pattern to filter files (default: '*').
             output_format (str): Output format ('text', 'json', 'markdown').
+            page (int): The page number to retrieve (1-based index).
+            page_size (int): The number of results per page (default: 10).
 
         Returns:
             Union[str, Dict]: The search results in the specified format.
         """
         try:
+            # Validate pagination parameters
+            if page < 1:
+                raise ValueError("Page number must be a positive integer.")
+            if page_size < 1:
+                raise ValueError("Page size must be a positive integer.")
+
             # Set up Tree-sitter based on language
             language_handler = self._get_language_handler(language_name)
             parser = Parser(language_handler.get_language())
@@ -140,7 +162,21 @@ class SearchDefinitionNames(Tool):
                         logger.warning(f"Error processing file {file_path}: {str(e)}")
                         continue
 
-            return self._format_results(results, directory_path, language_name, file_pattern, output_format)
+            # Apply pagination
+            start_index = (page - 1) * page_size
+            end_index = start_index + page_size
+            paginated_results = results[start_index:end_index]
+
+            return self._format_results(
+                paginated_results,
+                directory_path,
+                language_name,
+                file_pattern,
+                output_format,
+                page,
+                page_size,
+                len(results)
+            )
 
         except Exception as e:
             logger.error(f"Error during search: {str(e)}")
@@ -263,6 +299,9 @@ class SearchDefinitionNames(Tool):
         language_name: str,
         file_pattern: str,
         output_format: str = "text",
+        page: int = 1,
+        page_size: int = 10,
+        total_results: int = 0,
     ) -> Union[str, Dict]:
         """Formats the search results in the specified format.
 
@@ -272,6 +311,9 @@ class SearchDefinitionNames(Tool):
             language_name: The language that was searched.
             file_pattern: The file pattern that was used.
             output_format: The desired output format.
+            page: The page number.
+            page_size: The number of results per page.
+            total_results: The total number of results.
 
         Returns:
             Union[str, Dict]: The formatted results.
@@ -281,6 +323,9 @@ class SearchDefinitionNames(Tool):
                 "directory": directory_path,
                 "language": language_name,
                 "file_pattern": file_pattern,
+                "page": page,
+                "page_size": page_size,
+                "total_results": total_results,
                 "results": [],
             }
 
@@ -318,7 +363,10 @@ class SearchDefinitionNames(Tool):
             markdown = "# Search Results\n\n"
             markdown += f"- **Directory**: `{directory_path}`\n"
             markdown += f"- **Language**: `{language_name}`\n"
-            markdown += f"- **File Pattern**: `{file_pattern}`\n\n"
+            markdown += f"- **File Pattern**: `{file_pattern}`\n"
+            markdown += f"- **Page**: {page}\n"
+            markdown += f"- **Page Size**: {page_size}\n"
+            markdown += f"- **Total Results**: {total_results}\n\n"
 
             for result in results:
                 markdown += f"## File: {result['file_path']}\n"
@@ -354,7 +402,10 @@ class SearchDefinitionNames(Tool):
             text += "==============\n"
             text += f"Directory: {directory_path}\n"
             text += f"Language: {language_name}\n"
-            text += f"File Pattern: {file_pattern}\n\n"
+            text += f"File Pattern: {file_pattern}\n"
+            text += f"Page: {page}\n"
+            text += f"Page Size: {page_size}\n"
+            text += f"Total Results: {total_results}\n\n"
 
             for result in results:
                 text += f"File: {result['file_path']}\n"

quantalogic/tools/tool.py

@@ -6,6 +6,7 @@ with type-validated arguments and execution methods.
 
 from typing import Any, Literal
 
+from loguru import logger
 from pydantic import BaseModel, ConfigDict, Field, field_validator
 
 
@@ -27,9 +28,10 @@ class ToolArgument(BaseModel):
     )
     description: str | None = Field(default=None, description="A brief description of the argument.")
     required: bool = Field(default=False, description="Indicates if the argument is required.")
-    default: str | None = Field(default=None, description="The default value for the argument. This parameter is required.")
+    default: str | None = Field(
+        default=None, description="The default value for the argument. This parameter is required."
+    )
     example: str | None = Field(default=None, description="An example value to illustrate the argument's usage.")
-    need_validation: bool = Field(default=False, description="Indicates if the argument needs validation.")
 
 
 class ToolDefinition(BaseModel):
@@ -42,12 +44,49 @@ class ToolDefinition(BaseModel):
         need_validation: Flag to indicate if tool requires validation.
     """
 
-    model_config = ConfigDict(extra="forbid", validate_assignment=True)
+    model_config = ConfigDict(extra="allow", validate_assignment=True)
 
     name: str = Field(..., description="The unique name of the tool.")
     description: str = Field(..., description="A brief description of what the tool does.")
     arguments: list[ToolArgument] = Field(default_factory=list, description="A list of arguments the tool accepts.")
-    need_validation: bool = Field(default=False, description="Indicates if the tool needs validation.")
+    need_validation: bool = Field(
+        default=False,
+        description="When True, requires user confirmation before execution. Useful for tools that perform potentially destructive operations.",
+    )
+    need_variables: bool = Field(
+        default=False,
+        description="When True, provides access to the agent's variable store. Required for tools that need to interpolate variables (e.g., Jinja templates).",
+    )
+    need_caller_context_memory: bool = Field(
+        default=False,
+        description="When True, provides access to the agent's conversation history. Useful for tools that need context from previous interactions.",
+    )
+
+    def get_properties(self, exclude: list[str] | None = None) -> dict[str, Any]:
+        """Return a dictionary of all non-None properties, excluding Tool class fields and specified fields.
+
+        Args:
+            exclude: Optional list of field names to exclude from the result
+
+        Returns:
+            Dictionary of property names and values, excluding Tool class fields and specified fields.
+        """
+        exclude = exclude or []
+        tool_fields = {
+            "name",
+            "description",
+            "arguments",
+            "need_validation",
+            "need_variables",
+            "need_caller_context_memory",
+        }
+        properties = {}
+
+        for name, value in self.__dict__.items():
+            if name not in tool_fields and name not in exclude and value is not None and not name.startswith("_"):
+                properties[name] = value
+
+        return properties
 
     def to_json(self) -> str:
         """Convert the tool to a JSON string representation.
@@ -67,10 +106,21 @@ class ToolDefinition(BaseModel):
         markdown = f"`{self.name}`:\n"
         markdown += f"- **Description**: {self.description}\n\n"
 
+        properties_injectable = self.get_injectable_properties_in_execution()
+
         # Parameters section
         if self.arguments:
             markdown += "- **Parameters**:\n"
+            parameters = ""
             for arg in self.arguments:
+                # Skip if parameter name matches an object property with non-None value
+                # This enables automatic property injection during execution:
+                # When an object has a property matching an argument name,
+                # the agent will inject the property value at runtime,
+                # reducing manual input and improving flexibility
+                if properties_injectable.get(arg.name) is not None:
+                    continue
+
                 required_status = "required" if arg.required else "optional"
                 # Prioritize example, then default, then create a generic description
                 value_info = ""
@@ -79,12 +129,15 @@ class ToolDefinition(BaseModel):
                 elif arg.default is not None:
                     value_info = f" (default: `{arg.default}`)"
 
-                markdown += (
+                parameters += (
                     f"  - `{arg.name}`: "
                     f"({required_status}{value_info})\n"
-                    f"    {arg.description or 'No description provided.'}\n"
+                    f"    {arg.description or ''}\n"
                 )
-            markdown += "\n"
+            if len(parameters) > 0:
+                markdown += parameters + "\n\n"
+            else:
+                markdown += "None\n\n"
 
         # Usage section with XML-style example
         markdown += "**Usage**:\n"
@@ -93,6 +146,8 @@ class ToolDefinition(BaseModel):
 
         # Generate example parameters
         for arg in self.arguments:
+            if properties_injectable.get(arg.name) is not None:
+                continue
             # Prioritize example, then default, then create a generic example
             example_value = arg.example or arg.default or f"Your {arg.name} here"
             markdown += f"  <{arg.name}>{example_value}</{arg.name}>\n"
@@ -102,6 +157,18 @@ class ToolDefinition(BaseModel):
 
         return markdown
 
+    def get_non_injectable_arguments(self) -> list[ToolArgument]:
+        """Get arguments that cannot be injected from properties.
+
+        Returns:
+            List of ToolArgument instances that cannot be injected by the agent.
+        """
+        properties_injectable = self.get_injectable_properties_in_execution()
+
+        return [
+            arg for arg in self.arguments if properties_injectable.get(arg.name) is None
+        ]
+
 
 class Tool(ToolDefinition):
     """Extended class for tools with execution capabilities.
@@ -144,3 +211,43 @@ class Tool(ToolDefinition):
             A string representing the result of tool execution.
         """
         raise NotImplementedError("This method should be implemented by subclasses.")
+
+    def get_injectable_properties_in_execution(self) -> dict[str, Any]:
+        """Get injectable properties excluding tool arguments.
+        
+        Returns:
+            A dictionary of property names and values, excluding tool arguments and None values.
+        """
+        # Get argument names from tool definition
+        argument_names = {arg.name for arg in self.arguments}
+        
+        # Get properties excluding arguments and filter out None values
+        properties = self.get_properties(exclude=["arguments"])
+        return {
+            name: value 
+            for name, value in properties.items() 
+            if value is not None and name in argument_names
+        }
+
+
+if __name__ == "__main__":
+    tool = Tool(name="my_tool", description="A simple tool", arguments=[ToolArgument(name="arg1", arg_type="string")])
+    print(tool.to_markdown())
+
+    class MyTool(Tool):
+        field1: str | None = Field(default=None, description="Field 1 description")
+
+    tool_with_fields = MyTool(
+        name="my_tool1", description="A simple tool", arguments=[ToolArgument(name="field1", arg_type="string")]
+    )
+    print(tool_with_fields.to_markdown())
+    print(tool_with_fields.get_injectable_properties_in_execution())
+
+    tool_with_fields_defined = MyTool(
+        name="my_tool2",
+        description="A simple tool2",
+        field1="field1_value",
+        arguments=[ToolArgument(name="field1", arg_type="string")],
+    )
+    print(tool_with_fields_defined.to_markdown())
+    print(tool_with_fields_defined.get_injectable_properties_in_execution())

quantalogic/xml_tool_parser.py

@@ -76,15 +76,17 @@ class ToolParser:
             elements = self.xml_parser.extract_elements(xml_string, preserve_cdata=True)
             logger.debug(f"Extracted elements from XML: {elements}")
 
+            arguments = self.tool.get_non_injectable_arguments()
+
             # Check for required arguments
-            for arg in self.tool.arguments:
+            for arg in arguments:
                 if arg.required and arg.name not in elements:
                     error_msg = f"argument {arg.name} not found"
                     logger.error(f"Error extracting XML elements: {error_msg}")
                     raise ValueError(f"Error extracting XML elements: {error_msg}")
 
             # Create and validate arguments dictionary
-            argument_dict = {arg.name: elements.get(arg.name, "") for arg in self.tool.arguments}
+            argument_dict = {arg.name: elements.get(arg.name, "") for arg in arguments}
 
             # Validate using Pydantic model
             validated_args = ToolArguments(arguments=argument_dict)