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

quantalogic/codeact/llm_util.py

@@ -1,57 +0,0 @@
-from typing import Callable, List, Optional
-
-import litellm
-
-
-async def litellm_completion(
-    model: str,
-    messages: List[dict],
-    max_tokens: int,
-    temperature: float,
-    stream: bool = False,
-    step: Optional[int] = None,
-    notify_event: Optional[Callable] = None,
-    **kwargs
-) -> str:
-    """A wrapper for litellm.acompletion that supports streaming and non-streaming modes."""
-    from .events import StreamTokenEvent
-
-    if stream:
-        if notify_event is None:
-            raise ValueError("notify_event callback is required when streaming is enabled.")
-        
-        full_response = ""
-        try:
-            response = await litellm.acompletion(
-                model=model,
-                messages=messages,
-                max_tokens=max_tokens,
-                temperature=temperature,
-                stream=True,
-                **kwargs
-            )
-            async for chunk in response:
-                if chunk.choices[0].delta.content:
-                    token = chunk.choices[0].delta.content
-                    full_response += token
-                    await notify_event(StreamTokenEvent(
-                        event_type="StreamToken",
-                        token=token,
-                        step_number=step
-                    ))
-            return full_response
-        except Exception as e:
-            raise Exception(f"Streaming completion failed: {e}")
-    else:
-        try:
-            response = await litellm.acompletion(
-                model=model,
-                messages=messages,
-                max_tokens=max_tokens,
-                temperature=temperature,
-                stream=False,
-                **kwargs
-            )
-            return response.choices[0].message.content
-        except Exception as e:
-            raise Exception(f"Completion failed: {e}")

quantalogic/codeact/plugin_manager.py

@@ -1,92 +0,0 @@
-"""Plugin management module for dynamically loading components."""
-
-from importlib.metadata import entry_points
-from typing import List
-
-from loguru import logger
-
-from quantalogic.tools import Tool
-
-from .executor import Executor
-from .reasoner import Reasoner
-from .tools_manager import ToolRegistry
-
-
-class PluginManager:
-    """Manages dynamic loading of plugins for tools, reasoners, executors, and CLI commands."""
-    _instance = None
-
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super(PluginManager, cls).__new__(cls)
-            cls._instance.tools = ToolRegistry()
-            cls._instance.reasoners = {"default": Reasoner}
-            cls._instance.executors = {"default": Executor}
-            cls._instance.cli_commands = {}
-            cls._instance._plugins_loaded = False
-        return cls._instance
-
-    def load_plugins(self, force: bool = False) -> None:
-        """Load all plugins from registered entry points, handling duplicates gracefully.
-        
-        Args:
-            force: If True, reload plugins even if they were already loaded
-        """
-        if self._plugins_loaded and not force:
-            logger.debug("Plugins already loaded, skipping entire load process")
-            return
-        
-        # Clear existing plugins only if forcing reload
-        if force:
-            logger.info("Forcing plugin reload, clearing existing registrations")
-            self.tools = ToolRegistry()
-            self.reasoners = {"default": Reasoner}
-            self.executors = {"default": Executor}
-            self.cli_commands = {}
-            self._plugins_loaded = False
-
-        logger.debug("Loading plugins")
-        for group, store in [
-            ("quantalogic.tools", self.tools.load_toolboxes),
-            ("quantalogic.reasoners", self.reasoners),
-            ("quantalogic.executors", self.executors),
-            ("quantalogic.cli", self.cli_commands),
-        ]:
-            try:
-                eps = entry_points(group=group)
-                logger.debug(f"Found {len(eps)} entry points for group {group}")
-                for ep in eps:
-                    try:
-                        loaded = ep.load()
-                        if group == "quantalogic.tools":
-                            # Load static tools first
-                            store()
-                            # Then initialize dynamic MCP tools if applicable
-                            if ep.name == "quantalogic_toolbox_mcp":
-                                import asyncio
-
-                                from quantalogic_toolbox_mcp.tools import initialize_toolbox
-                                asyncio.run(initialize_toolbox(self.tools))
-                        else:
-                            store[ep.name] = loaded
-                            logger.info(f"Loaded plugin {ep.name} for {group}")
-                    except Exception as e:
-                        logger.warning(f"Skipping plugin {ep.name} for {group} due to error: {e}")
-            except Exception as e:
-                logger.error(f"Failed to retrieve entry points for {group}: {e}")
-        self._plugins_loaded = True
-        logger.info("Plugin loading completed")
-
-    def get_tools(self, force_reload: bool = False) -> List[Tool]:
-        """Return all registered tools.
-        
-        Args:
-            force_reload: If True, reload plugins before getting tools
-        """
-        if force_reload:
-            self.load_plugins(force=True)
-        else:
-            # Ensure plugins are loaded at least once, but don’t reload
-            if not self._plugins_loaded:
-                self.load_plugins()
-        return self.tools.get_tools()

