droidrun 0.3.10.dev3__py3-none-any.whl → 0.3.10.dev4__py3-none-any.whl

droidrun/agent/context/personas/default.py

@@ -1,95 +0,0 @@
-from droidrun.agent.context.agent_persona import AgentPersona
-from droidrun.tools import Tools
-
-DEFAULT = AgentPersona(
-    name="Default",
-    description="Default Agent. Use this as your Default",
-    expertise_areas=[
-        "UI navigation", "button interactions", "text input",
-        "menu navigation", "form filling", "scrolling", "app launching"
-    ],
-    allowed_tools=[
-        Tools.swipe.__name__,
-        Tools.input_text.__name__,
-        Tools.press_key.__name__,
-        Tools.tap_by_index.__name__,
-        Tools.start_app.__name__,
-        Tools.list_packages.__name__,
-        Tools.remember.__name__,
-        Tools.complete.__name__
-    ],
-    required_context=[
-        "ui_state",
-        "screenshot",
-    ],
-    user_prompt="""
-    **Current Request:**
-    {goal}
-    **Is the precondition met? What is your reasoning and the next step to address this request?**
-    Explain your thought process then provide code in ```python ... ``` tags if needed.
-    """"",
-
-    system_prompt="""
-    You are a helpful AI assistant that can write and execute Python code to solve problems.
-
-    You will be given a task to perform. You should output:
-    - Python code wrapped in ``` tags that provides the solution to the task, or a step towards the solution.
-    - If there is a precondition for the task, you MUST check if it is met.
-    - If a goal's precondition is unmet, fail the task by calling `complete(success=False, reason='...')` with an explanation.
-    - If you task is complete, you should use the complete(success:bool, reason:str) function within a code block to mark it as finished. The success parameter should be True if the task was completed successfully, and False otherwise. The reason parameter should be a string explaining the reason for failure if failed.
-
-
-    ## Context:
-    The following context is given to you for analysis:
-    - **ui_state**: A list of all currently visible UI elements with their indices. Use this to understand what interactive elements are available on the screen.
-    - **screenshots**: A visual screenshot of the current state of the Android screen. This provides visual context for what the user sees. screenshots won't be saved in the chat history. So, make sure to describe what you see and explain the key parts of your plan in your thoughts, as those will be saved and used to assist you in future steps.
-    - **phone_state**: The current app you are navigating in. This tells you which application context you're working within.
-    - **chat history**: You are also given the history of your actions (if any) from your previous steps.
-    - **execution result**: The result of your last Action
-    NOTE: you don't have access to these inputs in your tool calling context
-
-    ## Response Format:
-    Example of proper code format:
-    **Task Assignment:**
-    **Task:** "Precondition: Settings app is open. Goal: Navigate to Wi-Fi settings and connect to the network 'HomeNetwork'."
-
-    **(Step 1) Agent Analysis:** I can see the Settings app is open from the screenshot. This is a multi-step task that requires me to first navigate to Wi-Fi settings, then ensure Wi-Fi is enabled, and finally connect to 'HomeNetwork'. Let me start by finding and tapping on the Wi-Fi option in the settings menu. Looking at the UI elements, I can see "Wi-Fi" option at index 3.
-
-    **(Step 1) Agent Action:**
-    ```python
-    # First step: Navigate to Wi-Fi settings
-    tap_by_index(3)
-    ```
-
-    **(Step 2) Agent Analysis:** Good! I've successfully navigated to the Wi-Fi settings screen. Now I can see the Wi-Fi settings interface. I notice that Wi-Fi appears to be turned off based on the toggle switch at index 1. I need to turn it on before I can see available networks and connect to 'HomeNetwork'.
-
-    **(Step 2) Agent Action:**
-    ```python
-    # Second step: Turn on Wi-Fi to see available networks
-    tap_by_index(1)
-    ```
-
-    **(Step 3) Agent Analysis:** Excellent! Wi-Fi is now enabled and I can see a list of available networks appearing on the screen. I can see 'HomeNetwork' in the list at index 5. This is the final step - I need to tap on it to initiate the connection, which will complete my assigned task.
-
-    **(Step 3) Agent Action:**
-    ```python
-    # Final step: Connect to the target network
-    tap_by_index(5)
-    complete(success=True, reason="Successfully navigated to Wi-Fi settings and initiated connection to HomeNetwork")
-    ```
-    ```
-
-    ## Tools:
-    In addition to the Python Standard Library and any functions you have already written, you can use the following functions:
-    {tool_descriptions}
-
-
-    ## Final Answer Guidelines:
-    - When providing a final answer, focus on directly answering the user's question in the response format given
-    - Present the results clearly and concisely as if you computed them directly
-    - Structure your response like you're directly answering the user's query, not explaining how you solved it
-
-    Reminder: Always place your Python code between ```...``` tags when you want to run code.
-"""
-
-)

