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

droidrun/agent/manager/prompts.py

@@ -5,155 +5,6 @@ Prompts for the ManagerAgent.
 import re
 
 
-def build_manager_system_prompt(
-    instruction: str,
-    has_text_to_modify: bool = False,
-    app_card: str = "",
-    device_date: str = "",
-    important_notes: str = "",
-    error_flag: bool = False,
-    error_history: list = [],  # noqa: B006
-    custom_tools_descriptions: str = ""
-) -> str:
-    """
-    Build the manager system prompt with all context.
-
-    Args:
-        instruction: User's goal/task
-        has_text_to_modify: Whether focused text field has editable content
-        app_card: App-specific instructions (TODO: implement app card system)
-        device_date: Current device date (TODO: implement via adb shell date)
-        important_notes: Additional important information
-        error_flag: Whether consecutive errors occurred
-        error_history: List of recent errors if error_flag=True
-        custom_tools_descriptions: Formatted descriptions of custom tools available to executor
-
-    Returns:
-        Complete system prompt for Manager
-    """
-    prompt = (
-        "You are an agent who can operate an Android phone on behalf of a user. "
-        "Your goal is to track progress and devise high-level plans to achieve the user's requests.\n\n"
-        "<user_request>\n"
-        f"{instruction}\n"
-        "</user_request>\n\n"
-    )
-
-
-    if device_date.strip():
-        prompt += f"<device_date>\n{device_date}\n</device_date>\n\n"
-
-
-
-
-    if app_card.strip():
-        prompt += "App card gives information on how to operate the app and perform actions.\n"
-        prompt += f"<app_card>\n{app_card.strip()}\n</app_card>\n\n"
-
-    # Important notes
-    if important_notes:
-        prompt += "<important_notes>\n"
-        prompt += f"{important_notes}\n"
-        prompt += "</important_notes>\n\n"
-
-    # Error escalation
-    if error_flag and error_history:
-        prompt += (
-            "<potentially_stuck>\n"
-            "You have encountered several failed attempts. Here are some logs:\n"
-        )
-        for error in error_history:
-            prompt += (
-                f"- Attempt: Action: {error['action']} | "
-                f"Description: {error['summary']} | "
-                f"Outcome: Failed | "
-                f"Feedback: {error['error']}\n"
-            )
-        prompt += "</potentially_stuck>\n\n"
-
-    # Guidelines
-    prompt += """<guidelines>
-The following guidelines will help you plan this request.
-General:
-1. Use the `open_app` action whenever you want to open an app, do not use the app drawer to open an app.
-2. Use search to quickly find a file or entry with a specific name, if search function is applicable.
-3. Only use copy to clipboard actions when the task specifically requires copying text to clipboard. Do not copy text just to use it later - use the Memory section instead.
-4. When you need to remember information for later use, store it in the Memory section (using <add_memory> tags) with step context (e.g., "At step X, I obtained [information] from [source]").
-5. File names in the user request must always match the exact file name you are working with, make that reflect in the plan too.
-6. Make sure names and titles are not cutoff. If the request is to check who sent a message, make sure to check the message sender's full name not just what appears in the notification because it might be cut off.
-7. Dates and file names must match the user query exactly.
-8. Don't do more than what the user asks for."""
-
-    # Text manipulation guidelines (conditional)
-    if has_text_to_modify:
-        prompt += """
-
-<text_manipulation>
-1. Use **TEXT_TASK:** prefix in your plan when you need to modify text in the currently focused text input field
-2. TEXT_TASK is for editing, formatting, or transforming existing text content in text boxes using Python code
-3. Do not use TEXT_TASK for extracting text from messages, typing new text, or composing messages
-4. The focused text field contains editable text that you can modify
-5. Example plan item: 'TEXT_TASK: Add "Hello World" at the beginning of the text'
-6. Always use TEXT_TASK for modifying text, do not try to select the text to copy/cut/paste or adjust the text
-</text_manipulation>"""
-
-    prompt += """
-
-Memory Usage:
-- Always include step context: "At step [number], I obtained [actual content] from [source]"
-- Store the actual content you observe, not just references (e.g., store full recipe text, not "found recipes")
-- Use memory instead of copying text unless specifically requested
-- Memory is append-only: whatever you put in <add_memory> tags gets added to existing memory, not replaced
-- Update memory to track progress on multi-step tasks
-
-</guidelines>"""
-
-    # Add custom tools section if custom tools are provided
-    if custom_tools_descriptions.strip():
-        prompt += """
-
-<custom_actions>
-The executor has access to these additional custom actions beyond the standard actions (click, type, swipe, etc.):
-""" + custom_tools_descriptions + """
-
-You can reference these custom actions or tell the Executer agent to use them in your plan when they help achieve the user's goal.
-</custom_actions>"""
-
-    prompt += """
----
-Carefully assess the current status and the provided screenshot. Check if the current plan needs to be revised.
-Determine if the user request has been fully completed. If you are confident that no further actions are required, use the request_accomplished tag with a message in it. If the user request is not finished, update the plan and don't use it. If you are stuck with errors, think step by step about whether the overall plan needs to be revised to address the error.
-NOTE: 1. If the current situation prevents proceeding with the original plan or requires clarification from the user, make reasonable assumptions and revise the plan accordingly. Act as though you are the user in such cases. 2. Please refer to the helpful information and steps in the Guidelines first for planning. 3. If the first subgoal in plan has been completed, please update the plan in time according to the screenshot and progress to ensure that the next subgoal is always the first item in the plan. 4. If the first subgoal is not completed, please copy the previous round's plan or update the plan based on the completion of the subgoal.
-Provide your output in the following format, which contains four or five parts:
-
-<thought>
-An explanation of your rationale for the updated plan and current subgoal.
-</thought>
-
-<add_memory>
-Store important information here with step context for later reference. Always include "At step X, I obtained [actual content] from [source]".
-Examples:
-- At step 5, I obtained recipe details from recipes.jpg: Recipe 1 "Chicken Pasta" - ingredients: chicken, pasta, cream. Instructions: Cook pasta, sauté chicken, add cream.
-or
-- At step 12, I successfully added Recipe 1 to Broccoli app. Still need to add Recipe 2 and Recipe 3 from memory.
-Store important information here with step context for later reference.
-</add_memory>
-
-<plan>
-Please update or copy the existing plan according to the current page and progress. Please pay close attention to the historical operations. Please do not repeat the plan of completed content unless you can judge from the screen status that a subgoal is indeed not completed.
-</plan>
-
-<request_accomplished>
-Use this tag ONLY after actually completing the user's request through concrete actions, not at the beginning or for planning.
-
-1. Always include a message inside this tag confirming what you accomplished
-2. Ensure both opening and closing tags are present
-3. Use exclusively for signaling completed user requests
-</request_accomplished>"""
-
-    return prompt
-
-
 def parse_manager_response(response: str) -> dict:
     """
     Parse manager LLM response into structured dict.
@@ -163,7 +14,6 @@ def parse_manager_response(response: str) -> dict:
     - <add_memory>...</add_memory>
     - <plan>...</plan>
     - <request_accomplished>...</request_accomplished> (answer)
-    - <historical_operations>...</historical_operations> (optional, for completed plan)
 
     Also derives:
     - current_subgoal: first line of plan (with list markers removed)
@@ -177,8 +27,7 @@ def parse_manager_response(response: str) -> dict:
             - memory: str
             - plan: str
             - current_subgoal: str (first line of plan, cleaned)
-            - completed_subgoal: str
-            - answer: str (from request_accomplished tag)
+            - request_accomplished: str (from request_accomplished tag)
     """
     def extract(tag: str) -> str:
         """Extract content between XML-style tags."""