quantalogic/codeact/prompts/error_format.j2

@@ -1,11 +0,0 @@
-<Action>
-  <Thought>Failed to generate a valid action due to: {{ error }}</Thought>
-  <Error>
-    <Message>{{ error }}</Message>
-  </Error>
-  <Code><![CDATA[
-import asyncio
-async def main():
-    print("Error: Action generation failed")
-  ]]></Code>
-</Action>

quantalogic/codeact/prompts/generate_action.j2

@@ -1,77 +0,0 @@
-Before generating the code, follow these steps:
-
-1. **Review the History**: Examine the <History> section below to understand previous thoughts, actions, and results.
-2. **Identify Available Variables**: Check the 'Currently available variables' list and 'Available variables' in the history. These are stored in the `context_vars` dictionary and can be accessed using `context_vars.get('variable_name', default_value)`.
-3. **Understand Variable Types**: Variables in `context_vars` are objects returned by tools, not just their string representations. Refer to tool documentation (e.g., `create_project_plan` returns `PlanResult` with `task_id`, `task_description`, `subtasks`) to access attributes directly (e.g., `plan.task_id`) rather than parsing strings.
-4. **Use Previous Results**: Incorporate relevant variables from prior steps to avoid redundant calculations and ensure continuity. For example, if `step1_plan` is a `PlanResult`, retrieve it with `plan = context_vars.get('step1_plan')` and use `plan.task_id`.
-5. **Plan Your Approach**: Based on the history and variables, determine the next logical step toward solving the task.
-
-Currently available variables from previous steps: {{ available_vars | join(', ') }}
-
-Solve the following task: 
-
-<Task>
-{{ task }}
-</Task>
-
-This is step {{ current_step }} out of {{ max_iterations }} allowed steps.
-
-Previous steps:
-
-<History>
-{{ history_str }}
-</History>
-
-Task:
-
-Generate a Python program with an async main() function that uses the available tools to take the next step toward solving the task.
-
-Essential Requirements:
-
-- **Always check the 'Available variables' from the history** before proceeding. These are listed in the <History> section and stored in the `context_vars` dictionary as objects. Access them using `context_vars.get("variable_name", default_value)` to retrieve results from previous steps.
-- **Handle Variable Types Correctly**: Variables in `context_vars` are the actual objects returned by tools (e.g., `PlanResult` from `create_project_plan`). Use attribute access (e.g., `plan.task_id`) instead of string methods like `split()` unless the variable is explicitly a string. Check tool documentation for return types.
-- **Build upon previous steps** by using these variables when they are relevant. This avoids redundant work and ensures continuity. For example, if a previous step stored a `PlanResult` as `step1_plan`, retrieve it with `plan = context_vars.get('step1_plan')` and use `plan.task_id`.
-- When defining new variables, **prefix them with 'step{{ current_step }}_'** to ensure uniqueness (e.g., `step{{ current_step }}_result`). This prevents overwriting variables from earlier steps.
-- Return `"Task completed: [final answer]"` if the task is fully solved in this step.
-- Otherwise, return intermediate results as a string to be stored for future steps.
-- Handle potential errors in tool arguments gracefully, using try/except blocks if needed.
-- Use proper async/await syntax for all asynchronous operations.
-
-Variable Naming Convention:
-- Prefix all new variables with 'step{{ current_step }}_' (e.g., `step{{ current_step }}_result = ...`).
-- This ensures variables are unique across steps and traceable to their origin.
-
-Example of using variables from previous steps:
-
-Task: "Retrieve the plan from the previous step"
-History: 
-"===== Step 1 of 5 max =====
-Thought: Create a project plan
-Action: <code>import asyncio\nasync def main():\n    step1_plan = await quantalogic_planning_toolbox.create_project_plan(task_description='Write an article')\n    return f'{step1_plan}'</code>
-Result: task_id='abc123' task_description='Write an article' subtasks=[...]
-Available variables: step1_plan"
-
-Code:
-import asyncio
-
-async def main():
-    # Retrieve previous plan as an object, not a string
-    step1_plan = context_vars.get('step1_plan')
-    if step1_plan:
-        step2_task_id: str = step1_plan.task_id  # Access attribute directly
-        step2_retrieved_plan = await quantalogic_planning_toolbox.retrieve_project_plan(task_id=step2_task_id)
-        return f"Retrieved plan: {step2_retrieved_plan}"
-    return "Error: No plan found from previous step"
-
-Error Reflection:
-- If there were errors in previous steps, review the error messages in the <History> section and adjust your code to avoid similar issues.
-- For example, if a variable was missing, check `context_vars` with a default value.
-- If a tool call failed, verify the arguments and ensure they match the tool's requirements.
-- If an error like "'PlanResult' object has no attribute 'split'" occurred, it means you tried to treat an object as a string. Use attribute access instead (e.g., `.task_id`).
-
-The program must:
-
-1. Use only the provided async tools
-2. Follow a subset of Python 3.10+ syntax, doesn't allow unsafe operations such as eval() or exec()
-3. Include type annotations for variables, give very explicit names to variables
-4. Output progress information

