quantalogic 0.33.1__py3-none-any.whl → 0.33.3__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/read_html_tool.py

@@ -105,21 +105,23 @@ class ReadHTMLTool(Tool):
             description="Convert input to 'text' (Markdown) or 'html'. Default is 'text'",
             default='text',
             required=False,
-            example="'text' or 'html'"
+            example="'text' or 'html'",
         ),
         ToolArgument(
             name="line_start",
             arg_type="int",
             description="The starting line number (1-based index). Default: 1",
             required=False,
-            example="1"
+            example="1",
+            default=1
         ),
         ToolArgument(
             name="line_end",
             arg_type="int",
             description="The ending line number (1-based index). Default: 300",
             required=False,
-            example="300"
+            example="300",
+            default=300
         )
     ]
 

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}")