@@ -191,12 +40,6 @@ def parse_manager_response(response: str) -> dict:
     plan = extract("plan")
     answer = extract("request_accomplished")
 
-    # Extract completed subgoal (optional historical_operations tag)
-    if "<historical_operations>" in response:
-        completed_subgoal = extract("historical_operations")
-    else:
-        completed_subgoal = "No completed subgoal."
-
     # Parse current subgoal from first line of plan
     current_goal_text = plan
     # Prefer newline-separated plans; take the first non-empty line
@@ -215,7 +58,6 @@ def parse_manager_response(response: str) -> dict:
 
     return {
         "thought": thought,
-        "completed_subgoal": completed_subgoal,
         "plan": plan,
         "memory": memory_section,
         "current_subgoal": current_subgoal,

droidrun/agent/utils/chat_utils.py

@@ -155,6 +155,47 @@ async def add_packages_block(packages, chat_history: List[ChatMessage]) -> List[
     chat_history[-1].blocks.append(ui_block)
     return chat_history
 
+async def add_device_state_block(
+    formatted_device_state: str,
+    chat_history: List[ChatMessage],
+    copy: bool = True
+) -> List[ChatMessage]:
+    """
+    Add formatted device state to the LAST user message in chat history.
+
+    This follows the pattern of other chat_utils functions:
+    - Doesn't create a new message
+    - Appends to last user message content
+    - Prevents device state from being saved to every message in memory
+
+    Args:
+        formatted_device_state: Complete formatted device state text
+        chat_history: Current chat history
+        copy: Whether to copy the history before modifying (default: True)
+
+    Returns:
+        Updated chat history with device state in last user message
+    """
+    if not formatted_device_state or not formatted_device_state.strip():
+        return chat_history
+
+    if not chat_history:
+        return chat_history
+
+    # Create device state block
+    device_state_block = TextBlock(text=f"\n{formatted_device_state}\n")
+
+    # Copy history if requested
+    if copy:
+        chat_history = chat_history.copy()
+        chat_history[-1] = message_copy(chat_history[-1])
+
+    # Append to last message blocks
+    chat_history[-1].blocks.append(device_state_block)
+
+    return chat_history
+
+
 async def add_memory_block(memory: List[str], chat_history: List[ChatMessage]) -> List[ChatMessage]:
     memory_block = "\n### Remembered Information:\n"
     for idx, item in enumerate(memory, 1):
@@ -294,6 +335,27 @@ def has_non_empty_content(msg):
             return True
     return False
 
-@clean_span("remove_empty_messages")
 def remove_empty_messages(messages):
-    return [msg for msg in messages if has_non_empty_content(msg)]
+    """Remove empty messages and duplicates, with span decoration."""
+    if not messages or all(has_non_empty_content(msg) for msg in messages):
+        return messages
+
+    @clean_span("remove_empty_messages")
+    def process_messages():
+        # Remove empty messages first
+        cleaned = [msg for msg in messages if has_non_empty_content(msg)]
+
+        # Remove duplicates based on content
+        seen_contents = set()
+        unique_messages = []
+        for msg in cleaned:
+            content = msg.get('content', [])
+            content_str = str(content)  # Simple string representation for deduplication
+            if content_str not in seen_contents:
+                seen_contents.add(content_str)
+                unique_messages.append(msg)
+
+        logger.debug(f"Removed empty messages and duplicates: {len(messages)} -> {len(unique_messages)}")
+        return unique_messages
+
+    return process_messages()

droidrun/agent/utils/device_state_formatter.py

@@ -101,50 +101,75 @@ def format_ui_elements(ui_data: List[Dict[str, Any]], level: int = 0) -> str:
     return "\n".join(formatted_lines)
 
 
-def get_device_state_exact_format(state: Dict[str, Any]) -> Tuple[str, str]:
+def format_device_state(state: Dict[str, Any]) -> Tuple[str, str, List[Dict], Dict]:
     """
-    Get device state in exactly the format requested:
-
-    **Current Phone State:**
-    • **App:** App Name (package.name)
-    • **Keyboard:** Hidden/Visible
-    • **Focused Element:** 'text'
+    Format device state with all necessary data.
 
-    Current Clickable UI elements from the device in the schema 'index. className: resourceId, text - bounds(x1,y1,x2,y2)':
-    1. ClassName: "resourceId", "text" - (x1, y1, x2, y2)
+    Returns formatted text for prompts plus raw components for storage.
 
     Args:
-        state: Dictionary containing device state data from collector.get_device_state()
+        state: Dictionary containing device state data from tools.get_state()
 
     Returns:
-        Tuple of (formatted_string, focused_text) where focused_text is the actual
-        text content of the focused element, or empty string if none.
+        Tuple of:
+        - formatted_text (str): Complete formatted device state for prompts
+        - focused_text (str): Text content of focused element (empty if none)
+        - a11y_tree (List[Dict]): Raw accessibility tree
+        - phone_state (Dict): Raw phone state dict
     """
     try:
         if "error" in state:
-            return (f"Error getting device state: {state.get('message', 'Unknown error')}", "")
+            error_msg = f"Error getting device state: {state.get('message', 'Unknown error')}"
+            return (error_msg, "", [], {})
 
-        # Extract focused element text
+        # Extract raw components
         phone_state = state.get("phone_state", {})
+        a11y_tree = state.get("a11y_tree", [])
+
+        # Extract focused element text
         focused_element = phone_state.get('focusedElement')
         focused_text = ""
         if focused_element:
             focused_text = focused_element.get('text', '')
 
-        # Format the state data
+        # Format phone state section
         phone_state_text = format_phone_state(phone_state)
-        ui_data = state.get("a11y_tree", [])
-        if ui_data:
-            formatted_ui = format_ui_elements(ui_data)
-            ui_elements_text = f"Current Clickable UI elements from the device in the schema 'index. className: resourceId, text - bounds(x1,y1,x2,y2)':\n{formatted_ui}"
+
+        # Format UI elements section
+        if a11y_tree:
+            formatted_ui = format_ui_elements(a11y_tree)
+            ui_elements_text = (
+                "Current Clickable UI elements from the device in the schema "
+                "'index. className: resourceId, text - bounds(x1,y1,x2,y2)':\n"
+                f"{formatted_ui}"
+            )
         else:
-            ui_elements_text = "Current Clickable UI elements from the device in the schema 'index. className: resourceId, text - bounds(x1,y1,x2,y2)':\nNo UI elements found"
+            ui_elements_text = (
+                "Current Clickable UI elements from the device in the schema "
+                "'index. className: resourceId, text - bounds(x1,y1,x2,y2)':\n"
+                "No UI elements found"
+            )
+
+        # Combine into complete formatted text
+        formatted_text = f"{phone_state_text}\n\n{ui_elements_text}"
 
-        formatted_string = f"{phone_state_text}\n        \n\n{ui_elements_text}"
+        # Return all 4 components
+        return (formatted_text, focused_text, a11y_tree, phone_state)
 
-        return (formatted_string, focused_text)
     except Exception as e:
-        return (f"Error getting device state: {e}", "")
+        return (f"Error formatting device state: {e}", "", [], {})
+
+
+# Backward compatibility alias
+def get_device_state_exact_format(state: Dict[str, Any]) -> Tuple[str, str]:
+    """
+    Deprecated: Use format_device_state() instead.
+
+    This function is kept for backward compatibility with ManagerAgent and ExecutorAgent.
+    Returns only the first two values (formatted_text, focused_text).
+    """
+    formatted_text, focused_text, _, _ = format_device_state(state)
+    return (formatted_text, focused_text)
 
 
 def main():
@@ -167,10 +192,13 @@ def main():
         ]
     }
 