quantalogic/codeact/prompts/generate_program.j2

@@ -1,52 +0,0 @@
-You are a Python code generator. Your task is to create a Python program that solves the following task:
-
-"{{ task_description }}"
-
-You have access to the following pre-defined async tool functions, grouped by toolbox:
-
-{% for toolbox_name, docstrings in tools_by_toolbox.items() %}
-### {{ toolbox_name }}
-{% for docstring in docstrings %}
-{{ docstring }}
-
-{% endfor %}
-{% endfor %}
-
-If applicable, use tools to assess the situation and generate a Python program that solves the task step by step.
-
-If applicable, use tools to verify the task is completed.
-
-Instructions:
-1. Generate a very simple Python program, avoid complex logic, return the program as a single string. No more than 3 functions called.
-2. Include only the import for asyncio (import asyncio).
-3. Define an async function named main() that solves the task.
-4. Use the pre-defined tool functions by calling them with await and prefixing them with their toolbox name (e.g., `await {{ toolbox_name }}.tool_name(arg1, arg2)`). For core tools, use `default.tool_name` (e.g., `await default.agent_tool(...)`).
-5. Do not redefine the tool functions within the program; assume they are already available in the namespace under their toolbox names (e.g., `default.agent_tool` for core tools).
-6. Return the program as a plain string (no markdown or extra text).
-7. Strictly exclude asyncio.run(main()) or any code outside the main() function definition, including any 'if __name__ == "__main__":' block, as the runtime will handle execution of main().
-8. Express all string variables as multiline strings, always start a string at the beginning of a line.
-9. Always return a string from main(); use "Task completed: [result]" if the task is solved, otherwise return intermediate results.
-10. Access variables from previous steps using the `context_vars` dictionary:
-    - Use `context_vars.get("variable_name", default_value)` to safely retrieve variables (e.g., `previous_sum = context_vars.get("step1_sum", 0)`).
-    - Always specify a default value to handle cases where the variable might not exist.
-    - Check the history for 'Available variables' to identify relevant previous results.
-    - Use these variables to build on prior work rather than starting from scratch.
-11. Be careful to avoid programs that cannot terminate.
-12. When defining new variables, prefix them with 'step<current_step>_' (e.g., `step1_result`) to ensure uniqueness across steps.
-13. Never use dangerous functions like eval, or any other unsafe operations.
-14. If a return result is tool complex use an intermediate result to store it.
-15. VERY IMPORTANT: If the return type of a function is Any or not specified don't call another function after this just return the result, the result will be handled by the runtime.
-
-Example task: "Translate the poem 'The sun rises' into Spanish using the agent_tool"
-Example output:
-import asyncio
-
-async def main():
-    step1_poem: str = "The sun rises"
-    step1_system_prompt: str = "You are a translation expert."
-    step1_translation: str = await default.agent_tool(
-        system_prompt=step1_system_prompt,
-        prompt=f"Translate '{step1_poem}' into Spanish",
-        temperature=0.7
-    )
-    return f"Task completed: {step1_translation}"

quantalogic/codeact/prompts/response_format.j2

