quantalogic 0.61.2__py3-none-any.whl → 0.80__py3-none-any.whl

quantalogic/codeact/tools_manager.py

@@ -1,135 +1,258 @@
+"""Tool management module for defining and retrieving agent tools."""
+
 import asyncio
+import importlib
+import importlib.metadata
+import inspect
+import os
 from contextlib import AsyncExitStack
-from typing import List
+from typing import Any, Dict, List, Optional
 
 import litellm
 from loguru import logger
 
-from quantalogic.tools import (
-    EditWholeContentTool,
-    ExecuteBashCommandTool,
-    GrepAppTool,
-    InputQuestionTool,
-    JinjaTool,
-    ListDirectoryTool,
-    ReadFileBlockTool,
-    ReadFileTool,
-    ReadHTMLTool,
-    ReplaceInFileTool,
-    RipgrepTool,
-    SearchDefinitionNamesTool,
-    TaskCompleteTool,
-    Tool,
-    ToolArgument,
-    WriteFileTool,
-    create_tool,
-)
-
-from .utils import log_async_tool, log_tool_method
-
-
-@create_tool
-@log_async_tool("Adding")
-async def add_tool(a: int, b: int) -> str:
-    """Adds two numbers and returns the sum as a string."""
-    return str(a + b)
-
-@create_tool
-@log_async_tool("Multiplying")
-async def multiply_tool(x: int, y: int) -> str:
-    """Multiplies two numbers and returns the product as a string."""
-    return str(x * y)
-
-@create_tool
-@log_async_tool("Concatenating")
-async def concat_tool(s1: str, s2: str) -> str:
-    """Concatenates two strings and returns the result."""
-    return s1 + s2
+from quantalogic.tools import Tool, ToolArgument
+
+from .utils import log_tool_method
+
+
+class ToolRegistry:
+    """Manages tool registration with dependency and conflict checking."""
+    def __init__(self):
+        self.tools: Dict[tuple[str, str], Tool] = {}
+
+    def register(self, tool: Tool) -> None:
+        """Register a tool, checking for conflicts within the same toolbox."""
+        try:
+            key = (tool.toolbox_name or "default", tool.name)
+            if key in self.tools:
+                logger.warning(f"Tool '{tool.name}' in toolbox '{tool.toolbox_name or 'default'}' is already registered. Skipping.")
+                return
+            self.tools[key] = tool
+            logger.debug(f"Tool registered: {tool.name} in toolbox {tool.toolbox_name or 'default'}")
+        except Exception as e:
+            logger.error(f"Failed to register tool {tool.name}: {e}")
+            raise
+
+    def get_tools(self) -> List[Tool]:
+        """Return all registered tools."""
+        try:
+            logger.debug(f"Returning {len(self.tools)} tools: {list(self.tools.keys())}")
+            return list(self.tools.values())
+        except Exception as e:
+            logger.error(f"Error retrieving tools: {e}")
+            return []
+
+    def register_tools_from_module(self, module, toolbox_name: str) -> None:
+        """Register all @create_tool generated Tool instances from a module with toolbox name."""
+        try:
+            tools_found = False
+            for name, obj in inspect.getmembers(module):
+                if isinstance(obj, Tool) and hasattr(obj, '_func'):
+                    obj.toolbox_name = toolbox_name
+                    self.register(obj)
+                    logger.debug(f"Registered tool: {obj.name} from {module.__name__} in toolbox {toolbox_name}")
+                    tools_found = True
+            if not tools_found:
+                logger.warning(f"No @create_tool generated tools found in {module.__name__}")
+        except Exception as e:
+            logger.error(f"Failed to register tools from module {module.__name__}: {e}")
+            raise
+
+    def load_toolboxes(self, toolbox_names: Optional[List[str]] = None) -> None:
+        """Load toolboxes from registered entry points, optionally filtering by name."""
+        try:
+            entry_points = importlib.metadata.entry_points(group="quantalogic.tools")
+        except Exception as e:
+            logger.error(f"Failed to retrieve entry points: {e}")
+            entry_points = []
+
+        try:
+            if toolbox_names is not None:
+                entry_points = [ep for ep in entry_points if ep.name in toolbox_names]
+
+            logger.debug(f"Found {len(entry_points)} toolbox entry points")
+            for ep in entry_points:
+                try:
+                    module = ep.load()
+                    self.register_tools_from_module(module, toolbox_name=ep.name)
+                    logger.info(f"Successfully loaded toolbox: {ep.name}")
+                except ImportError as e:
+                    logger.error(f"Failed to import toolbox {ep.name}: {e}")
+        except Exception as e:
+            logger.error(f"Error loading toolboxes: {e}")
+
 
 class AgentTool(Tool):
