droidrun 0.3.1__py3-none-any.whl → 0.3.2__py3-none-any.whl

droidrun/__init__.py

@@ -5,26 +5,17 @@ DroidRun - A framework for controlling Android devices through LLM agents.
 __version__ = "0.3.0"
 
 # Import main classes for easier access
-from droidrun.agent.codeact.codeact_agent import CodeActAgent
-from droidrun.agent.planner.planner_agent import PlannerAgent
-from droidrun.agent.utils.executer import SimpleCodeExecutor
 from droidrun.agent.utils.llm_picker import load_llm
 from droidrun.adb.manager import DeviceManager
-from droidrun.tools.tools import Tools
-from droidrun.tools.adb import AdbTools
-from droidrun.tools.ios import IOSTools
+from droidrun.tools import Tools, AdbTools, IOSTools
 from droidrun.agent.droid import DroidAgent
 
 
 # Make main components available at package level
 __all__ = [
     "DroidAgent",
-    "CodeActAgent",
-    "PlannerAgent",
     "DeviceManager",
-    "Tools",
     "load_llm",
-    "SimpleCodeExecutor",
     "Tools",
     "AdbTools",
     "IOSTools",

droidrun/adb/device.py

@@ -10,12 +10,13 @@ import string
 from typing import Dict, Optional, Tuple, List
 from droidrun.adb.wrapper import ADBWrapper
 
+
 class Device:
     """High-level representation of an Android device."""
 
     def __init__(self, serial: str, adb: ADBWrapper):
         """Initialize device.
-        
+
         Args:
             serial: Device serial number
             adb: ADB wrapper instance
@@ -60,9 +61,13 @@ class Device:
         """Get SDK level."""
         return await self.get_property("ro.build.version.sdk")
 
+    async def shell(self, command: str, timeout: float | None = None) -> str:
+        """Execute a shell command on the device."""
+        return await self._adb.shell(self._serial, command, timeout)
+
     async def tap(self, x: int, y: int) -> None:
         """Tap at coordinates.
-        
+
         Args:
             x: X coordinate
             y: Y coordinate
@@ -70,15 +75,10 @@ class Device:
         await self._adb.shell(self._serial, f"input tap {x} {y}")
 
     async def swipe(
-        self,
-        start_x: int,
-        start_y: int,
-        end_x: int,
-        end_y: int,
-        duration_ms: int = 300
+        self, start_x: int, start_y: int, end_x: int, end_y: int, duration_ms: int = 300
     ) -> None:
         """Perform swipe gesture.
-        
+
         Args:
             start_x: Starting X coordinate
             start_y: Starting Y coordinate
@@ -88,12 +88,12 @@ class Device:
         """
         await self._adb.shell(
             self._serial,
-            f"input swipe {start_x} {start_y} {end_x} {end_y} {duration_ms}"
+            f"input swipe {start_x} {start_y} {end_x} {end_y} {duration_ms}",
         )
 
     async def input_text(self, text: str) -> None:
         """Input text.
-        
+
         Args:
             text: Text to input
         """
@@ -101,7 +101,7 @@ class Device:
 
     async def press_key(self, keycode: int) -> None:
         """Press a key.
-        
+
         Args:
             keycode: Android keycode to press
         """
@@ -111,10 +111,10 @@ class Device:
         self,
         package: str,
         activity: str = ".MainActivity",
-        extras: Optional[Dict[str, str]] = None
+        extras: Optional[Dict[str, str]] = None,
     ) -> None:
         """Start an app activity.
-        
+
         Args:
             package: Package name
             activity: Activity name
@@ -125,48 +125,56 @@ class Device:
             for key, value in extras.items():
                 cmd += f" -e {key} {value}"
         await self._adb.shell(self._serial, cmd)
-        
+
     async def start_app(self, package: str, activity: str = "") -> str:
         """Start an app on the device.
-        
+
         Args:
             package: Package name
             activity: Optional activity name (if empty, launches default activity)