-    formatted_string, focused_text = get_device_state_exact_format(example_state)
-    print("Formatted String:")
-    print(formatted_string)
+    # Test new format_device_state function
+    formatted_text, focused_text, a11y_tree, phone_state = format_device_state(example_state)
+    print("Formatted Text:")
+    print(formatted_text)
     print(f"\nFocused Text: '{focused_text}'")
+    print(f"\nA11y Tree: {a11y_tree}")
+    print(f"\nPhone State: {phone_state}")
 
 
 if __name__ == "__main__":

droidrun/agent/utils/executer.py

@@ -1,19 +1,20 @@
-import asyncio
-import contextlib
 import io
-import logging
-import threading
+import contextlib
 import traceback
+import logging
+from typing import Any, Dict, Optional
 from asyncio import AbstractEventLoop
-from typing import Any, Dict
-
-from llama_index.core.workflow import Context
-
-from droidrun.agent.utils.async_utils import async_to_sync
-from droidrun.tools.adb import AdbTools
+from pydantic import BaseModel
 
 logger = logging.getLogger("droidrun")
 
+class ExecuterState(BaseModel):
+    """State object for the code executor."""
+    ui_state: Optional[Any] = None
+    
+    class Config:
+        arbitrary_types_allowed = True
+
 
 class SimpleCodeExecutor:
     """
@@ -28,122 +29,107 @@ class SimpleCodeExecutor:
     def __init__(
         self,
         loop: AbstractEventLoop,
-        locals: Dict[str, Any] = {},  # noqa: B006
-        globals: Dict[str, Any] = {},  # noqa: B006
-        tools={},  # noqa: B006
-        tools_instance=None,
+        locals: Dict[str, Any] = None,
+        globals: Dict[str, Any] = None,
+        tools=None,
         use_same_scope: bool = True,
     ):
         """
         Initialize the code executor.
 
         Args:
+            loop: The event loop to use for async execution
             locals: Local variables to use in the execution context
             globals: Global variables to use in the execution context
-            tools: List of tools available for execution
-            tools_instance: Original tools instance (e.g., AdbTools instance)
+            tools: Dict or list of tools available for execution
+            use_same_scope: Whether to use the same scope for globals and locals
         """
-
-        self.tools_instance = tools_instance
-
-        # loop throught tools and add them to globals, but before that check if tool value is async, if so convert it to sync. tools is a dictionary of tool name: function
-        # e.g. tools = {'tool_name': tool_function}
-
-        # check if tools is a dictionary
+        if locals is None:
+            locals = {}
+        if globals is None:
+            globals = {}
+        if tools is None:
+            tools = {}
+
+        # Add tools to globals
         if isinstance(tools, dict):
-            logger.debug(
-                f"🔧 Initializing SimpleCodeExecutor with tools: {tools.items()}"
-            )
-            for tool_name, tool_function in tools.items():
-                if asyncio.iscoroutinefunction(tool_function):
-                    # If the function is async, convert it to sync
-                    tool_function = async_to_sync(tool_function)
-                # Add the tool to globals
-                globals[tool_name] = tool_function
+            logger.debug(f"🔧 Initializing SimpleCodeExecutor with tools: {list(tools.keys())}")
+            globals.update(tools)
         elif isinstance(tools, list):
-            logger.debug(f"🔧 Initializing SimpleCodeExecutor with tools: {tools}")
-            # If tools is a list, convert it to a dictionary with tool name as key and function as value
+            logger.debug(f"🔧 Initializing SimpleCodeExecutor with {len(tools)} tools")
             for tool in tools:
-                if asyncio.iscoroutinefunction(tool):
-                    # If the function is async, convert it to sync
-                    tool = async_to_sync(tool)
-                # Add the tool to globals
                 globals[tool.__name__] = tool
         else:
             raise ValueError("Tools must be a dictionary or a list of functions.")
 
+        # Add common imports
         import time
-
         globals["time"] = time
 
         self.globals = globals
         self.locals = locals
         self.loop = loop
         self.use_same_scope = use_same_scope
-        self.tools = tools
+        
         if self.use_same_scope:
-            # If using the same scope, set the globals and locals to the same dictionary
+            # If using the same scope, merge globals and locals
             self.globals = self.locals = {
                 **self.locals,
                 **{k: v for k, v in self.globals.items() if k not in self.locals},
             }
 
-    async def execute(self, ctx: Context, code: str) -> str:
+    def _execute_in_thread(self, code: str, ui_state: Any) -> str:
         """
-        Execute Python code and capture output and return values.
-
-        Args:
-            code: Python code to execute
-
-        Returns:
-            str: Output from the execution, including print statements.
+        Execute code synchronously in a thread.
+        All async tools will be called synchronously here.
         """
-        # Update UI elements before execution
-        self.globals['ui_state'] = await ctx.store.get("ui_state", None)
-        self.globals['step_screenshots'] = []
-        self.globals['step_ui_states'] = []
-
-        if self.tools_instance and isinstance(self.tools_instance, AdbTools):
-            self.tools_instance._set_context(ctx)
-
+        # Update UI state
+        self.globals['ui_state'] = ui_state
+        
         # Capture stdout and stderr
         stdout = io.StringIO()
         stderr = io.StringIO()
 
         output = ""
         try:
-            # Execute with captured output
-            thread_exception = []
             with contextlib.redirect_stdout(stdout), contextlib.redirect_stderr(stderr):
-
-                def execute_code():
-                    try:
-                        exec(code, self.globals, self.locals)
-                    except Exception as e:
-                        import traceback
-
-                        thread_exception.append((e, traceback.format_exc()))
-
-                t = threading.Thread(target=execute_code)
-                t.start()
-                t.join()
+                # Just exec the code directly - no async needed!
+                exec(code, self.globals, self.locals)
 
             # Get output
             output = stdout.getvalue()
             if stderr.getvalue():
                 output += "\n" + stderr.getvalue()
-            if thread_exception:
-                e, tb = thread_exception[0]
-                output += f"\nError: {type(e).__name__}: {str(e)}\n{tb}"
 
         except Exception as e:
             # Capture exception information
             output = f"Error: {type(e).__name__}: {str(e)}\n"
             output += traceback.format_exc()
 
-        result = {
-            'output': output,
-            'screenshots': self.globals['step_screenshots'],
-            'ui_states': self.globals['step_ui_states'],
-        }
-        return result
+        return output
+
+    async def execute(self, state: ExecuterState, code: str) -> str:
+        """
+        Execute Python code and capture output and return values.
+        
+        Runs the code in a separate thread to prevent blocking.
+
+        Args:
+            state: ExecuterState containing ui_state and other execution context.
+            code: Python code to execute
+
+        Returns:
+            str: Output from the execution, including print statements.
+        """
+        # Get UI state from the state object
+        ui_state = state.ui_state
+        
+        # Run the execution in a thread pool executor
+        output = await self.loop.run_in_executor(
+            None,
+            self._execute_in_thread,
+            code,
+            ui_state
+        )
+        
+        return output

droidrun/agent/utils/inference.py

@@ -1,11 +1,12 @@
 
+import asyncio
 import contextvars
 import threading
 import time
 from concurrent.futures import TimeoutError as FuturesTimeoutError
-import asyncio
 from typing import Any, Optional
 
+
 def call_with_retries(llm, messages, retries=3, timeout=500, delay=1.0):
     last_exception = None
 
@@ -67,26 +68,26 @@ async def acall_with_retries(
 ) -> Any:
     """
     Call LLM with retries and timeout handling.