-    """Tool for generating text using a language model."""
-    def __init__(self, model: str = "gemini/gemini-2.0-flash"):
-        super().__init__(
-            name="agent_tool",
-            description="Generates text using a language model.",
-            arguments=[
-                ToolArgument(name="system_prompt", arg_type="string", 
-                           description="System prompt to guide the model", required=True),
-                ToolArgument(name="prompt", arg_type="string", 
-                           description="User prompt to generate a response", required=True),
-                ToolArgument(name="temperature", arg_type="float", 
-                           description="Temperature for generation (0 to 1)", required=True)
-            ],
-            return_type="string"
-        )
-        self.model = model
+    """A specialized tool for generating text using language models, designed for AI agent workflows."""
+    def __init__(self, model: str = None, timeout: int = None, config: Optional[Dict[str, Any]] = None) -> None:
+        """Initialize the AgentTool with configurable model and timeout."""
+        try:
+            super().__init__(
+                name="agent_tool",
+                description="Generates text using a language model. This is a stateless agent - all necessary context must be explicitly provided in either the system prompt or user prompt.",
+                arguments=[
+                    ToolArgument(name="system_prompt", arg_type="string", description="System prompt to guide the model", required=True),
+                    ToolArgument(name="prompt", arg_type="string", description="User prompt to generate a response", required=True),
+                    ToolArgument(name="temperature", arg_type="float", description="Temperature for generation (0 to 1)", required=True)
+                ],
+                return_type="string"
+            )
+            self.config = config or {}
+            self.model: str = self._resolve_model(model)
+            self.timeout: int = self._resolve_timeout(timeout)
+        except Exception as e:
+            logger.error(f"Failed to initialize AgentTool: {e}")
+            raise
+
+    def _resolve_model(self, model: Optional[str]) -> str:
+        """Resolve the model from config, argument, or environment variable."""
+        try:
+            return self.config.get("model", model) or os.getenv("AGENT_MODEL", "gemini/gemini-2.0-flash")
+        except Exception as e:
+            logger.error(f"Error resolving model: {e}. Using default.")
+            return "gemini/gemini-2.0-flash"
+
+    def _resolve_timeout(self, timeout: Optional[int]) -> int:
+        """Resolve the timeout from config, argument, or environment variable."""
+        try:
+            return self.config.get("timeout", timeout) or int(os.getenv("AGENT_TIMEOUT", "30"))
+        except (ValueError, TypeError) as e:
+            logger.error(f"Error resolving timeout: {e}. Using default.")
+            return 30
 
     @log_tool_method
     async def async_execute(self, **kwargs) -> str:
-        system_prompt = kwargs["system_prompt"]
-        prompt = kwargs["prompt"]
-        temperature = float(kwargs["temperature"])
-
-        if not 0 <= temperature <= 1:
-            raise ValueError("Temperature must be between 0 and 1")
-
-        logger.info(f"Generating with {self.model}, temp={temperature}")
-        async with AsyncExitStack() as stack:
-            await stack.enter_async_context(asyncio.timeout(30))
-            response = await litellm.acompletion(
-                model=self.model,
-                messages=[
-                    {"role": "system", "content": system_prompt},
-                    {"role": "user", "content": prompt}
-                ],
-                temperature=temperature,
-                max_tokens=1000
-            )
-            return response.choices[0].message.content.strip()
+        """Execute the tool asynchronously with error handling."""
+        try:
+            system_prompt: str = kwargs["system_prompt"]
+            prompt: str = kwargs["prompt"]
+            temperature: float = float(kwargs["temperature"])
+
+            if not 0 <= temperature <= 1:
+                raise ValueError("Temperature must be between 0 and 1")
+
+            logger.info(f"Generating with {self.model}, temp={temperature}, timeout={self.timeout}s")
+            async with AsyncExitStack() as stack:
+                await stack.enter_async_context(asyncio.timeout(self.timeout))
+                try:
+                    response = await litellm.acompletion(
+                        model=self.model,
+                        messages=[
+                            {"role": "system", "content": system_prompt},
+                            {"role": "user", "content": prompt}
+                        ],
+                        temperature=temperature,
+                        max_tokens=1000
+                    )
+                    result = response.choices[0].message.content.strip()
+                    logger.info(f"AgentTool generated text successfully: {result[:50]}...")
+                    return result
+                except Exception as e:
+                    error_msg = f"Error: Unable to generate text due to {str(e)}"
+                    logger.error(f"AgentTool failed: {e}")
+                    return error_msg
+        except TimeoutError:
+            logger.error(f"AgentTool execution timed out after {self.timeout}s")
+            return "Error: Execution timed out"
+        except Exception as e:
+            logger.error(f"Unexpected error in AgentTool execution: {e}")
+            return f"Error: {str(e)}"
+
 
 class RetrieveStepTool(Tool):