droidrun/agent/context/personas/ui_expert.py

@@ -1,108 +0,0 @@
-from droidrun.agent.context.agent_persona import AgentPersona
-from droidrun.tools import Tools
-
-UI_EXPERT = AgentPersona(
-    name="UIExpert",
-    description="Specialized in UI interactions, navigation, and form filling",
-    expertise_areas=[
-        "UI navigation", "button interactions", "text input",
-        "menu navigation", "form filling", "scrolling"
-    ],
-    allowed_tools=[
-        Tools.swipe.__name__,
-        Tools.input_text.__name__,
-        Tools.press_key.__name__,
-        Tools.tap_by_index.__name__,
-        Tools.drag.__name__,
-        Tools.remember.__name__,
-        Tools.complete.__name__
-    ],
-    required_context=[
-        "ui_state",
-        "screenshot",
-        "phone_state",
-        "memory"
-    ],
-    user_prompt="""
-    **Current Request:**
-    {goal}
-    **Is the precondition met? What is your reasoning and the next step to address this request?** Explain your thought process then provide code in ```python ... ``` tags if needed.""""",
-
-
-    system_prompt="""You are a UI Expert specialized in Android interface interactions. Your core expertise includes:
-
-    **Primary Capabilities:**
-    - Navigate through Android UI elements with precision
-    - Interact with buttons, menus, forms, and interactive elements
-    - Enter text into input fields and search bars
-    - Scroll through content and lists
-    - Handle complex UI navigation workflows
-    - Recognize and interact with various UI patterns (tabs, drawers, dialogs, etc.)
-
-    **Your Approach:**
-    - Focus on understanding the current UI state through screenshots and element data
-    - Use precise element identification for reliable interactions
-    - Handle dynamic UI changes and loading states gracefully
-    - Provide clear feedback on UI interactions and their outcomes
-    - Adapt to different app interfaces and UI patterns
-
-    **Key Principles:**
-    - Always analyze the current screen state before taking action
-    - Prefer using element indices for reliable targeting
-    - Provide descriptive feedback about what you're interacting with
-    - Handle edge cases like loading screens, popups, and navigation changes
-    - Remember important UI state information for context
-
-    You do NOT handle app launching or package management - that's handled by other specialists.
-
-
-    ## Available Context:
-    In your execution environment, you have access to:
-    - `ui_elements`: A global variable containing the current UI elements from the device. This is automatically updated before each code execution and contains the latest UI elements that were fetched.
-
-    ## Response Format:
-    Example of proper code format:
-    To calculate the area of a circle, I need to use the formula: area = pi * radius^2. I will write a function to do this.
-    ```python
-    import math
-
-    def calculate_area(radius):
-        return math.pi * radius**2
-
-    # Calculate the area for radius = 5
-    area = calculate_area(5)
-    print(f"The area of the circle is {{area:.2f}} square units")
-    ```
-
-    Another example (with for loop):
-    To calculate the sum of numbers from 1 to 10, I will use a for loop.
-    ```python
-    sum = 0
-    for i in range(1, 11):
-        sum += i
-    print(f"The sum of numbers from 1 to 10 is {{sum}}")
-    ```
-
-    In addition to the Python Standard Library and any functions you have already written, you can use the following functions:
-    {tool_descriptions}
-
-    You'll receive a screenshot showing the current screen and its UI elements to help you complete the task. However, screenshots won't be saved in the chat history. So, make sure to describe what you see and explain the key parts of your plan in your thoughts, as those will be saved and used to assist you in future steps.
-
-    **Important Notes:**
-    - If there is a precondition for the task, you MUST check if it is met.
-    - If a goal's precondition is unmet, fail the task by calling `complete(success=False, reason='...')` with an explanation.
-
-    ## Final Answer Guidelines:
-    - When providing a final answer, focus on directly answering the user's question
-    - Avoid referencing the code you generated unless specifically asked
-    - Present the results clearly and concisely as if you computed them directly
-    - If relevant, you can briefly mention general methods used, but don't include code snippets in the final answer
-    - Structure your response like you're directly answering the user's query, not explaining how you solved it
-
-    Reminder: Always place your Python code between ```...``` tags when you want to run code.
-
-    You MUST ALWAYS to include your reasoning and thought process outside of the code block. You MUST DOUBLE CHECK that TASK IS COMPLETE with a SCREENSHOT.
-    """
-)
-
-

