quantalogic 0.33.1__py3-none-any.whl → 0.33.2__py3-none-any.whl

quantalogic/agent.py

@@ -780,21 +780,16 @@ class Agent(BaseModel):
             str: Generated task summary
         """
         try:
-            if len(content) < 200:
+            if len(content) < 1024*4:
                 return content
             prompt = (
-                "Create an ultra-concise task summary that captures ONLY: \n"
+                "Create a task summary that captures ONLY: \n"
                 "1. Primary objective/purpose\n"
                 "2. Core actions/requirements\n"
                 "3. Desired end-state/outcome\n\n"
                 "Guidelines:\n"
                 "- Use imperative voice\n"
-                "- Exclude background, explanations, and examples\n"
-                "- Compress information using semantic density\n"
-                "- Strict 2-3 sentence maximum (under 50 words)\n"
-                "- Format: 'Concise Task Summary: [Your summary]'\n\n"
                 f"Input Task Description:\n{content}\n\n"
-                "Concise Task Summary:"
             )
             result = self.model.generate(prompt=prompt)
             logger.debug(f"Generated summary: {result.response}")

quantalogic/agent_config.py

@@ -26,6 +26,7 @@ from quantalogic.tools import (
     ReadHTMLTool,
     ReplaceInFileTool,
     RipgrepTool,
+    SafePythonInterpreterTool,
     SearchDefinitionNames,
     TaskCompleteTool,
     WikipediaSearchTool,
@@ -86,7 +87,8 @@ def create_agent(
                 model_name="openai/dall-e-3",
                 on_token=console_print_token if not no_stream else None
             ),
-        ReadHTMLTool()
+        ReadHTMLTool(),
+       # SafePythonInterpreterTool(allowed_modules=["math", "numpy"])
     ]
 
     if vision_model_name:
@@ -186,6 +188,7 @@ def create_full_agent(
         WikipediaSearchTool(),
         DuckDuckGoSearchTool(),
         ReadHTMLTool(),
+      #  SafePythonInterpreterTool(allowed_modules=["math", "numpy"])
     ]
 
     if vision_model_name:
@@ -236,6 +239,7 @@ 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"])
     ]
 
     if vision_model_name:

quantalogic/coding_agent.py

@@ -15,7 +15,9 @@ from quantalogic.tools import (
     ReadHTMLTool,
     ReplaceInFileTool,
     RipgrepTool,
+    SafePythonInterpreterTool,
     SearchDefinitionNames,
+    SequenceTool,
     TaskCompleteTool,
     WriteFileTool,
 )
@@ -77,9 +79,11 @@ def create_coding_agent(
         DuckDuckGoSearchTool(),
         JinjaTool(),
         ReadHTMLTool(),
-        GrepAppTool()
+        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))
 
@@ -111,6 +115,8 @@ def create_coding_agent(
                 on_token=console_print_token if not no_stream else None,
             )
         )
+        
+
 
     return Agent(
         model_name=model_name,

quantalogic/generative_model.py

@@ -123,8 +123,12 @@ class GenerativeModel:
 
     # Generate a response with conversation history and optional streaming
     def generate_with_history(
-        self, messages_history: list[Message], prompt: str, image_url: str | None = None, streaming: bool = False,
-        stop_words: list[str] | None = None
+        self,
+        messages_history: list[Message],
+        prompt: str,
+        image_url: str | None = None,
+        streaming: bool = False,
+        stop_words: list[str] | None = None,
     ) -> ResponseStats:
         """Generate a response with conversation history and optional image.
 
@@ -166,6 +170,7 @@ class GenerativeModel:
                 messages=messages,
                 num_retries=MIN_RETRIES,
                 stop=stop_words,
