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

quantalogic/codeact/reasoner.py

@@ -1,185 +0,0 @@
-import ast
-import asyncio
-from abc import ABC, abstractmethod
-from typing import Any, Callable, Dict, List, Optional
-
-from quantalogic.tools import Tool
-
-from .constants import MAX_GENERATE_PROGRAM_TOKENS
-from .events import PromptGeneratedEvent
-from .llm_util import litellm_completion
-from .templates import jinja_env
-from .xml_utils import XMLResultHandler, validate_xml
-
-
-async def generate_program(
-    task_description: str,
-    tools: List[Tool],
-    model: str,
-    max_tokens: int,
-    step: int,
-    notify_event: Callable,
-    streaming: bool = False
-) -> str:
-    """Generate a Python program using the specified model with streaming support and retries."""
-    tools_by_toolbox = {}
-    for tool in tools:
-        toolbox_name = tool.toolbox_name if tool.toolbox_name else "default"
-        if toolbox_name not in tools_by_toolbox:
-            tools_by_toolbox[toolbox_name] = []
-        tools_by_toolbox[toolbox_name].append(tool.to_docstring())
-
-    prompt = jinja_env.get_template("generate_program.j2").render(
-        task_description=task_description,
-        tools_by_toolbox=tools_by_toolbox
-    )
-    await notify_event(PromptGeneratedEvent(
-        event_type="PromptGenerated", step_number=step, prompt=prompt
-    ))
-
-    for attempt in range(3):
-        try:
-            response = await litellm_completion(
-                model=model,
-                messages=[
-                    {"role": "system", "content": "You are a Python code generator."},
-                    {"role": "user", "content": prompt}
-                ],
-                max_tokens=max_tokens,
-                temperature=0.3,
-                stream=streaming,
-                step=step,
-                notify_event=notify_event
-            )
-            code = response.strip()
-            return code[9:-3].strip() if code.startswith("```python") and code.endswith("```") else code
-        except Exception as e:
-            if attempt < 2:
-                await asyncio.sleep(2 ** attempt)
-            else:
-                raise Exception(f"Code generation failed with {model} after 3 attempts: {e}")
-
-
-class PromptStrategy(ABC):
-    """Abstract base class for prompt generation strategies."""
-    @abstractmethod
-    async def generate_prompt(self, task: str, history_str: str, step: int, max_iterations: int, available_vars: List[str]) -> str:
-        pass
-
-
-class DefaultPromptStrategy(PromptStrategy):
-    """Default strategy using Jinja2 templates."""
-    async def generate_prompt(self, task: str, history_str: str, step: int, max_iterations: int, available_vars: List[str]) -> str:
-        return jinja_env.get_template("generate_action.j2").render(
-            task=task,
-            history_str=history_str,
-            current_step=step,
-            max_iterations=max_iterations,
-            available_vars=available_vars
-        )
-
-
-class BaseReasoner(ABC):
-    """Abstract base class for reasoning components."""
-    @abstractmethod
-    async def generate_action(
-        self,
-        task: str,
-        history_str: str,
-        step: int,
-        max_iterations: int,
-        system_prompt: Optional[str],
-        notify_event: Callable,
-        streaming: bool,
-        available_vars: List[str]
-    ) -> str:
-        pass
-
-
-class Reasoner(BaseReasoner):
-    """Handles action generation using the language model."""
-    def __init__(self, model: str, tools: List[Tool], config: Optional[Dict[str, Any]] = None, prompt_strategy: Optional[PromptStrategy] = None):
-        self.model = model
-        self.tools = tools
-        self.config = config or {}
-        self.prompt_strategy = prompt_strategy or DefaultPromptStrategy()
-
-    async def generate_action(
-        self,
-        task: str,
-        history_str: str,
-        step: int,
-        max_iterations: int,
-        system_prompt: Optional[str] = None,
-        notify_event: Callable = None,
-        streaming: bool = False,
-        available_vars: List[str] = None
-    ) -> str:
-        """Generate an action based on task and history with streaming support."""
-        try:
-            # Prepare type hints for available variables based on tool return types
-            available_var_types = {}
-            for var_name in available_vars or []:
-                # Infer type from tool documentation if possible (simplified heuristic)
-                if "plan" in var_name.lower():
-                    available_var_types[var_name] = "PlanResult (has attributes: task_id, task_description, subtasks)"
-                else:
-                    available_var_types[var_name] = "Unknown (check history or assume str)"
-
-            task_prompt = await self.prompt_strategy.generate_prompt(
-                task if not system_prompt else f"{system_prompt}\nTask: {task}",
-                history_str,
-                step,
-                max_iterations,
-                available_vars or []  # Default to empty list if None
-            )
-            await notify_event(PromptGeneratedEvent(
-                event_type="PromptGenerated", step_number=step, prompt=task_prompt
-            ))
-            program = await generate_program(
-                task_prompt + f"\n\nVariable Types in context_vars:\n{available_var_types}",
-                self.tools, 
-                self.model, 
-                self.config.get("max_tokens", MAX_GENERATE_PROGRAM_TOKENS), 
-                step, 
-                notify_event, 
-                streaming=streaming
-            )
-            program = self._clean_code(program)
-            response = jinja_env.get_template("response_format.j2").render(
-                task=task,
-                included_stepsincluded_stepshistory_str=history_str,
-                program=program,
-                current_step=step,
-                max_iterations=max_iterations
-            )
-            if not validate_xml(response):
-                raise ValueError("Invalid XML generated")
-            return response
-        except Exception as e:
-            return XMLResultHandler.format_error_result(str(e))
-
-    def _clean_code(self, code: str) -> str:
-        lines = code.splitlines()
-        in_code_block = False
-        code_lines = []
-        
-        for line in lines:
-            if line.startswith('```python'):
-                in_code_block = True
-                code_part = line[len('```python'):].strip()
-                if code_part:
-                    code_lines.append(code_part)
-                continue
-            if in_code_block:
-                if line.startswith('```'):
-                    break
-                code_lines.append(line)
-        
-        final_code = '\n'.join(code_lines) if in_code_block else code
-        
-        try:
-            ast.parse(final_code)
-            return final_code
-        except SyntaxError as e:
-            raise ValueError(f'Invalid Python code: {e}') from e