droidrun/agent/planner/__init__.py

@@ -1,13 +0,0 @@
-from droidrun.agent.planner.planner_agent import PlannerAgent
-from droidrun.agent.planner.prompts import (
-    DEFAULT_PLANNER_SYSTEM_PROMPT,
-    DEFAULT_PLANNER_TASK_FAILED_PROMPT,
-    DEFAULT_PLANNER_USER_PROMPT,
-)
-
-__all__ = [
-    "PlannerAgent",
-    "DEFAULT_PLANNER_SYSTEM_PROMPT",
-    "DEFAULT_PLANNER_USER_PROMPT",
-    "DEFAULT_PLANNER_TASK_FAILED_PROMPT"
-]

droidrun/agent/planner/events.py

@@ -1,21 +0,0 @@
-from typing import Optional
-
-from llama_index.core.base.llms.types import ChatMessage
-from llama_index.core.workflow import Event
-
-from droidrun.agent.context import Task
-from droidrun.agent.usage import UsageResult
-
-
-class PlanInputEvent(Event):
-    input: list[ChatMessage]
-
-
-class PlanThinkingEvent(Event):
-    thoughts: Optional[str] = None
-    code: Optional[str] = None
-    usage: Optional[UsageResult] = None
-
-
-class PlanCreatedEvent(Event):
-    tasks: list[Task]

droidrun/agent/planner/planner_agent.py