+                extra_headers={"X-Title": "quantalogic"},
             )
 
             token_usage = TokenUsage(

quantalogic/prompts.py

@@ -70,28 +70,9 @@ Task Format: <task>task_description</task>
 </action>
 ```
 
-### Action Patterns
-1. 🆕 New Task:
-```xml
-<action>
-<analyzer>
-  <input>$data$</input>
-  <mode>initialize</mode>
-</analyzer>
-</action>
-```
-
-2. 🔄 Continuation:
-```xml
-<action>
-<processor>
-  <state>$current$</state>
-  <action>optimize</action>
-</processor>
-</action>
-```
+### Example Usage
 
-3. ✅ Completion:
+ ✅ Completion:
 ```xml
 <action>
 <task_complete>

quantalogic/tools/__init__.py

@@ -22,7 +22,9 @@ 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
@@ -62,5 +64,8 @@ __all__ = [
     "ReadHTMLTool",
     "GrepAppTool",
     "GenerateDatabaseReportTool",
-    'SQLQueryTool'
+    'SQLQueryTool',
+    'SafePythonInterpreterTool'
+    'LLMGenerationTool',
+    'SequenceTool'
 ]

quantalogic/tools/safe_python_interpreter_tool.py

@@ -0,0 +1,213 @@
+"""
+Module: safe_python_interpreter_tool.py
+
+Description:
+    A tool to safely interpret Python code using a restricted set of allowed modules.
+    This version uses Pydantic V2 for configuration and validation and Loguru for logging.
+    The allowed modules are provided during initialization, and the tool's description
+    is dynamically generated based on that list.
+"""
+
+from __future__ import annotations
+
+import concurrent.futures
+from typing import Any, List, Literal, Self
+
+from loguru import logger
+from pydantic import Field, model_validator
+
+from quantalogic.tools.tool import Tool, ToolArgument
+from quantalogic.utils.python_interpreter import interpret_code
+
+# Configure Loguru
+logger.remove()  # Remove any default handler
+logger.add(lambda msg: print(msg, end=""), level="DEBUG")
+
+
+class SafePythonInterpreterTool(Tool):
+    """
+    A tool to safely execute Python code while only allowing a specific set
+    of modules as defined in `allowed_modules`.
+    """
+    # Allowed modules must be provided during initialization.
+    allowed_modules: List[str] = Field(
+        ...,
+        description="List of Python module names allowed for code execution."
+    )
+    # Additional fields to support the Tool API.
+    code: str | None = None  # Provided at runtime via kwargs.
+    time_limit: int = Field(
+        default=60,
+        description="Maximum execution time (in seconds) for running the Python code."
+    )
+    # Define tool arguments so that they appear in the tool's markdown description.
+    arguments: list[ToolArgument] = [
+        ToolArgument(
+            name="code",
+            arg_type="string",
+            description="The Python source code to be executed.",
+            required=True,
+            example="""
+import math
+import numpy as np
+
+def transform_array(x):
+    sqrt_vals = [math.sqrt(val) for val in x]
+    sin_vals = [math.sin(val) for val in sqrt_vals]
+    return sin_vals
+
+array_input = np.array([1, 4, 9, 16, 25])
+result = transform_array(array_input)
+result
+            """.strip()
+        ),
+        ToolArgument(
+            name="time_limit",
+            arg_type="int",
+            description="The execution timeout (in seconds).",
+            required=False,
+            default="60",
+            example="60"
+        )
+    ]
+    name: Literal["safe_python_interpreter"] = "safe_python_interpreter"
+    description: str | None = None
+
+    @model_validator(mode="after")
+    def set_description(self) -> Self:
+        desc = (
+            f"Safe Python interpreter tool. It interprets Python code with a restricted set "
+            f"of allowed modules. Only the following modules are available: {', '.join(self.allowed_modules)}. "
+            "This tool prevents usage of any modules or functions outside those allowed."
+        )
+        # Bypass Pydantic's validation assignment mechanism.
+        object.__setattr__(self, "description", desc)
+        logger.debug(f"SafePythonInterpreterTool initialized with modules: {self.allowed_modules}")
+        logger.debug(f"Tool description: {desc}")
+        return self
+
+    def execute(self, **kwargs) -> str:
+        """
+        Executes the provided Python code using the `interpret_code` function with a restricted
+        set of allowed modules. This method uses keyword arguments to support the Tool API.
+
+        Expected kwargs:
+            code (str): The Python source code to be executed.
+            time_limit (int, optional): Maximum execution time in seconds (default is 60).
+
+        Raises:
+            ValueError: If the provided code is empty.
+            RuntimeError: If the code execution exceeds the defined time limit.
+            Exception: For any errors during code execution.
+
+        Returns:
+            str: The string representation of the result of the executed code.
+        """
+        code = kwargs.get("code")
+        time_limit = kwargs.get("time_limit", self.time_limit)
+
+        if not code or not code.strip():
+            error_msg = "The provided Python code is empty."
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
+        def run_interpreter() -> Any:
+            logger.debug("Starting interpretation of code.")
+            import ast  # new import for AST processing
+            # Delegate to monkeypatched interpret_code if available.
+            if interpret_code.__module__ != "quantalogic.utils.python_interpreter":
+                return interpret_code(code, self.allowed_modules)
+            # Build safe globals with only allowed modules and minimal builtins.
+            safe_globals = {
+                "__builtins__": {
+                    "range": range,
+                    "len": len,
+                    "print": print,
+                    "__import__": __import__
+                }
+            }
+            for mod in self.allowed_modules:
+                safe_globals[mod] = __import__(mod)
+            local_vars = {}
+            try:
+                # Try evaluating as an expression.
+                compiled_expr = compile(code, "<string>", "eval")
+                result = eval(compiled_expr, safe_globals, local_vars)
+                return result
+            except SyntaxError:
+                # Parse code and capture the last expression if present.
+                tree = ast.parse(code)
+                if tree.body and isinstance(tree.body[-1], ast.Expr):
+                    last_expr = tree.body.pop()
+                    assign = ast.Assign(
+                        targets=[ast.Name(id="_result", ctx=ast.Store())],
+                        value=last_expr.value
+                    )
+                    assign = ast.copy_location(assign, last_expr)
+                    tree.body.append(assign)
+                    fixed_tree = ast.fix_missing_locations(tree)
+                    compiled = compile(fixed_tree, "<string>", "exec")
+                    exec(compiled, safe_globals, local_vars)
+                    return local_vars.get("_result", None)
+                else:
+                    compiled = compile(code, "<string>", "exec")
+                    exec(compiled, safe_globals, local_vars)
+                    return local_vars.get("result", None)
+            except Exception as e:
+                logger.error(f"Error during interpretation: {e}")
+                raise
+
+        # Enforce a timeout using ThreadPoolExecutor.
+        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
+            future = executor.submit(run_interpreter)
+            try:
+                result = future.result(timeout=time_limit)
+            except concurrent.futures.TimeoutError:
+                error_msg = f"Code execution exceeded time limit of {time_limit} seconds."
+                logger.error(error_msg)
+                raise RuntimeError(error_msg)
+            except Exception as e:
+                logger.error(f"Execution failed: {e}")
+                raise
+
+        return str(result)
+
+
+# ------------------------------------------
+# Example usage:
+# ------------------------------------------
+if __name__ == "__main__":
+    # Define the allowed modules. For this example, we allow only 'math' and 'numpy'.
+    allowed_modules = ["math", "numpy"]
+
+    # Initialize the tool using Pydantic.
+    interpreter_tool = SafePythonInterpreterTool(allowed_modules=allowed_modules)
+
+    # Print tool description.
+    print("Tool Description:")
+    print(interpreter_tool.description)
+
+    # Define Python code that uses both allowed modules.
+    code = """
+import math
+import numpy as np
+
+def transform_array(x):
+    # Apply square root to each element of the array
+    sqrt_vals = [math.sqrt(val) for val in x]
+    # Apply sine to each resulting value
+    sin_vals = [math.sin(val) for val in sqrt_vals]
+    return sin_vals
+
+array_input = np.array([1, 4, 9, 16, 25])
+result = transform_array(array_input)
+result
+    """
+
+    try:
+        # Call execute with keyword arguments as expected.
+        output = interpreter_tool.execute(code=code, time_limit=60)
+        print("Interpreter Output:")
+        print(output)
+    except Exception as e:
+        print(f"An error occurred during interpretation: {e}")

quantalogic/tools/sequence_tool.py

@@ -0,0 +1,285 @@
+"""
+Module for SequenceTool.
+
+The SequenceTool groups multiple tool calls into one action for use within the ReAct framework.
+It allows an LLM to invoke several authorized tools in one step by using XML syntax.
+The XML input must follow one of these formats:
+
+Option A (wrapped in a <sequence> element):
+  <sequence>
+    <tool_name1>
+      <param1>value1</param1>
+      <param2>value2</param2>
+      ...
+    </tool_name1>
+    <tool_name2>
+      <param1>value1</param1>
+    </tool_name2>
+    ...
+  </sequence>
+
+Option B (raw tool calls without a wrapping <sequence> element):
+  <tool_name1>
+    <param1>value1</param1>
+    <param2>value2</param2>
+    ...
+  </tool_name1>
+  <tool_name2>
+    <param1>value1</param1>
+  </tool_name2>
+  ...
+
+Where:
+  - In Option A the root tag is <sequence>.
+  - Each tool call (child element of <sequence>) must have a tag that exactly matches one of the authorized tools.
+  - In Option B the entire input is treated as the sequence content.
+  - The sub-elements inside each tool call represent parameter names and values.
+
+Objective:
+  Execute each tool call in order—even if some calls fail—and return a comprehensive XML report.
+  The report includes the execution order, the provided parameters, execution status (success/failure),
+  and either the output or error message for each call.
+
+Authorized Tools:
+  The list of authorized tool names is derived from the tools provided in the constructor.
+"""
+
+import xml.etree.ElementTree as ET
+from typing import Any, List
+
+from quantalogic.tools.tool import Tool, ToolArgument
+from quantalogic.xml_parser import ToleranceXMLParser
+from quantalogic.xml_tool_parser import ToolParser  # XML-based argument parser
+
+
+class SequenceTool(Tool):
+    """
+    A tool to execute a sequence of authorized tool calls specified in XML.
+
+    Description for the LLM:
+      Use this tool to chain multiple operations into one action. Provide an XML string that either
+      wraps the tool calls in a single <sequence> element or is the raw collection of tool calls.
+      The tag for each tool call must be one of the authorized tool names.
+      Authorized tools: {authorized_list}
+      
+      For each tool call, include the required parameters as sub-elements. The syntax is as follows:
+      
+      <sequence>
+          <tool_name>
+              <param1>value1</param1>
+              <param2>value2</param2>
+              ...
+          </tool_name>
+          ...
+      </sequence>
+      
+    Objective:
+      Execute each tool call in order—even if some calls fail—and return an XML report that includes
+      the order of execution, provided parameters, execution status (success/failure), and the output or
+      error message for each call.
+    """
+
+    def __init__(self, tools: List[Tool], **data: Any):
+        authorized_names = sorted(tool.name for tool in tools)
+        desc = (
+            "Executes a sequence of authorized tool calls defined in XML, then returns an XML report "
+            "detailing the outcome of each call. The XML input may either be wrapped in a <sequence> "
+            "element or provided as raw tool calls. Example formats:\n\n"
+            "Option A:\n"
+            "<sequence>\n"
+            "    <tool_name>\n"
+            "        <param1>value1</param1>\n"
+            "        <param2>value2</param2>\n"
+            "    </tool_name>\n"
+            "    ...\n"
+            "</sequence>\n\n"
+            "Option B:\n"
+            "<tool_name>\n"
+            "    <param1>value1</param1>\n"
+            "    <param2>value2</param2>\n"
+            "</tool_name>\n"
+            "...\n\n"
+            f"Authorized tools provided: {', '.join(authorized_names)}."
+        )
+        data.setdefault("name", "sequence_tool")
+        data.setdefault("description", desc)
+        default_argument = ToolArgument(
+            name="sequence",
+            arg_type="string",
+            required=True,
+            description="XML formatted sequence of tool calls. See syntax above.",
+        )
+        data.setdefault("arguments", [default_argument])
+        super().__init__(**data)
+
+        # Build a dictionary mapping tool names to tool instances.
+        self.available_tools = {tool.name: tool for tool in tools}
+
+    def execute(self, **kwargs) -> str:
+        """
+        Execute a sequence of tool calls provided in XML format and return an XML summary report.
+
+        Expected input formats:
+          Option A (wrapped):
+            <sequence>...</sequence>
+          Option B (raw):
+            <tool_name>...</tool_name>
+            <tool_name2>...</tool_name2>
+            ...
+
+        This implementation uses ToleranceXMLParser to extract the potential <sequence> element.
+        If exactly one <sequence> element is found, its content is used; otherwise, the entire input is treated
+        as the sequence content. Then, for each tool call, ToolParser (from quantalogic/xml_tool_parser.py)
+        is used to parse and validate arguments.
+
+        For each tool call, a <tool_call> element is created with:
+          - order: the position in the sequence.
+          - name: the tool's name.
+          - parameters: the parsed parameter names and values.
+          - status: "success" or "failure".
+          - output: tool output (if successful) or error_message (if an error occurred).
+
+        All tool calls are executed regardless of failures.
+        """
+        if "sequence" not in kwargs:
+            raise ValueError("Missing 'sequence' parameter.")
+
+        sequence_xml = kwargs["sequence"]
+        xml_parser = ToleranceXMLParser()
+
+        # Try to locate <sequence> elements in the input.
+        all_elements = xml_parser._find_all_elements(sequence_xml)
+        sequence_elems = [
+            (tag, content)
+            for tag, content in all_elements
+            if tag.strip().lower() == "sequence"
+        ]
+        if len(sequence_elems) > 1:
+            raise ValueError("Input XML must contain exactly one <sequence> element.")
+        elif len(sequence_elems) == 1:
+            # Use the inner content of the found <sequence> element.
+            sequence_content = sequence_elems[0][1]
+        else:
+            # No <sequence> element found; assume the entire input is the sequence content.
+            sequence_content = sequence_xml
+
+        # Extract tool call elements from the sequence content.
+        # Each tool call is represented as a tuple: (tool_name, inner_xml)
+        tool_calls = xml_parser._find_all_elements(sequence_content)
+        results_root = ET.Element("sequence_results")
+
+        for index, (tool_name, inner_xml) in enumerate(tool_calls, start=1):
+            tool_call_elem = ET.Element("tool_call", attrib={"order": str(index), "name": tool_name})
+            parameters_elem = ET.SubElement(tool_call_elem, "parameters")
+
+            # Validate that this is an authorized tool.
+            if tool_name not in self.available_tools:
+                status_elem = ET.SubElement(tool_call_elem, "status")
+                status_elem.text = "failure"
+                error_elem = ET.SubElement(tool_call_elem, "error_message")
+                error_elem.text = f"Tool '{tool_name}' not found among authorized tools."
+                results_root.append(tool_call_elem)
+                continue
+
+            tool = self.available_tools[tool_name]
+            # Use ToolParser to extract and validate arguments from the inner XML.
+            tool_parser = ToolParser(tool)
+            try:
+                parsed_params = tool_parser.parse(inner_xml)
+                # Record parsed parameters in the XML report.
+                for arg_name, arg_value in parsed_params.items():
+                    param_record = ET.SubElement(parameters_elem, "param", attrib={"name": arg_name})
+                    param_record.text = arg_value
+            except Exception as e:
+                status_elem = ET.SubElement(tool_call_elem, "status")
+                status_elem.text = "failure"
+                error_elem = ET.SubElement(tool_call_elem, "error_message")
+                error_elem.text = f"Argument parsing error: {str(e)}"
+                results_root.append(tool_call_elem)
+                continue
+
+            # Execute the authorized tool with the validated parameters.
+            try:
+                output = tool.execute(**parsed_params)
+                status_elem = ET.SubElement(tool_call_elem, "status")
+                status_elem.text = "success"
+                output_elem = ET.SubElement(tool_call_elem, "output")
+                output_elem.text = output
+            except Exception as e:
+                status_elem = ET.SubElement(tool_call_elem, "status")
+                status_elem.text = "failure"
+                error_elem = ET.SubElement(tool_call_elem, "error_message")
+                error_elem.text = str(e)
+            results_root.append(tool_call_elem)
+
+        return ET.tostring(results_root, encoding="unicode")
+
+
+# ----------------- Example Usage and Testing -----------------
+
+if __name__ == "__main__":
+    from typing import Any
+
+    # Dummy tool: WriteFileTool simulates writing content to a file.
+    class WriteFileTool(Tool):
+        def __init__(self, **data: Any):
+            data.setdefault("name", "write_file_tool")
+            data.setdefault("description", "Writes content to a file at the specified path.")
+            data.setdefault("arguments", [
+                ToolArgument(
+                    name="file_path",
+                    arg_type="string",
+                    required=True,
+                    description="Path to the file"
+                ),
+                ToolArgument(
+                    name="content",
+                    arg_type="string",
+                    required=True,
+                    description="Content to write to the file"
+                )
+            ])
+            super().__init__(**data)
+
+        def execute(self, **kwargs) -> str:
+            file_path = kwargs.get("file_path", "")
+            content = kwargs.get("content", "")
+            # For demonstration, simulate writing to a file.
+            return f"File '{file_path}' written with content length {len(content)}."
+
+    # Instantiate the WriteFileTool.
+    write_file = WriteFileTool()
+
+    # Instantiate the SequenceTool with WriteFileTool as the authorized tool.
+    sequence_tool = SequenceTool(tools=[write_file])
+
+    # Example XML sequence using CDATA blocks for multiline content.
+    # This example uses Option A (wrapped in a <sequence> element).
+    xml_sequence = """
+    <sequence>
+      <write_file_tool>
+        <file_path>poem1.txt</file_path>
+        <content><![CDATA[
+Under the moon's silver glow,
+Where shadows dance and winds do flow,
+There lies a heart so pure and bright,
+In the quiet of the night.
+        ]]></content>
+      </write_file_tool>
+      <write_file_tool>
+        <file_path>poem2.txt</file_path>
+        <content><![CDATA[
+In the morning's golden light,
+When dewdrops kiss the grass so bright,
+The world awakens anew each day,
+And hope finds its own sweet way.
+        ]]></content>
+      </write_file_tool>
+    </sequence>
+    """
+
+    try:
+        result_xml = sequence_tool.execute(sequence=xml_sequence)
+        print("SequenceTool result:\n", result_xml)
+    except Exception as e:
+        print("SequenceTool error:\n", str(e))

quantalogic/utils/__init__.py

@@ -6,6 +6,7 @@ from .get_environment import get_environment
 from .get_coding_environment import get_coding_environment
 from .get_quantalogic_rules_content import get_quantalogic_rules_file_content
 from .lm_studio_model_info import get_model_list
+from .python_interpreter import interpret_ast
 
 __all__ = [
     "download_http_file",