-            
+
         Returns:
             Result message
         """
         if activity:
             if not activity.startswith(".") and "." not in activity:
                 activity = f".{activity}"
-                
-            if not activity.startswith(".") and "." in activity and not activity.startswith(package):
+
+            if (
+                not activity.startswith(".")
+                and "." in activity
+                and not activity.startswith(package)
+            ):
                 # Fully qualified activity name
                 component = activity.split("/", 1)
-                return await self.start_activity(component[0], component[1] if len(component) > 1 else activity)
-                
+                return await self.start_activity(
+                    component[0], component[1] if len(component) > 1 else activity
+                )
+
             # Relative activity name
             return await self.start_activity(package, activity)
-            
+
         # Start main activity using monkey
         cmd = f"monkey -p {package} -c android.intent.category.LAUNCHER 1"
         result = await self._adb.shell(self._serial, cmd)
         return f"Started {package}"
-        
-    async def install_app(self, apk_path: str, reinstall: bool = False, grant_permissions: bool = True) -> str:
+
+    async def install_app(
+        self, apk_path: str, reinstall: bool = False, grant_permissions: bool = True
+    ) -> str:
         """Install an APK on the device.
-        
+
         Args:
             apk_path: Path to the APK file
             reinstall: Whether to reinstall if app exists
             grant_permissions: Whether to grant all requested permissions
-            
+
         Returns:
             Installation result
         """
         if not os.path.exists(apk_path):
             return f"Error: APK file not found: {apk_path}"
-            
+
         # Build install command args
         install_args = ["install"]
         if reinstall:
@@ -174,28 +182,28 @@ class Device:
         if grant_permissions:
             install_args.append("-g")
         install_args.append(apk_path)
-        
+
         try:
             stdout, stderr = await self._adb._run_device_command(
                 self._serial,
                 install_args,
-                timeout=120  # Longer timeout for installation
+                timeout=120,  # Longer timeout for installation
             )
-            
+
             if "success" in stdout.lower():
                 return f"Successfully installed {os.path.basename(apk_path)}"
             return f"Installation failed: {stdout or stderr}"
-            
+
         except Exception as e:
             return f"Installation failed: {str(e)}"
-            
+
     async def uninstall_app(self, package: str, keep_data: bool = False) -> str:
         """Uninstall an app from the device.
-        
+
         Args:
             package: Package name to uninstall
             keep_data: Whether to keep app data and cache directories
-            
+
         Returns:
             Uninstallation result
         """
@@ -203,41 +211,42 @@ class Device:
         if keep_data:
             cmd.append("-k")
         cmd.append(package)
-        
+
         result = await self._adb.shell(self._serial, " ".join(cmd))
         return result.strip()
-        
+
     async def take_screenshot(self, quality: int = 75) -> Tuple[str, bytes]:
         """Take a screenshot of the device and compress it.
-        
+
         Args:
             quality: JPEG quality (1-100, lower means smaller file size)