@@ -1,311 +0,0 @@
-import asyncio
-import logging
-from typing import TYPE_CHECKING, List, Union
-
-from dotenv import load_dotenv
-from llama_index.core.base.llms.types import ChatMessage, ChatResponse
-from llama_index.core.llms.llm import LLM
-from llama_index.core.memory import Memory
-from llama_index.core.prompts import PromptTemplate
-from llama_index.core.workflow import Context, StartEvent, StopEvent, Workflow, step
-
-from droidrun.agent.common.constants import LLM_HISTORY_LIMIT
-from droidrun.agent.common.events import RecordUIStateEvent, ScreenshotEvent
-from droidrun.agent.context.agent_persona import AgentPersona
-from droidrun.agent.context.task_manager import TaskManager
-from droidrun.agent.planner.events import (
-    PlanCreatedEvent,
-    PlanInputEvent,
-    PlanThinkingEvent,
-)
-from droidrun.agent.planner.prompts import (
-    DEFAULT_PLANNER_SYSTEM_PROMPT,
-    DEFAULT_PLANNER_USER_PROMPT,
-)
-from droidrun.agent.usage import get_usage_from_response
-from droidrun.agent.utils import chat_utils
-from droidrun.agent.utils.executer import SimpleCodeExecutor
-from droidrun.tools import Tools
-
-load_dotenv()
-
-# Setup logger
-logger = logging.getLogger("droidrun")
-
-if TYPE_CHECKING:
-    from droidrun.tools import Tools
-
-
-class PlannerAgent(Workflow):
-    def __init__(
-        self,
-        goal: str,
-        llm: LLM,
-        vision: bool,
-        personas: List[AgentPersona],
-        task_manager: TaskManager,
-        tools_instance: Tools,
-        system_prompt=None,
-        user_prompt=None,
-        debug=False,
-        *args,
-        **kwargs,
-    ) -> None:
-        super().__init__(*args, **kwargs)
-
-        self.llm = llm
-        self.goal = goal
-        self.task_manager = task_manager
-        self.debug = debug
-        self.vision = vision
-
-        self.chat_memory = None
-        self.remembered_info = None
-
-        self.current_retry = 0
-        self.steps_counter = 0
-
-        self.tool_list = {}
-        self.tool_list[self.task_manager.set_tasks_with_agents.__name__] = (
-            self.task_manager.set_tasks_with_agents
-        )
-        self.tool_list[self.task_manager.complete_goal.__name__] = (
-            self.task_manager.complete_goal
-        )
-
-        self.tools_description = chat_utils.parse_tool_descriptions(self.tool_list)
-        self.tools_instance = tools_instance
-
-        self.personas = personas
-
-        self.system_prompt = system_prompt or DEFAULT_PLANNER_SYSTEM_PROMPT.format(
-            tools_description=self.tools_description,
-            agents=chat_utils.parse_persona_description(self.personas),
-        )
-        self.user_prompt = user_prompt or DEFAULT_PLANNER_USER_PROMPT.format(goal=goal)
-        self.system_message = ChatMessage(role="system", content=self.system_prompt)
-        self.user_message = ChatMessage(role="user", content=self.user_prompt)
-
-        self.executer = SimpleCodeExecutor(
-            loop=asyncio.get_event_loop(), globals={}, locals={}, tools=self.tool_list
-        )
-
-    @step
-    async def prepare_chat(self, ctx: Context, ev: StartEvent) -> PlanInputEvent:
-        logger.info("💬 Preparing planning session...")
-
-        self.chat_memory: Memory = await ctx.store.get(
-            "chat_memory", default=Memory.from_defaults()
-        )
-        await self.chat_memory.aput(self.user_message)
-
-        if ev.remembered_info:
-            self.remembered_info = ev.remembered_info
-
-        assert len(self.chat_memory.get_all()) > 0 or self.user_prompt, "Memory input, user prompt or user input cannot be empty."
-
-        await self.chat_memory.aput(ChatMessage(role="user", content=PromptTemplate(self.user_prompt or DEFAULT_PLANNER_USER_PROMPT.format(goal=self.goal))))
-
-        input_messages = self.chat_memory.get_all()
-        logger.debug(f"  - Memory contains {len(input_messages)} messages")
-        return PlanInputEvent(input=input_messages)
-
-    @step
-    async def handle_llm_input(
-        self, ev: PlanInputEvent, ctx: Context
-    ) -> PlanThinkingEvent:
-        """Handle LLM input."""
-        chat_history = ev.input
-        assert len(chat_history) > 0, "Chat history cannot be empty."
-
-        ctx.write_event_to_stream(ev)
-
-        self.steps_counter += 1
-        logger.info("🧠 Thinking about how to plan the goal...")
-
-        if self.vision:
-            screenshot = (self.tools_instance.take_screenshot())[1]
-            ctx.write_event_to_stream(ScreenshotEvent(screenshot=screenshot))
-            await ctx.store.set("screenshot", screenshot)
-
-        try:
-            state = self.tools_instance.get_state()
-            await ctx.store.set("ui_state", state["a11y_tree"])
-            await ctx.store.set("phone_state", state["phone_state"])
-            ctx.write_event_to_stream(RecordUIStateEvent(ui_state=state["a11y_tree"]))
-        except Exception:
-            logger.warning("⚠️ Error retrieving state from the connected device. Is the Accessibility Service enabled?")
-
-
-        await ctx.store.set("remembered_info", self.remembered_info)
-
-        response = await self._get_llm_response(ctx, chat_history)
-        try:
-            usage = get_usage_from_response(self.llm.class_name(), response)
-        except Exception as e:
-            logger.warning(f"Could not get llm usage from response: {e}")
-            usage = None
-        await self.chat_memory.aput(response.message)
-
-        code, thoughts = chat_utils.extract_code_and_thought(response.message.content)
-
-        event = PlanThinkingEvent(thoughts=thoughts, code=code, usage=usage)
-        ctx.write_event_to_stream(event)
-        return event
-
-    @step
-    async def handle_llm_output(
-        self, ev: PlanThinkingEvent, ctx: Context
-    ) -> Union[PlanInputEvent, PlanCreatedEvent]:
-        """Handle LLM output."""
-        logger.debug("🤖 Processing planning output...")
-        code = ev.code
-
-        if code:
-            try:
-                result = await self.executer.execute(ctx, code)
-                logger.info("📝 Planning complete")
-                logger.debug(f"  - Planning code executed. Result: {result['output']}")
-
-                screenshots = result['screenshots']
-                for screenshot in screenshots[:-1]: # the last screenshot will be captured by next step
-                    ctx.write_event_to_stream(ScreenshotEvent(screenshot=screenshot))
-
-                ui_states = result['ui_states']
-                for ui_state in ui_states[:-1]:
-                    ctx.write_event_to_stream(RecordUIStateEvent(ui_state=ui_state['a11y_tree']))
-
-                await self.chat_memory.aput(
-                    ChatMessage(
-                        role="user", content=f"Execution Result:\n```\n{result['output']}\n```"
-                    )
-                )
-
-                self.remembered_info = self.tools_instance.memory
-
-                tasks = self.task_manager.get_all_tasks()
-                event = PlanCreatedEvent(tasks=tasks)
-
-                if not self.task_manager.goal_completed:
-                    logger.info(f"📋 Current plan created with {len(tasks)} tasks:")
-                    for i, task in enumerate(tasks):
-                        logger.info(
-                            f"  Task {i}: [{task.status.upper()}] [{task.agent_type}] {task.description}"
-                        )
-                    ctx.write_event_to_stream(event)
-
-                return event
-
-            except Exception as e:
-                logger.debug(f"error handling Planner: {e}")
-                await self.chat_memory.aput(
-                    ChatMessage(
-                        role="user",
-                        content="""Please either set new tasks using set_tasks_with_agents() or mark the goal as complete using complete_goal() if done.
-wrap your code inside this:
-```python
-<YOUR CODE HERE>
-```""",
-                    )
-                )
-                logger.debug("🔄 Waiting for next plan or completion.")
-                return PlanInputEvent(input=self.chat_memory.get_all())
-        else:
-            await self.chat_memory.aput(
-                ChatMessage(
-                    role="user",
-                    content="""Please either set new tasks using set_tasks_with_agents() or mark the goal as complete using complete_goal() if done.
-wrap your code inside this:
-```python
-<YOUR CODE HERE>
-```""",
-                )
-            )
-            logger.debug("🔄 Waiting for next plan or completion.")
-            return PlanInputEvent(input=self.chat_memory.get_all())
-
-    @step
-    async def finalize(self, ev: PlanCreatedEvent, ctx: Context) -> StopEvent:
-        """Finalize the workflow."""
-        await ctx.store.set("chat_memory", self.chat_memory)
-
-        result = {}
-        result.update(
-            {
-                "tasks": ev.tasks,
-            }
-        )
-
-        return StopEvent(result=result)
-
-    async def _get_llm_response(
-        self, ctx: Context, chat_history: List[ChatMessage]
-    ) -> ChatResponse:
-        """Get streaming response from LLM."""
-        try:
-            logger.debug(f"  - Sending {len(chat_history)} messages to LLM.")
-
-            model = self.llm.class_name()
-            if self.vision:
-                if model == "DeepSeek":
-                    logger.warning(
-                        "[yellow]DeepSeek doesnt support images. Disabling screenshots[/]"
-                    )
-                else:
-                    chat_history = await chat_utils.add_screenshot_image_block(
-                        await ctx.store.get("screenshot"), chat_history
-                    )
-
-
-
-            chat_history = await chat_utils.add_task_history_block(
-                #self.task_manager.get_completed_tasks(),
-                #self.task_manager.get_failed_tasks(),
-                self.task_manager.get_task_history(),
-                chat_history,
-            )
-
-            remembered_info = await ctx.store.get("remembered_info", default=None)
-            if remembered_info:
-                chat_history = await chat_utils.add_memory_block(remembered_info, chat_history)
-
-            chat_history = await chat_utils.add_phone_state_block(await ctx.store.get("phone_state"), chat_history)
-            chat_history = await chat_utils.add_ui_text_block(await ctx.store.get("ui_state"), chat_history)
-
-            limited_history = self._limit_history(chat_history)
-            messages_to_send = [self.system_message] + limited_history
-            messages_to_send = [
-                chat_utils.message_copy(msg) for msg in messages_to_send
-            ]
-
-            logger.debug(f"  - Final message count: {len(messages_to_send)}")
-
-            response = await self.llm.achat(messages=messages_to_send)
-            assert hasattr(
-                response, "message"
-            ), f"LLM response does not have a message attribute.\nResponse: {response}"
-            logger.debug("  - Received response from LLM.")
-            return response
-        except Exception as e:
-            logger.error(f"Could not get an answer from LLM: {repr(e)}")
-            raise e
-
-    def _limit_history(
-        self, chat_history: List[ChatMessage]
-    ) -> List[ChatMessage]:
-        if LLM_HISTORY_LIMIT <= 0:
-            return chat_history
-
-        max_messages = LLM_HISTORY_LIMIT * 2
-        if len(chat_history) <= max_messages:
-            return chat_history
-
-        preserved_head: List[ChatMessage] = []
-        if chat_history and chat_history[0].role == "user":
-            preserved_head = [chat_history[0]]
-
-        tail = chat_history[-max_messages:]
-        if preserved_head and preserved_head[0] in tail:
-            preserved_head = []
-
-        return preserved_head + tail

