droidrun 0.3.10.dev8__tar.gz → 0.3.10.dev10__tar.gz

{droidrun-0.3.10.dev8 → droidrun-0.3.10.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: droidrun
-Version: 0.3.10.dev8
+Version: 0.3.10.dev10
 Summary: A framework for controlling Android devices through LLM agents
 Project-URL: Homepage, https://github.com/droidrun/droidrun
 Project-URL: Bug Tracker, https://github.com/droidrun/droidrun/issues

{droidrun-0.3.10.dev8 → droidrun-0.3.10.dev10}/droidrun/agent/codeact/codeact_agent.py

@@ -75,7 +75,6 @@ class CodeActAgent(Workflow):
         self.remembered_info = None
 
         self.goal = None
-        self.steps_counter = 0
         self.code_exec_counter = 0
 
         # Build tool list
@@ -164,7 +163,7 @@ Now, describe the next step you will take to address the original goal: {goal}""
         assert len(chat_history) > 0, "Chat history cannot be empty."
         ctx.write_event_to_stream(ev)
 
-        if self.steps_counter >= self.max_steps:
+        if self.shared_state.step_number + 1 > self.max_steps:
             ev = TaskEndEvent(
                 success=False,
                 reason=f"Reached max step count of {self.max_steps} steps",
@@ -172,8 +171,7 @@ Now, describe the next step you will take to address the original goal: {goal}""
             ctx.write_event_to_stream(ev)
             return ev
 
-        self.steps_counter += 1
-        logger.info(f"🧠 Step {self.steps_counter}: Thinking...")
+        logger.info(f"🧠 Step {self.shared_state.step_number + 1}: Thinking...")
 
         model = self.llm.class_name()
 
@@ -200,15 +198,17 @@ Now, describe the next step you will take to address the original goal: {goal}""
             formatted_text, focused_text, a11y_tree, phone_state = format_device_state(raw_state)
 
             # Update shared_state if available
-            if self.shared_state is not None:
-                self.shared_state.formatted_device_state = formatted_text
-                self.shared_state.focused_text = focused_text
-                self.shared_state.a11y_tree = a11y_tree
-                self.shared_state.phone_state = phone_state
-
-                # Extract and store package/app name
-                self.shared_state.current_package_name = phone_state.get('packageName', 'Unknown')
-                self.shared_state.current_app_name = phone_state.get('currentApp', 'Unknown')
+            assert self.shared_state is not None, "Shared state is not set"
+            self.shared_state.formatted_device_state = formatted_text
+            self.shared_state.focused_text = focused_text
+            self.shared_state.a11y_tree = a11y_tree
+            self.shared_state.phone_state = phone_state
+
+            # Extract and store package/app name (using unified update method)
+            self.shared_state.update_current_app(
+                package_name=phone_state.get('packageName', 'Unknown'),
+                activity_name=phone_state.get('currentApp', 'Unknown')
+            )
 
             # Stream formatted state for trajectory
             ctx.write_event_to_stream(RecordUIStateEvent(ui_state=a11y_tree))
@@ -235,6 +235,7 @@ Now, describe the next step you will take to address the original goal: {goal}""
             usage = None
 
         await self.chat_memory.aput(response.message)
+        self.shared_state.step_number += 1
 
         code, thoughts = chat_utils.extract_code_and_thought(response.message.content)
 
@@ -359,8 +360,6 @@ Now, describe the next step you will take to address the original goal: {goal}""
             {
                 "success": ev.success,
                 "reason": ev.reason,
-                "output": ev.reason,
-                "codeact_steps": self.steps_counter,
                 "code_executions": self.code_exec_counter,
             }
         )

{droidrun-0.3.10.dev8 → droidrun-0.3.10.dev10}/droidrun/agent/droid/droid_agent.py

@@ -124,7 +124,11 @@ class DroidAgent(Workflow):
         """
 
         self.user_id = kwargs.pop("user_id", None)
-
+        self.runtype = kwargs.pop("runtype", "developer")
+        self.shared_state = DroidAgentState(
+            instruction=goal,
+            err_to_manager_thresh=2
+        )
         base_config = config
 
         self.config = DroidRunConfig(
@@ -154,7 +158,6 @@ class DroidAgent(Workflow):
                     "    • If installed via pip: `uv pip install droidrun[phoenix]`\n"
                 )
 
-        self.goal = goal
         self.timeout = timeout
         self.custom_tools = custom_tools or {}
 
@@ -180,8 +183,7 @@ class DroidAgent(Workflow):
             self.app_opener_llm = llms
 
 
-        self.event_counter = 0
-        self.trajectory = Trajectory(goal=goal)
+        self.trajectory = Trajectory(goal=self.shared_state.instruction)
         self.task_manager = TaskManager()
         self.task_iter = None
         self.current_episodic_memory = None
@@ -202,10 +204,6 @@ class DroidAgent(Workflow):
         # Set app_opener_llm on tools instance for open_app custom tool
         self.tools_instance.app_opener_llm = self.app_opener_llm
 
-        self.shared_state = DroidAgentState(
-            instruction=goal,
-            err_to_manager_thresh=2
-        )
 
         if self.config.agent.reasoning:
             logger.info("📝 Initializing Manager and Executor Agents...")
@@ -236,7 +234,7 @@ class DroidAgent(Workflow):
 
         capture(
             DroidAgentInitEvent(
-                goal=goal,
+                goal=self.shared_state.instruction,
                 llms={
                     "manager": self.manager_llm.class_name() if self.manager_llm else "None",
                     "executor": self.executor_llm.class_name() if self.executor_llm else "None",
@@ -257,6 +255,7 @@ class DroidAgent(Workflow):
                 enable_tracing=self.config.tracing.enabled,
                 debug=self.config.logging.debug,
                 save_trajectories=self.config.logging.save_trajectory,
+                runtype=self.runtype,
             ),
             self.user_id,
         )
@@ -269,35 +268,6 @@ class DroidAgent(Workflow):
         """
         return super().run(*args, **kwargs)
 
-    def _create_finalize_event(
-        self,
-        success: bool,
-        reason: str,
-        output: str
-    ) -> FinalizeEvent:
-        """
-        Single source of truth for creating FinalizeEvent.
-
-        This helper ensures all FinalizeEvent creation is consistent
-        across the workflow.
-
-        Args:
-            success: Whether the task succeeded
-            reason: Reason for completion (deprecated, use output)
-            output: Output message
-
-        Returns:
-            FinalizeEvent ready to be returned
-        """
-        return FinalizeEvent(
-            success=success,
-            reason=reason,
-            output=output,
-            task=[], # TODO: use the final plan as the tasks and the goal as task
-            tasks=[],
-            steps=self.step_counter
-        )
-
     @step
     async def execute_task(self, ctx: Context, ev: CodeActExecuteEvent) -> CodeActResultEvent:
         """
@@ -339,14 +309,12 @@ class DroidAgent(Workflow):
                     success=True,
                     reason=result["reason"],
                     task=task,
-                    steps=result["codeact_steps"],
                 )
             else:
                 return CodeActResultEvent(
                     success=False,
                     reason=result["reason"],
                     task=task,
-                    steps=result["codeact_steps"],
                 )
 
         except Exception as e:
@@ -354,35 +322,25 @@ class DroidAgent(Workflow):
             if self.config.logging.debug:
                 import traceback
                 logger.error(traceback.format_exc())
-            return CodeActResultEvent(success=False, reason=f"Error: {str(e)}", task=task, steps=0)
+            return CodeActResultEvent(success=False, reason=f"Error: {str(e)}", task=task)
 
     @step
     async def handle_codeact_execute(
         self, ctx: Context, ev: CodeActResultEvent
     ) -> FinalizeEvent:
         try:
-            task = ev.task
             return FinalizeEvent(
                 success=ev.success,
-                reason=ev.reason,
-                output=ev.reason,
-                task=[task],
-                tasks=[task],
-                steps=ev.steps,
+                reason=ev.reason
             )
         except Exception as e:
             logger.error(f"❌ Error during DroidAgent execution: {e}")
             if self.config.logging.debug:
                 import traceback
                 logger.error(traceback.format_exc())
-            tasks = self.task_manager.get_task_history()
             return FinalizeEvent(
                 success=False,
                 reason=str(e),
-                output=str(e),
-                task=tasks,
-                tasks=tasks,
-                steps=self.step_counter,
             )
 
     @step
@@ -395,16 +353,14 @@ class DroidAgent(Workflow):
         Returns:
             Event to trigger next step based on reasoning mode
         """
-        logger.info(f"🚀 Running DroidAgent to achieve goal: {self.goal}")
+        logger.info(f"🚀 Running DroidAgent to achieve goal: {self.shared_state.instruction}")
         ctx.write_event_to_stream(ev)
 
-        self.step_counter = 0
-        self.retry_counter = 0
 
         if not self.config.agent.reasoning:
-            logger.info(f"🔄 Direct execution mode - executing goal: {self.goal}")
+            logger.info(f"🔄 Direct execution mode - executing goal: {self.shared_state.instruction}")
             task = Task(
-                description=self.goal,
+                description=self.shared_state.instruction,
                 status=self.task_manager.STATUS_PENDING,
                 agent_type="Default",
             )
@@ -429,15 +385,14 @@ class DroidAgent(Workflow):
         Pre-flight checks for termination before running manager.
         The Manager analyzes current state and creates a plan with subgoals.
         """
-        if self.step_counter >= self.config.agent.max_steps:
+        if self.shared_state.step_number >= self.config.agent.max_steps:
             logger.warning(f"⚠️ Reached maximum steps ({self.config.agent.max_steps})")
-            return self._create_finalize_event(
+            return FinalizeEvent(
                 success=False,
-                reason=f"Reached maximum steps ({self.config.agent.max_steps})",
-                output=f"Reached maximum steps ({self.config.agent.max_steps})"
+                reason=f"Reached maximum steps ({self.config.agent.max_steps})"
             )
 
-        logger.info(f"📋 Running Manager for planning... (step {self.step_counter}/{self.config.agent.max_steps})")
+        logger.info(f"📋 Running Manager for planning... (step {self.shared_state.step_number}/{self.config.agent.max_steps})")
 
         # Run Manager workflow
         handler = self.manager_agent.run()
@@ -472,10 +427,9 @@ class DroidAgent(Workflow):
             logger.info(f"💬 Manager provided answer: {ev.manager_answer}")
             self.shared_state.progress_status = f"Answer: {ev.manager_answer}"
 
-            return self._create_finalize_event(
+            return FinalizeEvent(
                 success=True,
-                reason=ev.manager_answer,
-                output=ev.manager_answer
+                reason=ev.manager_answer
             )
 
         # Continue to Executor with current subgoal
@@ -533,7 +487,7 @@ class DroidAgent(Workflow):
         Checks for error escalation and loops back to Manager.
         Note: Max steps check is now done in run_manager pre-flight.
         """
-        # Check error escalation
+        # Check error escalation and reset flag when errors are resolved
         err_thresh = self.shared_state.err_to_manager_thresh
 
         if len(self.shared_state.action_outcomes) >= err_thresh:
@@ -542,9 +496,13 @@ class DroidAgent(Workflow):
             if error_count == err_thresh:
                 logger.warning(f"⚠️ Error escalation: {err_thresh} consecutive errors")
                 self.shared_state.error_flag_plan = True
+            else:
+                if self.shared_state.error_flag_plan:
+                    logger.info("✅ Error resolved - resetting error flag")
+                self.shared_state.error_flag_plan = False
 
-        self.step_counter += 1
-        logger.info(f"🔄 Step {self.step_counter}/{self.config.agent.max_steps} complete, looping to Manager")
+        self.shared_state.step_number += 1
+        logger.info(f"🔄 Step {self.shared_state.step_number}/{self.config.agent.max_steps} complete, looping to Manager")
 
         return ManagerInputEvent()
 
@@ -557,10 +515,11 @@ class DroidAgent(Workflow):
         ctx.write_event_to_stream(ev)
         capture(
             DroidAgentFinalizeEvent(
-                tasks=",".join([f"{t.agent_type}:{t.description}" for t in ev.task]),
                 success=ev.success,
-                output=ev.output,
-                steps=ev.steps,
+                reason=ev.reason,
+                steps=self.shared_state.step_number,
+                unique_packages_count=len(self.shared_state._visited_packages),
+                unique_activities_count=len(self.shared_state._visited_activities),
             ),
             self.user_id,
         )
@@ -569,8 +528,7 @@ class DroidAgent(Workflow):
         result = {
             "success": ev.success,
             "reason": ev.reason,
-            "output": ev.output,
-            "steps": ev.steps,
+            "steps": self.shared_state.step_number,
         }
 
         if self.trajectory and self.config.logging.save_trajectory != "none":

{droidrun-0.3.10.dev8 → droidrun-0.3.10.dev10}/droidrun/agent/droid/events.py

@@ -26,18 +26,11 @@ class CodeActResultEvent(Event):
     success: bool
     reason: str
     task: Task
-    steps: int
 
 
 class FinalizeEvent(Event):
     success: bool
-    # deprecated. use output instead.
     reason: str
-    output: str
-    # deprecated. use tasks instead.
-    task: List[Task]
-    tasks: List[Task]
-    steps: int = 1
 
 class TaskRunnerEvent(Event):
     pass
@@ -50,9 +43,12 @@ class DroidAgentState(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
     # Task context
     instruction: str = ""
+    step_number: int = 0
     # App Cards
     app_card: str = ""
     app_card_loading_task: asyncio.Task[str] | None = None
+    _app_card_package: str = ""  # Track which package the loading task is for
+    _app_card_instruction: str = ""  # Track which instruction the loading task is for
     # Formatted device state for prompts (complete text)
     formatted_device_state: str = ""
 
@@ -63,9 +59,11 @@ class DroidAgentState(BaseModel):
     a11y_tree: List[Dict] = Field(default_factory=list)
     phone_state: Dict = Field(default_factory=dict)
 
-    # Derived fields (extracted from phone_state)
-    current_package_name: str = ""
-    current_app_name: str = ""
+    # Private fields
+    _current_package_name: str = ""
+    _current_activity_name: str = ""
+    _visited_packages: set = Field(default_factory=set)
+    _visited_activities: set = Field(default_factory=set)
 
     # Previous device state (for before/after comparison in Manager)
     previous_formatted_device_state: str = ""
@@ -108,6 +106,50 @@ class DroidAgentState(BaseModel):
     # Output
     output_dir: str = ""
 
+    @property
+    def current_package_name(self) -> str:
+        """Get current package name"""
+        return self._current_package_name
+
+    @property
+    def current_activity_name(self) -> str:
+        """Get current activity name"""
+        return self._current_activity_name
+
+    def update_current_app(self, package_name: str, activity_name: str):
+        """
+        Update package and activity together, capturing telemetry event only once.
+
+        This prevents duplicate PackageVisitEvents when both package and activity change.
+        """
+        # Check if either changed
+        package_changed = package_name != self._current_package_name
+        activity_changed = activity_name != self._current_activity_name
+
+        if not (package_changed or activity_changed):
+            return  # No change, nothing to do
+
+        # Update tracking sets
+        if package_changed and package_name:
+            self._visited_packages.add(package_name)
+        if activity_changed and activity_name:
+            self._visited_activities.add(activity_name)
+
+        # Update values
+        self._current_package_name = package_name
+        self._current_activity_name = activity_name
+
+        # Capture telemetry event for any change
+        # This ensures we track when apps close or transitions to empty state occur
+        from droidrun.telemetry import PackageVisitEvent, capture
+        capture(
+            PackageVisitEvent(
+                package_name=package_name or "Unknown",
+                activity_name=activity_name or "Unknown",
+                step_number=self.step_number,
+            )
+        )
+
 
 # ============================================================================
 # Manager/Executor coordination events

{droidrun-0.3.10.dev8 → droidrun-0.3.10.dev10}/droidrun/agent/executor/executor_agent.py

@@ -39,7 +39,7 @@ if TYPE_CHECKING:
 logger = logging.getLogger("droidrun")
 
 
-class ExecutorAgent(Workflow): # TODO: Fix a bug in bad prompt
+class ExecutorAgent(Workflow):
     """
     Action execution agent that performs specific actions.
 
@@ -115,7 +115,7 @@ class ExecutorAgent(Workflow): # TODO: Fix a bug in bad prompt
             self.agent_config.get_executor_system_prompt_path(),
             {
                 "instruction": self.shared_state.instruction,
-                "app_card": "",  # TODO: Implement app card loader
+                "app_card": "",  # TODO: optionally implement app card loader
                 "device_state": self.shared_state.formatted_device_state,
                 "plan": self.shared_state.plan,
                 "subgoal": subgoal,
@@ -196,9 +196,7 @@ class ExecutorAgent(Workflow): # TODO: Fix a bug in bad prompt
 
         outcome, error, summary = await self._execute_action(action_dict, ev.description)
 
-        # TODO: Add sleep after action (should be in DroidAgent.handle_executor_result)
-        # Available via: self.agent_config.after_sleep_action
-        # await asyncio.sleep(self.agent_config.after_sleep_action)
+        await asyncio.sleep(self.agent_config.after_sleep_action)
 
         logger.info(f"{'✅' if outcome else '❌'} Execution complete: {summary}")
 

{droidrun-0.3.10.dev8 → droidrun-0.3.10.dev10}/droidrun/agent/manager/manager_agent.py

@@ -328,21 +328,38 @@ class ManagerAgent(Workflow):
         self.shared_state.phone_state = phone_state
 
         # Extract and store package/app name
-        self.shared_state.current_package_name = phone_state.get('packageName', 'Unknown')
-        self.shared_state.current_app_name = phone_state.get('currentApp', 'Unknown')
+        self.shared_state.update_current_app(
+            package_name=phone_state.get('packageName', 'Unknown'),
+            activity_name=phone_state.get('currentApp', 'Unknown')
+        )
 
         # ====================================================================
-        # Step 1.5: Start loading app card in background
+        # Step 1.5: Start loading app card in background (only if package/instruction changed)
         # ====================================================================
         if self.app_card_config.enabled:
-            loading_task = asyncio.create_task(
-                self.app_card_provider.load_app_card(
-                    package_name=self.shared_state.current_package_name,
-                    instruction=self.shared_state.instruction
+            current_package = self.shared_state.current_package_name
+            current_instruction = self.shared_state.instruction
+
+            # Check if we need to start a new loading task
+            package_changed = current_package != self.shared_state._app_card_package
+            instruction_changed = current_instruction != self.shared_state._app_card_instruction
+
+            if package_changed or instruction_changed:
+                # Cancel old task if it exists and is still running (non-blocking)
+                if (self.shared_state.app_card_loading_task and
+                    not self.shared_state.app_card_loading_task.done()):
+                    self.shared_state.app_card_loading_task.cancel()
+
+                # Start new loading task
+                loading_task = asyncio.create_task(
+                    self.app_card_provider.load_app_card(
+                        package_name=current_package,
+                        instruction=current_instruction
+                    )
                 )
-            )
-            self.shared_state.app_card_loading_task = loading_task
-
+                self.shared_state.app_card_loading_task = loading_task
+                self.shared_state._app_card_package = current_package
+                self.shared_state._app_card_instruction = current_instruction
         # ====================================================================
         # Step 2: Capture screenshot if vision enabled
         # ====================================================================
@@ -433,6 +450,10 @@ class ManagerAgent(Workflow):
             except asyncio.TimeoutError:
                 # Task not ready yet, use empty string
                 self.shared_state.app_card = ""
+            except asyncio.CancelledError:
+                # Task was cancelled (app/instruction changed), use empty string
+                logger.debug("App card task was cancelled")
+                self.shared_state.app_card = ""
             except Exception as e:
                 logger.warning(f"Error getting app card: {e}")
                 self.shared_state.app_card = ""

{droidrun-0.3.10.dev8 → droidrun-0.3.10.dev10}/droidrun/agent/utils/executer.py

@@ -1,3 +1,4 @@
+import asyncio
 import contextlib
 import io
 import logging
@@ -109,7 +110,7 @@ class SimpleCodeExecutor:
 
         return output
 
-    async def execute(self, state: ExecuterState, code: str) -> str:
+    async def execute(self, state: ExecuterState, code: str, timeout: float = 10.0) -> str:
         """
         Execute Python code and capture output and return values.
 
@@ -118,6 +119,7 @@ class SimpleCodeExecutor:
         Args:
             state: ExecuterState containing ui_state and other execution context.
             code: Python code to execute
+            timeout: Maximum execution time in seconds (default: 30.0)
 
         Returns:
             str: Output from the execution, including print statements.
@@ -125,12 +127,16 @@ class SimpleCodeExecutor:
         # 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
+        try:
+            output = await asyncio.wait_for(
+                self.loop.run_in_executor(
+                    None,
+                    self._execute_in_thread,
+                    code,
+                    ui_state
+                ),
+                timeout=timeout
+            )
+            return output
+        except asyncio.TimeoutError:
+            return f"Error: Execution timed out after {timeout} seconds"

{droidrun-0.3.10.dev8 → droidrun-0.3.10.dev10}/droidrun/cli/main.py

@@ -300,6 +300,7 @@ async def run_command(
                 tracing_config=tracing_cfg,
                 excluded_tools=excluded_tools,
                 timeout=1000,
+                runtype="cli"
             )
 
             # ================================================================
@@ -563,7 +564,6 @@ def run(
                     device_obj.shell("ime disable com.droidrun.portal/.DroidrunKeyboardIME")
         except Exception:
             click.echo("Failed to disable DroidRun keyboard")
-            pass
 
 
 @cli.command()
@@ -624,7 +624,7 @@ def setup(path: str | None, device: str | None, debug: bool):
     """Install and enable the DroidRun Portal on a device."""
     from droidrun.config_manager.path_resolver import PathResolver
 
-    # Ensure config.yaml exists (check working dir, then project dir)
+    # Ensure config.yaml exists (check working dir, then package dir)
     try:
         config_path = PathResolver.resolve("config.yaml")
         console.print(f"[blue]Using existing config: {config_path}[/]")

{droidrun-0.3.10.dev8 → droidrun-0.3.10.dev10/droidrun}/config/app_cards/README.md

@@ -60,13 +60,15 @@ App cards support three path types:
    ```json
    {"com.google.gm": "gmail.md"}
    ```
-   Resolves to: `config/app_cards/gmail.md`
+   Resolves to: `config/app_cards/gmail.md` (in package)
 
-2. **Relative to project root**:
+2. **Relative paths with PathResolver**:
    ```json
    {"com.google.gm": "config/custom_cards/gmail.md"}
    ```
-   Resolves to: `config/custom_cards/gmail.md`
+   Checks working directory first, then package directory
+   - Working dir: `./config/custom_cards/gmail.md`
+   - Package dir: `<package>/config/custom_cards/gmail.md`
 
 3. **Absolute path**:
    ```json

{droidrun-0.3.10.dev8 → droidrun-0.3.10.dev10/droidrun}/config/prompts/codeact/system.jinja2

@@ -45,7 +45,6 @@ click(1)
 click(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:

{droidrun-0.3.10.dev8 → droidrun-0.3.10.dev10}/droidrun/config_manager/config_manager.py

@@ -431,7 +431,7 @@ class ConfigManager:
         # Resolution order:
         # 1) Explicit path arg
         # 2) DROIDRUN_CONFIG env var
-        # 3) Default "config.yaml" (checks working dir, then project dir)
+        # 3) Default "config.yaml" (checks working dir, then package dir)
         if path:
             self.path = PathResolver.resolve(path)
         else:
@@ -439,7 +439,7 @@ class ConfigManager:
             if env:
                 self.path = PathResolver.resolve(env)
             else:
-                # Default: checks CWD first, then project dir
+                # Default: checks CWD first, then package dir
                 self.path = PathResolver.resolve("config.yaml")
 
         # Initialize with default config