quantalogic/codeact/templates/toolbox/README.md.j2

@@ -1,10 +0,0 @@
-# {{ name }}
-
-A custom toolbox for Quantalogic.
-
-## Installation
-
-```bash
-poetry install
-```
-

quantalogic/codeact/templates/toolbox/pyproject.toml.j2

@@ -1,16 +0,0 @@
-[tool.poetry]
-name = "{{ name }}"
-version = "0.1.0"
-description = "A custom toolbox for Quantalogic"
-authors = ["Your Name <you@example.com>"]
-
-[tool.poetry.dependencies]
-python = "^3.10"
-quantalogic = ">0.60.0"
-
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"
-
-[tool.poetry.plugins."quantalogic.tools"]
-"{{ name }}" = "{{ package_name }}.tools"

quantalogic/codeact/templates/toolbox/tools.py.j2

@@ -1,6 +0,0 @@
-from quantalogic.tools import create_tool
-
-@create_tool
-async def echo_tool(message: str) -> str:
-    """An example tool that echoes the input."""
-    return f"Echo: {message}"

quantalogic/codeact/templates.py

@@ -1,7 +0,0 @@
-from jinja2 import Environment, FileSystemLoader
-
-from .constants import TEMPLATE_DIR
-
-# Centralized Jinja2 environment for template rendering
-# Note: This is the default environment; custom environments can be passed to Agent
-jinja_env = Environment(loader=FileSystemLoader(TEMPLATE_DIR), trim_blocks=True, lstrip_blocks=True)

quantalogic/codeact/tools_manager.py

@@ -1,258 +0,0 @@
-"""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 Any, Dict, List, Optional
-
-import litellm
-from loguru import logger
-
-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):
-    """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:
-        """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 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:
-        """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,62 +0,0 @@
-import ast
-import inspect
-from functools import wraps
-from typing import Callable, List, Union
-
-from loguru import logger
-
-from quantalogic.tools import Tool, create_tool
-
-
-def log_async_tool(verb: str):
-    """Decorator factory for consistent async tool logging."""
-    def decorator(func: Callable) -> Callable:
-        @wraps(func)
-        async def wrapper(*args, **kwargs):
-            logger.info(f"Starting tool: {func.__name__}")
-            sig = inspect.signature(func)
-            bound_args = sig.bind(*args, **kwargs)
-            bound_args.apply_defaults()
-            logger.info(f"{verb} {', '.join(f'{k}={v}' for k, v in bound_args.arguments.items())}")
-            result = await func(*args, **kwargs)
-            logger.info(f"Finished tool: {func.__name__}")
-            return result
-        return wrapper
-    return decorator
-
-def log_tool_method(func: Callable) -> Callable:
-    """Decorator for logging Tool class methods."""
-    @wraps(func)
-    async def wrapper(self, **kwargs):
-        logger.info(f"Starting tool: {self.name}")
-        try:
-            result = await func(self, **kwargs)
-            logger.info(f"Finished tool: {self.name}")
-            return result
-        except Exception as e:
-            logger.error(f"Tool {self.name} failed: {e}")
-            raise
-    return wrapper
-
-def validate_code(code: str) -> bool:
-    """Check if code has an async main() function."""
-    try:
-        tree = ast.parse(code)
-        return any(isinstance(node, ast.AsyncFunctionDef) and node.name == "main" 
-                  for node in ast.walk(tree))
-    except SyntaxError:
-        return False
-
-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

@@ -1,126 +0,0 @@
-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")