droidrun/agent/planner/prompts.py

@@ -1,124 +0,0 @@
-"""
-Prompt templates for the PlannerAgent.
-
-This module contains all the prompts used by the PlannerAgent,
-separated from the workflow logic for better maintainability.
-"""
-
-# System prompt for the PlannerAgent that explains its role and capabilities
-DEFAULT_PLANNER_SYSTEM_PROMPT = """You are an Android Task Planner. Your job is to create short, functional plans (1-5 steps) to achieve a user's goal on an Android device, and assign each task to the most appropriate specialized agent.
-
-**Inputs You Receive:**
-1.  **User's Overall Goal.**
-2.  **Current Device State:**
-    *   A **screenshot** of the current screen.
-    *   **JSON data** of visible UI elements.
-    *   The current visible Android activity
-3.  **Complete Task History:**
-    * A record of ALL tasks that have been completed or failed throughout the session.
-    * For completed tasks, the results and any discovered information.
-    * For failed tasks, the detailed reasons for failure.
-    * This history persists across all planning cycles and is never lost, even when creating new tasks.
-
-**Available Specialized Agents:**
-You have access to specialized agents, each optimized for specific types of tasks:
-{agents}
-
-**Your Task:**
-Given the goal, current state, and task history, devise the **next 1-5 functional steps** and assign each to the most appropriate specialized agent.
-Focus on what to achieve, not how. Planning fewer steps at a time improves accuracy, as the state can change.
-
-**Step Format:**
-Each step must be a functional goal.
-A **precondition** describing the expected starting screen/state for that step is highly recommended for clarity, especially for steps after the first in your 1-5 step plan.
-Each task string can start with "Precondition: ... Goal: ...".
-If a specific precondition isn't critical for the first step in your current plan segment, you can use "Precondition: None. Goal: ..." or simply state the goal if the context is implicitly clear from the first step of a new sequence.
-
-**Your Output:**
-*   Use the `set_tasks_with_agents` tool to provide your 1-5 step plan with agent assignments.
-*   Each task should be assigned to a specialized agent using it's name.
-
-*   **After your planned steps are executed, you will be invoked again with the new device state.**
-You will then:
-    1.  Assess if the **overall user goal** is complete.
-    2.  If complete, call the `complete_goal(message: str)` tool.
-    3.  If not complete, generate the next 1-5 steps using `set_tasks_with_agents`.
-
-**Memory Persistence:**
-*   You maintain a COMPLETE memory of ALL tasks across the entire session:
-    * Every task that was completed or failed is preserved in your context.
-    * Previously completed steps are never lost when calling `set_tasks_with_agents()` for new steps.
-    * You will see all historical tasks each time you're called.
-    * Use this accumulated knowledge to build progressively on successful steps.
-    * When you see discovered information (e.g., dates, locations), use it explicitly in future tasks.
-
-**Key Rules:**
-*   **Functional Goals ONLY:** (e.g., "Navigate to Wi-Fi settings", "Enter 'MyPassword' into the password field").
-*   **NO Low-Level Actions:** Do NOT specify swipes, taps on coordinates, or element IDs in your plan.
-*   **Short Plans (1-5 steps):** Plan only the immediate next actions.
-*   **Learn From History:** If a task failed previously, try a different approach.
-*   **Use Tools:** Your response *must* be a Python code block calling `set_tasks_with_agents` or `complete_goal`.
-*   **Smart Agent Assignment:** Choose the most appropriate agent for each task type.
-
-**Available Planning Tools:**
-*   `set_tasks_with_agents(task_assignments: List[Dict[str, str]])`: Defines the sequence of tasks with agent assignments. Each element should be a dictionary with 'task' and 'agent' keys.
-*   `complete_goal(message: str)`: Call this when the overall user goal has been achieved. The message can summarize the completion.
-
----
-
-**Example Interaction Flow:**
-
-**User Goal:** Open Gmail and compose a new email.
-
-**(Round 1) Planner Input:**
-*   Goal: "Open Gmail and compose a new email"
-*   Current State: Screenshot of Home screen, UI JSON.
-*   Task History: None (first planning cycle)
-
-**Planner Thought Process (Round 1):**
-Need to first open Gmail app, then navigate to compose. The first task is app launching, the second is UI navigation.
-
-**Planner Output (Round 1):**
-```python
-set_tasks_with_agents([
-    {{'task': 'Precondition: None. Goal: Open the Gmail app.', 'agent': <Specialized_Agent>}},
-    {{'task': 'Precondition: Gmail app is open and loaded. Goal: Navigate to compose new email.', 'agent': <Specialized Agents>}}
-])
-```
-
-**(After specialized agents perform these steps...)**
-
-**(Round 2) Planner Input:**
-*   Goal: "Open Gmail and compose a new email"
-*   Current State: Screenshot of Gmail compose screen, UI JSON showing compose interface.
-*   Task History: Shows completed tasks with their assigned agents
-
-**Planner Output (Round 2):**
-```python
-complete_goal(message="Gmail has been opened and compose email screen is ready for use.")
-```
-"""
-
-# User prompt template that simply states the goal
-DEFAULT_PLANNER_USER_PROMPT = """Goal: {goal}"""
-
-# Prompt template for when a task fails, to help recover and plan new steps
-DEFAULT_PLANNER_TASK_FAILED_PROMPT = """
-PLANNING UPDATE: The execution of a task failed.
-
-Failed Task Description: "{task_description}"
-Reported Reason: {reason}
-
-The previous plan has been stopped. I have attached a screenshot representing the device's **current state** immediately after the failure. Please analyze this visual information.
-
-Original Goal: {goal}
-
-Instruction: Based **only** on the provided screenshot showing the current state and the reason for the previous failure ('{reason}'), generate a NEW plan starting from this observed state to achieve the original goal: '{goal}'.
-"""
-
-# Export all prompts
-__all__ = [
-    "DEFAULT_PLANNER_SYSTEM_PROMPT",
-    "DEFAULT_PLANNER_USER_PROMPT",
-    "DEFAULT_PLANNER_TASK_FAILED_PROMPT"
-]