@@ -1,11 +0,0 @@
-<Action>
-  <Thought>Generated a Python program to take the next step toward solving: {{ task }} Based on history: {{ history_str }}</Thought>
-  <Code><![CDATA[
-{{ program }}
-  ]]></Code>
-  <Metadata>
-    <StepNumber>{{ current_step }}</StepNumber>
-    <MaxIterations>{{ max_iterations }}</MaxIterations>
-    <Task>{{ task }}</Task>
-  </Metadata>
-</Action>

quantalogic/codeact/react_agent.py

@@ -1,318 +0,0 @@
-"""Core implementation of the ReAct framework for reasoning and acting."""
-
-import asyncio
-import time
-from typing import Callable, Dict, List, Optional, Tuple
-
-from loguru import logger
-from lxml import etree
-
-from quantalogic.tools import Tool
-
-from .events import (
-    ActionExecutedEvent,
-    ActionGeneratedEvent,
-    ErrorOccurredEvent,
-    StepCompletedEvent,
-    StepStartedEvent,
-    TaskCompletedEvent,
-    TaskStartedEvent,
-    ThoughtGeneratedEvent,
-)
-from .executor import BaseExecutor, Executor
-from .history_manager import HistoryManager
-from .llm_util import litellm_completion
-from .reasoner import BaseReasoner, Reasoner
-from .tools_manager import ToolRegistry
-from .xml_utils import XMLResultHandler
-
-
-class ReActAgent:
-    """Implements the ReAct framework for reasoning and acting with enhanced memory management."""
-    
-    def __init__(
-        self,
-        model: str,
-        tools: List[Tool],
-        max_iterations: int = 5,
-        max_history_tokens: int = 2000,
-        system_prompt: str = "",  # New parameter for persistent context
-        task_description: str = "",  # New parameter for persistent context
-        reasoner: Optional[BaseReasoner] = None,
-        executor: Optional[BaseExecutor] = None,
-        tool_registry: Optional[ToolRegistry] = None,
-        history_manager: Optional[HistoryManager] = None,
-        error_handler: Optional[Callable[[Exception, int], bool]] = None
-    ) -> None:
-        """
-        Initialize the ReActAgent with tools, reasoning, execution, and memory components.
-
-        Args:
-            model (str): Language model identifier.
-            tools (List[Tool]): List of available tools.
-            max_iterations (int): Maximum reasoning steps (default: 5).
-            max_history_tokens (int): Max tokens for history (default: 2000).
-            system_prompt (str): Persistent system instructions (default: "").
-            task_description (str): Persistent task context (default: "").
-            reasoner (Optional[BaseReasoner]): Custom reasoner instance.
-            executor (Optional[BaseExecutor]): Custom executor instance.
-            tool_registry (Optional[ToolRegistry]): Custom tool registry.
-            history_manager (Optional[HistoryManager]): Custom history manager.
-            error_handler (Optional[Callable[[Exception, int], bool]]): Error handler callback.
-        """
-        self.tool_registry = tool_registry or ToolRegistry()
-        for tool in tools:
-            self.tool_registry.register(tool)
-        self.reasoner: BaseReasoner = reasoner or Reasoner(model, self.tool_registry.get_tools())
-        self.executor: BaseExecutor = executor or Executor(self.tool_registry.get_tools(), notify_event=self._notify_observers)
-        self.max_iterations: int = max_iterations
-        self.max_history_tokens: int = max_history_tokens
-        self.history_manager: HistoryManager = history_manager or HistoryManager(
-            max_tokens=max_history_tokens,
-            system_prompt=system_prompt,
-            task_description=task_description
-        )
-        self.context_vars: Dict = {}
-        self._observers: List[Tuple[Callable, List[str]]] = []
-        self.error_handler = error_handler or (lambda e, step: False)  # Default: no retry
-
-    def add_observer(self, observer: Callable, event_types: List[str]) -> 'ReActAgent':
-        """Add an observer for specific event types."""
-        self._observers.append((observer, event_types))
-        return self
-
-    async def _notify_observers(self, event: object) -> None:
-        """Notify all subscribed observers of an event."""
-        await asyncio.gather(
-            *(observer(event) for observer, types in self._observers if event.event_type in types),
-            return_exceptions=True
-        )
-
-    async def generate_action(
-        self,
-        task: str,
-        history: List[Dict],
-        step: int,
-        max_iterations: int,
-        system_prompt: Optional[str] = None,
-        streaming: bool = False
-    ) -> str:
-        """
-        Generate an action using the Reasoner, passing available variables.
-
-        Args:
-            task (str): The task to address.
-            history (List[Dict]): Stored step history.
-            step (int): Current step number.
-            max_iterations (int): Maximum allowed steps.
-            system_prompt (Optional[str]): Override system prompt (optional).
-            streaming (bool): Whether to stream the response.
-
-        Returns:
-            str: Generated action in XML format.
-        """
-        history_str: str = self.history_manager.format_history(max_iterations)
-        available_vars: List[str] = list(self.context_vars.keys())
-        start: float = time.perf_counter()
-        response: str = await self.reasoner.generate_action(
-            task, 
-            history_str, 
-            step, 
-            max_iterations, 
-            system_prompt or self.history_manager.system_prompt,
-            self._notify_observers, 
-            streaming=streaming, 
-            available_vars=available_vars
-        )
-        thought, code = XMLResultHandler.parse_action_response(response)
-        gen_time: float = time.perf_counter() - start
-        await self._notify_observers(ThoughtGeneratedEvent(
-            event_type="ThoughtGenerated", step_number=step, thought=thought, generation_time=gen_time
-        ))
-        await self._notify_observers(ActionGeneratedEvent(
-            event_type="ActionGenerated", step_number=step, action_code=code, generation_time=gen_time
-        ))
-        if not response.endswith("</Code>"):
-            logger.warning(f"Response might be truncated at step {step}")
-        return response
-
-    async def execute_action(self, code: str, step: int, timeout: int = 300) -> str:
-        """
-        Execute an action using the Executor.
-
-        Args:
-            code (str): Code to execute.
-            step (int): Current step number.
-            timeout (int): Execution timeout in seconds (default: 300).
-
-        Returns:
-            str: Execution result in XML format.
-        """
-        start: float = time.perf_counter()
-        result_xml: str = await self.executor.execute_action(code, self.context_vars, step, timeout)
-        execution_time: float = time.perf_counter() - start
-        await self._notify_observers(ActionExecutedEvent(
-            event_type="ActionExecuted", step_number=step, result_xml=result_xml, execution_time=execution_time
-        ))
-        return result_xml
-
-    async def is_task_complete(self, task: str, history: List[Dict], result: str, success_criteria: Optional[str]) -> Tuple[bool, str]:
-        """
-        Check if the task is complete based on the result.
-
-        Args:
-            task (str): The task being solved.
-            history (List[Dict]): Step history.
-            result (str): Result of the latest action.
-            success_criteria (Optional[str]): Optional success criteria.
-
-        Returns:
-            Tuple[bool, str]: (is_complete, final_answer).
-        """
-        try:
-            root = etree.fromstring(result)
-            if root.findtext("Completed") == "true":
-                final_answer: str = root.findtext("FinalAnswer") or ""
-                verification: str = await litellm_completion(
-                    model=self.reasoner.model,
-                    messages=[{
-                        "role": "user",
-                        "content": f"Does '{final_answer}' solve '{task}' given history:\n{self.history_manager.format_history(self.max_iterations)}?"
-                    }],
-                    max_tokens=100,
-                    temperature=0.1,
-                    stream=False
-                )
-                if verification and "yes" in verification.lower():
-                    return True, final_answer
-                return True, final_answer
-        except etree.XMLSyntaxError:
-            pass
-
-        if success_criteria and (result_value := XMLResultHandler.extract_result_value(result)) and success_criteria in result_value:
-            return True, result_value
-        return False, ""
-
-    async def _run_step(self, task: str, step: int, max_iters: int, 
-                       system_prompt: Optional[str], streaming: bool) -> Dict:
-        """
-        Execute a single step of the ReAct loop with retry logic.
-
-        Args:
-            task (str): The task to address.
-            step (int): Current step number.
-            max_iters (int): Maximum allowed steps.
-            system_prompt (Optional[str]): System prompt override.
-            streaming (bool): Whether to stream responses.
-
-        Returns:
-            Dict: Step data (step_number, thought, action, result).
-        """
-        await self._notify_observers(StepStartedEvent(
-            event_type="StepStarted",
-            step_number=step,
-            system_prompt=self.history_manager.system_prompt,
-            task_description=self.history_manager.task_description
-        ))
-        for attempt in range(3):
-            try:
-                response: str = await self.generate_action(task, self.history_manager.store, step, max_iters, system_prompt, streaming)
-                thought, code = XMLResultHandler.parse_action_response(response)
-                result: str = await self.execute_action(code, step)
-                step_data = {"step_number": step, "thought": thought, "action": code, "result": result}
-                self.history_manager.add_step(step_data)
-                return step_data
-            except Exception as e:
-                if not self.error_handler(e, step) or attempt == 2:
-                    await self._notify_observers(ErrorOccurredEvent(
-                        event_type="ErrorOccurred", error_message=str(e), step_number=step
-                    ))
-                    raise
-                await asyncio.sleep(2 ** attempt)  # Exponential backoff
-
-    async def _finalize_step(self, task: str, step_data: Dict, 
-                            success_criteria: Optional[str]) -> Tuple[bool, Dict]:
-        """
-        Check completion and notify observers for a step.
-
-        Args:
-            task (str): The task being solved.
-            step_data (Dict): Current step data.
-            success_criteria (Optional[str]): Optional success criteria.
-
-        Returns:
-            Tuple[bool, Dict]: (is_complete, updated_step_data).
-        """
-        is_complete, final_answer = await self.is_task_complete(task, self.history_manager.store, step_data["result"], success_criteria)
-        if is_complete:
-            try:
-                root = etree.fromstring(step_data["result"])
-                if root.find("FinalAnswer") is None:
-                    final_answer_elem = etree.Element("FinalAnswer")
-                    final_answer_elem.text = etree.CDATA(final_answer)
-                    root.append(final_answer_elem)
-                step_data["result"] = etree.tostring(root, pretty_print=True, encoding="unicode")
-            except etree.XMLSyntaxError as e:
-                logger.error(f"Failed to parse result XML for appending FinalAnswer: {e}")
-                if "<FinalAnswer>" not in step_data["result"]:
-                    step_data["result"] += f"\n<FinalAnswer><![CDATA[\n{final_answer}\n]]></FinalAnswer>"
-        await self._notify_observers(StepCompletedEvent(
-            event_type="StepCompleted", step_number=step_data["step_number"], 
-            thought=step_data["thought"], action=step_data["action"], result=step_data["result"],
-            is_complete=is_complete, final_answer=final_answer if is_complete else None
-        ))
-        return is_complete, step_data
-
-    async def solve(
-        self,
-        task: str,
-        success_criteria: Optional[str] = None,
-        system_prompt: Optional[str] = None,
-        max_iterations: Optional[int] = None,
-        streaming: bool = False
-    ) -> List[Dict]:
-        """
-        Solve a task using the ReAct framework with persistent memory.
-
-        Args:
-            task (str): The task to solve.
-            success_criteria (Optional[str]): Criteria for success.
-            system_prompt (Optional[str]): System prompt override.
-            max_iterations (Optional[int]): Override for max steps.
-            streaming (bool): Whether to stream responses.
-
-        Returns:
-            List[Dict]: History of steps taken.
-        """
-        max_iters: int = max_iterations if max_iterations is not None else self.max_iterations
-        self.history_manager.store.clear()  # Reset history for new task
-        if system_prompt is not None:
-            self.history_manager.system_prompt = system_prompt
-        self.history_manager.task_description = task
-        await self._notify_observers(TaskStartedEvent(
-            event_type="TaskStarted",
-            task_description=task,
-            system_prompt=self.history_manager.system_prompt
-        ))
-
-        for step in range(1, max_iters + 1):
-            try:
-                step_data: Dict = await self._run_step(task, step, max_iters, system_prompt, streaming)
-                is_complete, step_data = await self._finalize_step(task, step_data, success_criteria)
-                if is_complete:
-                    await self._notify_observers(TaskCompletedEvent(
-                        event_type="TaskCompleted", final_answer=step_data["result"], reason="success"
-                    ))
-                    break
-            except Exception as e:
-                await self._notify_observers(ErrorOccurredEvent(
-                    event_type="ErrorOccurred", error_message=str(e), step_number=step
-                ))
-                break
-
-        if not any("<FinalAnswer>" in step["result"] for step in self.history_manager.store):
-            await self._notify_observers(TaskCompletedEvent(
-                event_type="TaskCompleted", final_answer=None,
-                reason="max_iterations_reached" if len(self.history_manager.store) == max_iters else "error"
-            ))
-        return self.history_manager.store