-    """Tool to retrieve information from a specific previous step."""
-    def __init__(self, history_store: List[dict]):
-        super().__init__(
-            name="retrieve_step",
-            description="Retrieve the thought, action, and result from a specific step.",
-            arguments=[
-                ToolArgument(name="step_number", arg_type="int", 
-                            description="The step number to retrieve (1-based)", required=True)
-            ],
-            return_type="string"
-        )
-        self.history_store = history_store
+    """Tool to retrieve information from a specific previous step with indexed access."""
+    def __init__(self, history_store: List[dict], config: Optional[Dict[str, Any]] = None) -> None:
+        """Initialize the RetrieveStepTool with history store."""
+        try:
+            super().__init__(
+                name="retrieve_step",
+                description="Retrieve the thought, action, and result from a specific step.",
+                arguments=[
+                    ToolArgument(name="step_number", arg_type="int", description="The step number to retrieve (1-based)", required=True)
+                ],
+                return_type="string"
+            )
+            self.config = config or {}
+            self.history_index: Dict[int, dict] = {i + 1: step for i, step in enumerate(history_store)}
+        except Exception as e:
+            logger.error(f"Failed to initialize RetrieveStepTool: {e}")
+            raise
 
     @log_tool_method
     async def async_execute(self, **kwargs) -> str:
-        step_number = kwargs["step_number"]
-        if step_number < 1 or step_number > len(self.history_store):
-            return f"Error: Step {step_number} does not exist."
-        step = self.history_store[step_number - 1]
-        return (
-            f"Step {step_number}:\n"
-            f"Thought: {step['thought']}\n"
-            f"Action: {step['action']}\n"
-            f"Result: {step['result']}"
-        )
-
-def get_default_tools(model: str) -> List[Tool]:
-    """Return list of default tools."""
-    return [
-        #EditWholeContentTool(), 
-        #ExecuteBashCommandTool(), 
-        GrepAppTool(),
-        InputQuestionTool(), 
-        JinjaTool(), 
-        ListDirectoryTool(),
-        ReadFileBlockTool(), 
-        ReadFileTool(), 
-        ReadHTMLTool(),
-        #ReplaceInFileTool(), 
-        # RipgrepTool(), 
-        # SearchDefinitionNamesTool(),
-        #TaskCompleteTool(), 
-        WriteFileTool(), 
-        AgentTool(model=model),
-    ]
+        """Execute the tool to retrieve step information."""
+        try:
+            step_number: int = kwargs["step_number"]
+            if step_number not in self.history_index:
+                error_msg = f"Error: Step {step_number} is out of range (1-{len(self.history_index)})"
+                logger.error(error_msg)
+                raise ValueError(error_msg)
+            step: dict = self.history_index[step_number]
+            result = (
+                f"Step {step_number}:\n"
+                f"Thought: {step['thought']}\n"
+                f"Action: {step['action']}\n"
+                f"Result: {step['result']}"
+            )
+            logger.info(f"Retrieved step {step_number} successfully")
+            return result
+        except Exception as e:
+            logger.error(f"Error retrieving step {kwargs.get('step_number', 'unknown')}: {e}")
+            return f"Error: {str(e)}"
+
+
+def get_default_tools(
+    model: str,
+    history_store: Optional[List[dict]] = None,
+    enabled_toolboxes: Optional[List[str]] = None,
+    tools_config: Optional[List[Dict[str, Any]]] = None
+) -> List[Tool]:
+    """Dynamically load default tools using the pre-loaded registry from PluginManager."""
+    from .cli import plugin_manager  # Import shared singleton plugin_manager
+
+    try:
+        # Ensure plugins are loaded
+        plugin_manager.load_plugins()
+        registry = plugin_manager.tools
+        
+        # Register static tools if not already present
+        static_tools: List[Tool] = [AgentTool(model=model)]
+        if history_store is not None:
+            static_tools.append(RetrieveStepTool(history_store))
+
+        for tool in static_tools:
+            try:
+                registry.register(tool)
+            except ValueError as e:
+                logger.debug(f"Static tool {tool.name} already registered: {e}")
+
+        # Filter tools based on enabled_toolboxes
+        if enabled_toolboxes:
+            tools = [t for t in registry.get_tools() if t.toolbox_name in enabled_toolboxes]
+        else:
+            tools = registry.get_tools()
+
+        # Apply tools_config if provided
+        if tools_config:
+            filtered_tools = []
+            processed_names = set()
+            for tool_conf in tools_config:
+                if tool_conf.get("enabled", True):
+                    tool = next((t for t in tools if t.name == tool_conf["name"] or t.toolbox_name == tool_conf["name"]), None)
+                    if tool and tool.name not in processed_names:
+                        for key, value in tool_conf.items():
+                            if key not in ["name", "enabled"]:
+                                setattr(tool, key, value)
+                        filtered_tools.append(tool)
+                        processed_names.add(tool.name)
+            for tool in tools:
+                if tool.name not in processed_names:
+                    filtered_tools.append(tool)
+            tools = filtered_tools
+        
+        logger.info(f"Loaded {len(tools)} default tools: {[(tool.toolbox_name or 'default', tool.name) for tool in tools]}")
+        return tools
+    except Exception as e:
+        logger.error(f"Failed to load default tools: {e}")
+        return []

quantalogic/codeact/utils.py

@@ -1,10 +1,11 @@
 import ast
 import inspect
 from functools import wraps
-from typing import Any, Callable, Tuple
+from typing import Callable, List, Union
 
 from loguru import logger
-from lxml import etree
+
+from quantalogic.tools import Tool, create_tool
 
 
 def log_async_tool(verb: str):
@@ -23,7 +24,6 @@ def log_async_tool(verb: str):
         return wrapper
     return decorator
 
-
 def log_tool_method(func: Callable) -> Callable:
     """Decorator for logging Tool class methods."""
     @wraps(func)
@@ -38,17 +38,6 @@ def log_tool_method(func: Callable) -> Callable:
             raise
     return wrapper
 
-
-def validate_xml(xml_string: str) -> bool:
-    """Validate XML string."""
-    try:
-        etree.fromstring(xml_string)
-        return True
-    except etree.XMLSyntaxError as e:
-        logger.error(f"XML validation failed: {e}")
-        return False
-
-
 def validate_code(code: str) -> bool:
     """Check if code has an async main() function."""
     try:
@@ -58,78 +47,16 @@ def validate_code(code: str) -> bool:
     except SyntaxError:
         return False
 