-        
+
         Returns:
             Tuple of (local file path, screenshot data as bytes)
         """
         # Create a temporary file for the screenshot
         with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as temp:
             screenshot_path = temp.name
-            
+
         try:
             # Generate a random filename for the device
             timestamp = int(time.time())
-            random_suffix = "".join(random.choices(string.ascii_lowercase + string.digits, k=8))
+            random_suffix = "".join(
+                random.choices(string.ascii_lowercase + string.digits, k=8)
+            )
             device_path = f"/sdcard/screenshot_{timestamp}_{random_suffix}.png"
-            
+
             # Take screenshot using screencap command
             await self._adb.shell(self._serial, f"screencap -p {device_path}")
-            
+
             # Pull screenshot to local machine
             await self._adb._run_device_command(
-                self._serial,
-                ["pull", device_path, screenshot_path]
+                self._serial, ["pull", device_path, screenshot_path]
             )
-            
+
             # Clean up on device
             await self._adb.shell(self._serial, f"rm {device_path}")
-            
+
             # Read the screenshot file
             with open(screenshot_path, "rb") as f:
                 screenshot_data = f.read()
@@ -249,12 +258,14 @@ class Device:
 
                 # Create buffer for the compressed image
                 buffer = io.BytesIO()
-                
+
                 # Load the PNG data into a PIL Image
                 with Image.open(io.BytesIO(screenshot_data)) as img:
                     # Convert to RGB (removing alpha channel if present) and save as JPEG
                     converted_img = img.convert("RGB") if img.mode == "RGBA" else img
-                    converted_img.save(buffer, format="JPEG", quality=quality, optimize=True)
+                    converted_img.save(
+                        buffer, format="JPEG", quality=quality, optimize=True
+                    )
                     compressed_data = buffer.getvalue()
 
                 # Get size reduction info for logging
@@ -263,6 +274,7 @@ class Device:
                 reduction = 100 - (jpg_size / png_size * 100) if png_size > 0 else 0
 
                 import logging
+
                 logger = logging.getLogger("droidrun")
                 logger.debug(
                     f"Screenshot compressed successfully: {png_size:.1f}KB → {jpg_size:.1f}KB ({reduction:.1f}% reduction)"
@@ -275,9 +287,11 @@ class Device:
                 return screenshot_path, screenshot_data
             except Exception as e:
                 # If compression fails, return the original PNG data
-                logger.warning(f"Screenshot compression failed: {e}, returning uncompressed")
+                logger.warning(
+                    f"Screenshot compression failed: {e}, returning uncompressed"
+                )
                 return screenshot_path, screenshot_data
-            
+
         except Exception as e:
             # Clean up in case of error
             try:
@@ -285,31 +299,47 @@ class Device:
             except OSError:
                 pass
             raise RuntimeError(f"Screenshot capture failed: {str(e)}")
-            
-    async def list_packages(self, include_system_apps: bool = False) -> List[Dict[str, str]]:
-        """List installed packages on the device.
         
+    def _parse_package_list(self, output: str) -> List[Dict[str, str]]:
+        """Parse the output of 'pm list packages -f' command.
+
+        Args:
+            output: Raw command output from 'pm list packages -f'
+
+        Returns:
+            List of dictionaries containing package info with 'package' and 'path' keys
+        """
+        apps = []
+        for line in output.splitlines():
+            if line.startswith("package:"):
+                # Format is: "package:/path/to/base.apk=com.package.name"
+                path_and_pkg = line[8:]  # Strip "package:"
+                if "=" in path_and_pkg:
+                    path, package = path_and_pkg.rsplit("=", 1)
+                    apps.append({"package": package.strip(), "path": path.strip()})
+        return apps
+
+    async def list_packages(self, include_system_apps: bool = False) -> List[str]:
+        """
+        List installed packages on the device.
+
         Args:
-            include_system_apps: Whether to include system apps
-            
+            include_system_apps: Whether to include system apps (default: False)
+
         Returns:
-            List of package dictionaries with 'package' and 'path' keys
+            List of package names
         """
+        # Use the direct ADB command to get packages with paths
         cmd = ["pm", "list", "packages", "-f"]
         if not include_system_apps:
             cmd.append("-3")
-            
-        output = await self._adb.shell(self._serial, " ".join(cmd))
-        
-        packages = []
-        for line in output.splitlines():
-            if line.startswith("package:"):
-                parts = line[8:].split("=")
-                if len(parts) == 2:
-                    path, package = parts
-                    packages.append({
-                        "package": package,
-                        "path": path
-                    })
-                    
-        return packages 
+
+        output = await self.shell(" ".join(cmd))
+
+        # Parse the package list using the function
+        packages = self._parse_package_list(output)
+        # Format package list for better readability
+        package_list = [pack["package"] for pack in packages]
+        #for package in package_list:
+        #    print(package)
+        return package_list

droidrun/adb/manager.py

@@ -42,7 +42,7 @@ class DeviceManager:
                 
         return list(self._devices.values())
 