-    
+
     Args:
         llm: The LLM client instance
         messages: List of messages to send
         retries: Number of retry attempts
         timeout: Timeout in seconds for each attempt
         delay: Base delay between retries (multiplied by attempt number)
-    
+
     Returns:
         The LLM response object
     """
     last_exception: Optional[Exception] = None
-    
+
     for attempt in range(1, retries + 1):
         try:
             response = await asyncio.wait_for(
                 llm.achat(messages=messages),  # Use achat() instead of chat()
                 timeout=timeout
             )
-            
+
             # Validate response
             if (
                 response is not None
@@ -97,18 +98,18 @@ async def acall_with_retries(
             else:
                 print(f"Attempt {attempt} returned empty content")
                 last_exception = ValueError("Empty response content")
-                
+
         except asyncio.TimeoutError:
             print(f"Attempt {attempt} timed out after {timeout} seconds")
             last_exception = TimeoutError("Timed out")
-            
+
         except Exception as e:
             print(f"Attempt {attempt} failed with error: {e!r}")
             last_exception = e
-        
+
         if attempt < retries:
             await asyncio.sleep(delay * attempt)
-    
+
     if last_exception:
         raise last_exception
-    raise ValueError("All attempts returned empty response content")
+    raise ValueError("All attempts returned empty response content")