-
-def format_xml_element(tag: str, value: Any, **attribs) -> etree.Element:
-    """Create an XML element with optional CDATA and attributes."""
-    elem = etree.Element(tag, **attribs)
-    elem.text = etree.CDATA(str(value)) if value is not None else None
-    return elem
-
-
-class XMLResultHandler:
-    """Utility class for handling XML formatting and parsing."""
-    @staticmethod
-    def format_execution_result(result) -> str:
-        """Format execution result as XML."""
-        root = etree.Element("ExecutionResult")
-        root.append(format_xml_element("Status", "Success" if not result.error else "Error"))
-        root.append(format_xml_element("Value", result.result or result.error))
-        root.append(format_xml_element("ExecutionTime", f"{result.execution_time:.2f} seconds"))
-
-        completed = result.result and result.result.startswith("Task completed:")
-        root.append(format_xml_element("Completed", str(completed).lower()))
-        
-        if completed:
-            final_answer = result.result[len("Task completed:"):].strip()
-            root.append(format_xml_element("FinalAnswer", final_answer))
-
-        if result.local_variables:
-            vars_elem = etree.SubElement(root, "Variables")
-            for k, v in result.local_variables.items():
-                if not callable(v) and not k.startswith("__"):
-                    vars_elem.append(format_xml_element("Variable", str(v)[:5000] + 
-                                                      ("... (truncated)" if len(str(v)) > 5000 else ""), 
-                                                      name=k))
-        return etree.tostring(root, pretty_print=True, encoding="unicode")
-
-    @staticmethod
-    def format_result_summary(result_xml: str) -> str:
-        """Format XML result into a readable summary."""
-        try:
-            root = etree.fromstring(result_xml)
-            lines = [
-                f"- Status: {root.findtext('Status', 'N/A')}",
-                f"- Value: {root.findtext('Value', 'N/A')}",
-                f"- Execution Time: {root.findtext('ExecutionTime', 'N/A')}",
-                f"- Completed: {root.findtext('Completed', 'N/A').capitalize()}"
-            ]
-            if final_answer := root.findtext("FinalAnswer"):
-                lines.append(f"- Final Answer: {final_answer}")
-
-            if (vars_elem := root.find("Variables")) is not None:
-                lines.append("- Variables:")
-                lines.extend(f"  - {var.get('name', 'unknown')}: {var.text.strip() or 'N/A'}" 
-                            for var in vars_elem.findall("Variable"))
-            return "\n".join(lines)
-        except etree.XMLSyntaxError:
-            logger.error(f"Failed to parse XML: {result_xml}")
-            return result_xml
-
-    @staticmethod
-    def parse_response(response: str) -> Tuple[str, str]:
-        """Parse XML response to extract thought and code."""
-        try:
-            root = etree.fromstring(response)
-            thought = root.findtext("Thought") or ""
-            code = root.findtext("Code") or ""
-            return thought, code
-        except etree.XMLSyntaxError as e:
-            raise ValueError(f"Failed to parse XML: {e}")
-
-    @staticmethod
-    def extract_result_value(result: str) -> str:
-        """Extract the value from the result XML."""
-        try:
-            return etree.fromstring(result).findtext("Value") or ""
-        except etree.XMLSyntaxError:
-            return ""
+def process_tools(tools: List[Union[Tool, Callable]]) -> List[Tool]:
+    """Convert a list of tools or callables into Tool instances."""
+    processed_tools: List[Tool] = []
+    for tool in tools:
+        if isinstance(tool, Tool):
+            processed_tools.append(tool)
+        elif callable(tool):
+            if not inspect.iscoroutinefunction(tool):
+                raise ValueError(f"Callable '{tool.__name__}' must be an async function to be used as a tool.")
+            processed_tools.append(create_tool(tool))
+        else:
+            raise ValueError(f"Invalid item type: {type(tool)}. Expected Tool or async function.")
+    return processed_tools

quantalogic/codeact/xml_utils.py

@@ -0,0 +1,126 @@
+from typing import Any, Tuple
+
+from loguru import logger
+from lxml import etree
+
+
+def validate_xml(xml_string: str) -> bool:
+    """Validate XML string using strict parser."""
+    try:
+        etree.fromstring(xml_string)
+        return True
+    except etree.XMLSyntaxError as e:
+        logger.error(f"XML validation failed: {e}")
+        return False
+
+def format_xml_element(tag: str, value: Any, **attribs) -> etree.Element:
+    """Create an XML element with optional CDATA and attributes."""
+    elem = etree.Element(tag, **attribs)
+    elem.text = etree.CDATA(str(value)) if value is not None else None
+    return elem
+
+class XMLResultHandler:
+    """Utility class for handling all XML formatting and parsing operations."""
+    
+    _parser = etree.XMLParser(recover=True, remove_comments=True, resolve_entities=False)
+
+    @staticmethod
+    def format_execution_result(result) -> str:
+        """Format execution result as XML with proper variable handling."""
+        root = etree.Element("ExecutionResult")
+        root.append(format_xml_element("Status", "Success" if not result.error else "Error"))
+        root.append(format_xml_element("Value", result.result or result.error))
+        root.append(format_xml_element("ExecutionTime", f"{result.execution_time:.2f} seconds"))
+
+        completed = result.result and result.result.startswith("Task completed:")
+        root.append(format_xml_element("Completed", str(completed).lower()))
+        
+        if completed:
+            final_answer = result.result[len("Task completed:"):].strip()
+            root.append(format_xml_element("FinalAnswer", final_answer))
+
+        if result.local_variables:
+            vars_elem = etree.SubElement(root, "Variables")
+            for k, v in result.local_variables.items():
+                if not callable(v) and not k.startswith("__"):
+                    var_elem = etree.SubElement(vars_elem, "Variable", name=k)
+                    var_value = str(v)[:5000] + ("... (truncated)" if len(str(v)) > 5000 else "")
+                    var_elem.text = etree.CDATA(var_value)
+        
+        xml_str = etree.tostring(root, pretty_print=True, encoding="unicode")
+        if not validate_xml(xml_str):
+            logger.error(f"Generated invalid XML: {xml_str}")
+            raise ValueError("Generated XML is invalid")
+        return xml_str
+
+    @staticmethod
+    def format_result_summary(result_xml: str) -> str:
+        """Format XML result into a readable summary with error resilience."""
+        try:
+            root = etree.fromstring(result_xml, parser=XMLResultHandler._parser)
+            if root is None:
+                raise ValueError("Empty XML document")
+            
+            lines = [
+                f"- Status: {root.findtext('Status', 'N/A')}",
+                f"- Value: {root.findtext('Value', 'N/A')}",
+                f"- Execution Time: {root.findtext('ExecutionTime', 'N/A')}",
+                f"- Completed: {root.findtext('Completed', 'N/A').capitalize()}"
+            ]
+            
+            if final_answer := root.findtext("FinalAnswer"):
+                lines.append(f"- Final Answer: {final_answer}")
+
+            if (vars_elem := root.find("Variables")) is not None:
+                lines.append("- Variables:")
+                lines.extend(f"  - {var.get('name', 'unknown')}: {var.text.strip() or 'N/A'}" 
+                            for var in vars_elem.findall("Variable"))
+            return "\n".join(lines)
+        except (etree.XMLSyntaxError, ValueError) as e:
+            logger.error(f"Failed to parse XML result: {e}")
+            return f"Raw Result (Error: {str(e)}):\n{result_xml}"
+
+    @staticmethod
+    def parse_action_response(response: str) -> Tuple[str, str]:
+        """Parse XML response to extract thought and code with robust error handling."""
+        try:
+            root = etree.fromstring(response, parser=XMLResultHandler._parser)
+            if root is None:
+                raise ValueError("Empty XML document")
+            
+            # Log XML parsing warnings
+            if XMLResultHandler._parser.error_log:
+                for error in XMLResultHandler._parser.error_log:
+                    logger.warning(f"XML parse warning: {error.message} (line {error.line})")
+            
+            return (
+                root.findtext("Thought") or "",
+                root.findtext("Code") or ""
+            )
+        except etree.XMLSyntaxError as e:
+            logger.error(f"Critical XML parsing error: {e}")
+            raise ValueError(f"Malformed XML structure: {e}") from e
+
+    @staticmethod
+    def extract_result_value(result: str) -> str:
+        """Safely extract the value from the result XML."""
+        try:
+            root = etree.fromstring(result, parser=XMLResultHandler._parser)
+            return root.findtext("Value") or "" if root is not None else ""
+        except etree.XMLSyntaxError as e:
+            logger.warning(f"XML extraction error: {e}")
+            return ""
+
+    @staticmethod
+    def format_error_result(error_msg: str) -> str:
+        """Format an error result as XML with proper escaping."""
+        root = etree.Element("Action")
+        root.append(format_xml_element("Thought", f"Failed to generate valid action: {error_msg}"))
+        error_elem = etree.SubElement(root, "Error")
+        error_elem.append(format_xml_element("Message", error_msg))
+        root.append(format_xml_element("Code", """
+import asyncio
+async def main():
+    print("Error: Action generation failed")
+"""))
+        return etree.tostring(root, pretty_print=True, encoding="unicode")