-    async def get_device(self, serial: str) -> Optional[Device]:
+    async def get_device(self, serial: str | None = None) -> Optional[Device]:
         """Get a specific device.
         
         Args:
@@ -51,13 +51,13 @@ class DeviceManager:
         Returns:
             Device instance if found, None otherwise
         """
-        if serial in self._devices:
+        if serial and serial in self._devices:
             return self._devices[serial]
             
         # Try to find the device
         devices = await self.list_devices()
         for device in devices:
-            if device.serial == serial:
+            if device.serial == serial or not serial:
                 return device
                 
         return None

droidrun/agent/codeact/codeact_agent.py

@@ -312,6 +312,7 @@ class CodeActAgent(Workflow):
             {
                 "success": ev.success,
                 "reason": ev.reason,
+                "output": ev.reason,
                 "codeact_steps": self.steps_counter,
                 "code_executions": self.code_exec_counter,
             }
@@ -321,7 +322,7 @@ class CodeActAgent(Workflow):
             EpisodicMemoryEvent(episodic_memory=self.episodic_memory)
         )
 
-        return StopEvent(result=result)
+        return StopEvent(result)
 
     async def _get_llm_response(
         self, ctx: Context, chat_history: List[ChatMessage]

droidrun/agent/context/personas/__init__.py

@@ -1,11 +1,9 @@
 from .default import DEFAULT
 from .ui_expert import UI_EXPERT
 from .app_starter import APP_STARTER_EXPERT
-from .extractor import EXTRACTOR
 
 __all__ = [
     'DEFAULT',
     'UI_EXPERT',
     'APP_STARTER_EXPERT',
-    'EXTRACTOR'
     ]

droidrun/agent/droid/droid_agent.py

@@ -8,6 +8,7 @@ from typing import List
 
 from llama_index.core.llms.llm import LLM
 from llama_index.core.workflow import step, StartEvent, StopEvent, Workflow, Context
+from llama_index.core.workflow.handler import WorkflowHandler
 from droidrun.agent.droid.events import *
 from droidrun.agent.codeact import CodeActAgent
 from droidrun.agent.codeact.events import EpisodicMemoryEvent
@@ -21,6 +22,7 @@ from droidrun.agent.context import ContextInjectionManager
 from droidrun.agent.context.agent_persona import AgentPersona
 from droidrun.agent.context.personas import DEFAULT
 from droidrun.agent.oneflows.reflector import Reflector
+from droidrun.telemetry import capture, flush, DroidAgentInitEvent, DroidAgentFinalizeEvent
 
 
 logger = logging.getLogger("droidrun")
@@ -86,7 +88,6 @@ A wrapper class that coordinates between PlannerAgent (creates plans) and
             **kwargs: Additional keyword arguments to pass to the agents
         """
         super().__init__(timeout=timeout ,*args,**kwargs)
-        
         # Configure default logging if not already configured
         self._configure_default_logging(debug=debug)
         
@@ -146,8 +147,32 @@ A wrapper class that coordinates between PlannerAgent (creates plans) and
         else:
             logger.debug("🚫 Planning disabled - will execute tasks directly with CodeActAgent")
             self.planner_agent = None
+
+        capture(
+            DroidAgentInitEvent(
+                goal=goal,
+                llm=llm.class_name(),
+                tools=",".join(self.tool_list),
+                personas=",".join([p.name for p in personas]),
+                max_steps=max_steps,
+                timeout=timeout,
+                vision=vision,
+                reasoning=reasoning,
+                reflection=reflection,
+                enable_tracing=enable_tracing,
+                debug=debug,
+                save_trajectories=save_trajectories,
+            )
+        )
+
         
         logger.info("✅ DroidAgent initialized successfully.")
+
+    def run(self) -> WorkflowHandler:
+        """
+        Run the DroidAgent workflow.
+        """
+        return super().run()
     
     @step
     async def execute_task(
@@ -211,7 +236,7 @@ A wrapper class that coordinates between PlannerAgent (creates plans) and
         try:
             task = ev.task
             if not self.reasoning:
-                return FinalizeEvent(success=ev.success, reason=ev.reason, task=[task], steps=ev.steps)
+                return FinalizeEvent(success=ev.success, reason=ev.reason, output=ev.reason, task=[task], tasks=[task], steps=ev.steps)
             
             if self.reflection:
                 return ReflectionEvent(task=task)
@@ -223,7 +248,8 @@ A wrapper class that coordinates between PlannerAgent (creates plans) and
             if self.debug:
                 import traceback
                 logger.error(traceback.format_exc())
-            return FinalizeEvent(success=False, reason=str(e), task=self.task_manager.get_task_history(), steps=self.step_counter)
+            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
@@ -259,7 +285,9 @@ A wrapper class that coordinates between PlannerAgent (creates plans) and
         ) -> FinalizeEvent | CodeActExecuteEvent:
         try:
             if self.step_counter >= self.max_steps:
-                return FinalizeEvent(success=False, reason=f"Reached maximum number of steps ({self.max_steps})", task=self.task_manager.get_task_history(), steps=self.step_counter)
+                output = f"Reached maximum number of steps ({self.max_steps})"
+                tasks = self.task_manager.get_task_history()
+                return FinalizeEvent(success=False, reason=output, output=output, task=tasks, tasks=tasks, steps=self.step_counter)
             self.step_counter += 1
 
             if ev.reflection:
@@ -286,10 +314,13 @@ A wrapper class that coordinates between PlannerAgent (creates plans) and
 
             if self.task_manager.goal_completed:
                 logger.info(f"✅ Goal completed: {self.task_manager.message}")
-                return FinalizeEvent(success=True, reason=self.task_manager.message, task=self.task_manager.get_task_history(), steps=self.step_counter)
+                tasks = self.task_manager.get_task_history()
+                return FinalizeEvent(success=True, reason=self.task_manager.message, output=self.task_manager.message, task=tasks, tasks=tasks, steps=self.step_counter)
             if not self.tasks:
                 logger.warning("No tasks generated by planner")
-                return FinalizeEvent(success=False, reason="Planner did not generate any tasks", task=self.task_manager.get_task_history(), steps=self.step_counter)
+                output = "Planner did not generate any tasks"
+                tasks = self.task_manager.get_task_history()
+                return FinalizeEvent(success=False, reason=output, output=output, task=tasks, tasks=tasks, steps=self.step_counter)
             
             return CodeActExecuteEvent(task=next(self.task_iter), reflection=None)
         
@@ -298,7 +329,8 @@ A wrapper class that coordinates between PlannerAgent (creates plans) and
             if self.debug:
                 import traceback
                 logger.error(traceback.format_exc())
-            return FinalizeEvent(success=False, reason=str(e), task=self.task_manager.get_task_history(), steps=self.step_counter)
+            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
@@ -331,10 +363,21 @@ A wrapper class that coordinates between PlannerAgent (creates plans) and
     @step
     async def finalize(self, ctx: Context, ev: FinalizeEvent) -> StopEvent:
         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,
+            )
+        )
+        flush()
 
         result = {
             "success": ev.success,
+            # deprecated. use output instead.
             "reason": ev.reason,
+            "output": ev.output,
             "steps": ev.steps,
         }
 

droidrun/agent/droid/events.py

@@ -16,8 +16,12 @@ class ReasoningLogicEvent(Event):
 
 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):

droidrun/agent/utils/llm_picker.py

@@ -31,6 +31,7 @@ def load_llm(provider_name: str, **kwargs: Any) -> LLM:
         raise ValueError("provider_name cannot be empty.")
     if provider_name == "OpenAILike":
         module_provider_part = "openai_like"
+        kwargs.setdefault("is_chat_model", True)
     elif provider_name == "GoogleGenAI":
         module_provider_part = "google_genai"
     else: