droidrun 0.3.10.dev14__tar.gz → 0.4.0.dev1__tar.gz

{droidrun-0.3.10.dev14 → droidrun-0.4.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: droidrun
-Version: 0.3.10.dev14
+Version: 0.4.0.dev1
 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
@@ -30,6 +30,7 @@ Requires-Dist: adbutils>=2.10.2
 Requires-Dist: apkutils==2.0.0
 Requires-Dist: arize-phoenix>=12.3.0
 Requires-Dist: httpx>=0.27.0
+Requires-Dist: llama-index-callbacks-arize-phoenix>=0.6.1
 Requires-Dist: llama-index==0.14.4
 Requires-Dist: posthog>=6.7.6
 Requires-Dist: pydantic>=2.11.10

{droidrun-0.3.10.dev14 → droidrun-0.4.0.dev1}/droidrun/__main__.py

@@ -1,7 +1,8 @@
 """
 DroidRun main entry point
 """
+
 from droidrun.cli.main import cli
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     cli()

droidrun-0.4.0.dev1/droidrun/agent/__init__.py

@@ -0,0 +1,6 @@
+# import logging
+
+# logger = logging.getLogger("droidrun")
+# logger.propagate = False  # Don't send to root logger
+# logger.handlers = []      # No handlers by default
+# logger.setLevel(logging.INFO)  # Or WARNING

{droidrun-0.3.10.dev14 → droidrun-0.4.0.dev1}/droidrun/agent/codeact/__init__.py

@@ -1,5 +1,3 @@
 from droidrun.agent.codeact.codeact_agent import CodeActAgent
 
-__all__ = [
-    "CodeActAgent"
-]
+__all__ = ["CodeActAgent"]

{droidrun-0.3.10.dev14 → droidrun-0.4.0.dev1}/droidrun/agent/codeact/codeact_agent.py

@@ -93,7 +93,11 @@ class CodeActAgent(Workflow):
         for action_name, signature in merged_signatures.items():
             func = signature["function"]
 
-            self.tool_list[action_name] = lambda *args, f=func, ti=tools_instance, **kwargs: f(ti, *args, **kwargs)
+            self.tool_list[action_name] = (
+                lambda *args, f=func, ti=tools_instance, **kwargs: f(
+                    ti, *args, **kwargs
+                )
+            )
 
         self.tool_list["remember"] = tools_instance.remember
         self.tool_list["complete"] = tools_instance.complete
@@ -103,13 +107,17 @@ class CodeActAgent(Workflow):
         custom_descriptions = build_custom_tool_descriptions(custom_tools or {})
         if custom_descriptions:
             self.tool_descriptions += "\n" + custom_descriptions
-        self.tool_descriptions += "\n- remember(information: str): Remember information for later use"
-        self.tool_descriptions += "\n- complete(success: bool, reason: str): Mark task as complete"
+        self.tool_descriptions += (
+            "\n- remember(information: str): Remember information for later use"
+        )
+        self.tool_descriptions += (
+            "\n- complete(success: bool, reason: str): Mark task as complete"
+        )
 
         # Load prompts from config
         system_prompt_text = PromptLoader.load_prompt(
             agent_config.get_codeact_system_prompt_path(),
-            {"tool_descriptions": self.tool_descriptions}
+            {"tool_descriptions": self.tool_descriptions},
         )
         self.system_prompt = ChatMessage(role="system", content=system_prompt_text)
 
@@ -123,10 +131,22 @@ class CodeActAgent(Workflow):
             tools=self.tool_list,
             globals={"__builtins__": __builtins__},
             safe_mode=safe_mode,
-            allowed_modules=safe_config.get_allowed_modules() if safe_config and safe_mode else None,
-            blocked_modules=safe_config.get_blocked_modules() if safe_config and safe_mode else None,
-            allowed_builtins=safe_config.get_allowed_builtins() if safe_config and safe_mode else None,
-            blocked_builtins=safe_config.get_blocked_builtins() if safe_config and safe_mode else None,
+            allowed_modules=(
+                safe_config.get_allowed_modules() if safe_config and safe_mode else None
+            ),
+            blocked_modules=(
+                safe_config.get_blocked_modules() if safe_config and safe_mode else None
+            ),
+            allowed_builtins=(
+                safe_config.get_allowed_builtins()
+                if safe_config and safe_mode
+                else None
+            ),
+            blocked_builtins=(
+                safe_config.get_blocked_builtins()
+                if safe_config and safe_mode
+                else None
+            ),
         )
 
         logger.info("✅ CodeActAgent initialized successfully.")
@@ -136,7 +156,6 @@ class CodeActAgent(Workflow):
         """Prepare chat history from user input."""
         logger.info("💬 Preparing chat for task execution...")
 
-
         self.chat_memory: Memory = await ctx.store.get(
             "chat_memory", default=Memory.from_defaults()
         )
@@ -152,8 +171,7 @@ class CodeActAgent(Workflow):
 
         # Format user prompt with goal
         user_prompt_text = PromptLoader.load_prompt(
-            self.agent_config.get_codeact_user_prompt_path(),
-            {"goal": goal}
+            self.agent_config.get_codeact_user_prompt_path(), {"goal": goal}
         )
         self.user_message = ChatMessage(role="user", content=user_prompt_text)
 
@@ -165,7 +183,6 @@ The code you provided will be executed below.
 Now, describe the next step you will take to address the original goal: {goal}"""
         self.no_thoughts_prompt = ChatMessage(role="user", content=no_thoughts_text)
 
-
         await self.chat_memory.aput(self.user_message)
 
         await ctx.store.set("chat_memory", self.chat_memory)
@@ -195,7 +212,9 @@ Now, describe the next step you will take to address the original goal: {goal}""
 
         if "remember" in self.tool_list and self.remembered_info:
             await ctx.store.set("remembered_info", self.remembered_info)
-            chat_history = await chat_utils.add_memory_block(self.remembered_info, chat_history)
+            chat_history = await chat_utils.add_memory_block(
+                self.remembered_info, chat_history
+            )
 
         # Always capture screenshot for trajectory
         screenshot = (self.tools.take_screenshot())[1]
@@ -204,7 +223,9 @@ Now, describe the next step you will take to address the original goal: {goal}""
 
         # Add screenshot to chat only if vision enabled
         if self.vision and model != "DeepSeek":
-            chat_history = await chat_utils.add_screenshot_image_block(screenshot, chat_history)
+            chat_history = await chat_utils.add_screenshot_image_block(
+                screenshot, chat_history
+            )
 
         # Get and format device state using unified formatter
         try:
@@ -213,7 +234,9 @@ Now, describe the next step you will take to address the original goal: {goal}""
             raw_state = self.tools.get_state()
 
             # Format using unified function (returns 4 values)
-            formatted_text, focused_text, a11y_tree, phone_state = format_device_state(raw_state)
+            formatted_text, focused_text, a11y_tree, phone_state = format_device_state(
+                raw_state
+            )
 
             # Update shared_state if available
             assert self.shared_state is not None, "Shared state is not set"
@@ -224,8 +247,8 @@ Now, describe the next step you will take to address the original goal: {goal}""
 
             # 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')
+                package_name=phone_state.get("packageName", "Unknown"),
+                activity_name=phone_state.get("currentApp", "Unknown"),
             )
 
             # Stream formatted state for trajectory
@@ -233,7 +256,9 @@ Now, describe the next step you will take to address the original goal: {goal}""
 
             # Add device state to chat using new chat_utils function
             # This injects into LAST user message, doesn't create new message
-            chat_history = await chat_utils.add_device_state_block(formatted_text, chat_history)
+            chat_history = await chat_utils.add_device_state_block(
+                formatted_text, chat_history
+            )
 
         except Exception as e:
             logger.warning(f"⚠️ Error retrieving state from the connected device: {e}")
@@ -300,7 +325,9 @@ Now, describe the next step you will take to address the original goal: {goal}""
 
         try:
             self.code_exec_counter += 1
-            result = await self.executor.execute(ExecuterState(ui_state=ctx.store.get("ui_state", None)), code)
+            result = await self.executor.execute(
+                ExecuterState(ui_state=ctx.store.get("ui_state", None)), code
+            )
             logger.info(f"💡 Code execution successful. Result: {result}")
             await asyncio.sleep(self.agent_config.after_sleep_action)
 
@@ -309,8 +336,14 @@ Now, describe the next step you will take to address the original goal: {goal}""
                 logger.info("✅ Task marked as complete via complete() function")
 
                 # Validate completion state
-                success = self.tools.success if self.tools.success is not None else False
-                reason = self.tools.reason if self.tools.reason else "Task completed without reason"
+                success = (
+                    self.tools.success if self.tools.success is not None else False
+                )
+                reason = (
+                    self.tools.reason
+                    if self.tools.reason
+                    else "Task completed without reason"
+                )
 
                 # Reset finished flag for next execution
                 self.tools.finished = False
@@ -425,10 +458,9 @@ Now, describe the next step you will take to address the original goal: {goal}""
                 chat_history=chat_history_str,
                 response=response_str,
                 timestamp=time.time(),
-                screenshot=(await ctx.store.get("screenshot", None))
+                screenshot=(await ctx.store.get("screenshot", None)),
             )
 
-
             self.episodic_memory.steps.append(step)
 
             assert hasattr(
@@ -450,16 +482,17 @@ Now, describe the next step you will take to address the original goal: {goal}""
                     time.sleep(40)
                 logger.debug("🔍 Retrying call to LLM...")
                 response = await self.llm.achat(messages=messages_to_send)
-            elif (
-                self.llm.class_name() == "Anthropic_LLM"
-                and "overloaded_error" in str(e)
+            elif self.llm.class_name() == "Anthropic_LLM" and "overloaded_error" in str(
+                e
             ):
                 # Use exponential backoff for Anthropic errors
-                if not hasattr(self, '_anthropic_retry_count'):
+                if not hasattr(self, "_anthropic_retry_count"):
                     self._anthropic_retry_count = 0
                 self._anthropic_retry_count += 1
-                seconds = min(2 ** self._anthropic_retry_count, 60)  # Cap at 60 seconds
-                logger.error(f"Anthropic overload error. Retrying in {seconds} seconds... (attempt {self._anthropic_retry_count})")
+                seconds = min(2**self._anthropic_retry_count, 60)  # Cap at 60 seconds
+                logger.error(
+                    f"Anthropic overload error. Retrying in {seconds} seconds... (attempt {self._anthropic_retry_count})"
+                )
                 time.sleep(seconds)
                 logger.debug("🔍 Retrying call to LLM...")
                 response = await self.llm.achat(messages=messages_to_send)
@@ -470,9 +503,7 @@ Now, describe the next step you will take to address the original goal: {goal}""
         logger.debug("  - Received response from LLM.")
         return response
 
-    def _limit_history(
-        self, chat_history: List[ChatMessage]
-    ) -> List[ChatMessage]:
+    def _limit_history(self, chat_history: List[ChatMessage]) -> List[ChatMessage]:
         if LLM_HISTORY_LIMIT <= 0:
             return chat_history
 
@@ -510,10 +541,15 @@ Now, describe the next step you will take to address the original goal: {goal}""
                 raise Exception(f"Failed to capture final UI state: {e}") from e
 
             # Create final observation chat history and response
-            final_chat_history = [{"role": "system", "content": "Final state observation after task completion"}]
+            final_chat_history = [
+                {
+                    "role": "system",
+                    "content": "Final state observation after task completion",
+                }
+            ]
             final_response = {
                 "role": "user",
-                "content": f"Final State Observation:\nUI State: {a11y_tree}\nScreenshot: {'Available' if screenshot else 'Not available'}"
+                "content": f"Final State Observation:\nUI State: {a11y_tree}\nScreenshot: {'Available' if screenshot else 'Not available'}",
             }
 
             # Create final episodic memory step
@@ -521,7 +557,7 @@ Now, describe the next step you will take to address the original goal: {goal}""
                 chat_history=json.dumps(final_chat_history),
                 response=json.dumps(final_response),
                 timestamp=time.time(),
-                screenshot=screenshot
+                screenshot=screenshot,
             )
 
             self.episodic_memory.steps.append(final_step)

{droidrun-0.3.10.dev14 → droidrun-0.4.0.dev1}/droidrun/agent/codeact/events.py

@@ -11,23 +11,26 @@ class TaskInputEvent(Event):
     input: list[ChatMessage]
 
 
-
 class TaskThinkingEvent(Event):
     thoughts: Optional[str] = None
     code: Optional[str] = None
     usage: Optional[UsageResult] = None
 
+
 class TaskExecutionEvent(Event):
     code: str
     globals: dict[str, str] = {}
     locals: dict[str, str] = {}
 
+
 class TaskExecutionResultEvent(Event):
     output: str
 
+
 class TaskEndEvent(Event):
     success: bool
     reason: str
 
+
 class EpisodicMemoryEvent(Event):
     episodic_memory: EpisodicMemory

{droidrun-0.3.10.dev14 → droidrun-0.4.0.dev1}/droidrun/agent/common/constants.py

@@ -1,2 +1,3 @@
 """Max number of recent conversation steps to include in LLM prompt"""
+
 LLM_HISTORY_LIMIT = 20

{droidrun-0.3.10.dev14 → droidrun-0.4.0.dev1}/droidrun/agent/common/events.py

@@ -6,48 +6,63 @@ from llama_index.core.workflow import Event
 class ScreenshotEvent(Event):
     screenshot: bytes
 
+
 class MacroEvent(Event):
     """Base class for coordinate-based action events"""
+
     action_type: str
     description: str
 
+
 class TapActionEvent(MacroEvent):
     """Event for tap actions with coordinates"""
+
     x: int
     y: int
     element_index: int = None
     element_text: str = ""
     element_bounds: str = ""
 
+
 class SwipeActionEvent(MacroEvent):
     """Event for swipe actions with coordinates"""
+
     start_x: int
     start_y: int
     end_x: int
     end_y: int
     duration_ms: int
 
+
 class DragActionEvent(MacroEvent):
     """Event for drag actions with coordinates"""
+
     start_x: int
     start_y: int
     end_x: int
     end_y: int
     duration_ms: int
 
+
 class InputTextActionEvent(MacroEvent):
     """Event for text input actions"""
+
     text: str
 
+
 class KeyPressActionEvent(MacroEvent):
     """Event for key press actions"""
+
     keycode: int
     key_name: str = ""
 
+
 class StartAppEvent(MacroEvent):
-    """"Event for starting an app"""
+    """ "Event for starting an app"""
+
     package: str
     activity: str = None
 
+
 class RecordUIStateEvent(Event):
     ui_state: list[Dict[str, Any]]

{droidrun-0.3.10.dev14 → droidrun-0.4.0.dev1}/droidrun/agent/context/__init__.py

@@ -9,9 +9,4 @@ This module contains:
 from droidrun.agent.context.episodic_memory import EpisodicMemory, EpisodicMemoryStep
 from droidrun.agent.context.task_manager import Task, TaskManager
 
-__all__ = [
-    "EpisodicMemory",
-    "EpisodicMemoryStep",
-    "TaskManager",
-    "Task"
-]
+__all__ = ["EpisodicMemory", "EpisodicMemoryStep", "TaskManager", "Task"]

{droidrun-0.3.10.dev14 → droidrun-0.4.0.dev1}/droidrun/agent/context/task_manager.py

@@ -10,6 +10,7 @@ class Task:
     """
     Represents a single task with its properties.
     """
+
     description: str
     status: str
     agent_type: str
@@ -22,15 +23,13 @@ class TaskManager:
     """
     Manages a list of tasks for an agent, each with a status and assigned specialized agent.
     """
+
     STATUS_PENDING = "pending"
     STATUS_COMPLETED = "completed"
     STATUS_FAILED = "failed"
 
-    VALID_STATUSES = {
-        STATUS_PENDING,
-        STATUS_COMPLETED,
-        STATUS_FAILED
-    }
+    VALID_STATUSES = {STATUS_PENDING, STATUS_COMPLETED, STATUS_FAILED}
+
     def __init__(self):
         """Initializes an empty task list."""
         self.tasks: List[Task] = []
@@ -38,7 +37,9 @@ class TaskManager:
         self.message = None
         self.task_history = []
         # Save to working directory for user visibility
-        self.file_path = PathResolver.resolve("droidrun_tasks.txt", create_if_missing=True)
+        self.file_path = PathResolver.resolve(
+            "droidrun_tasks.txt", create_if_missing=True
+        )
 
     def get_all_tasks(self) -> List[Task]:
         return self.tasks
@@ -66,19 +67,20 @@ class TaskManager:
         self.task_history.append(task)
 
     def get_completed_tasks(self) -> list[dict]:
-        return [task for task in self.task_history if task.status == self.STATUS_COMPLETED]
+        return [
+            task for task in self.task_history if task.status == self.STATUS_COMPLETED
+        ]
 
     def get_failed_tasks(self) -> list[dict]:
         return [task for task in self.task_history if task.status == self.STATUS_FAILED]
 
-
     def save_to_file(self):
         """Saves the current task list to a text file."""
         try:
             # Ensure parent directory exists
             self.file_path.parent.mkdir(parents=True, exist_ok=True)
 
-            with open(self.file_path, 'w', encoding='utf-8') as f:
+            with open(self.file_path, "w", encoding="utf-8") as f:
                 for i, task in enumerate(self.tasks, 1):
                     f.write(f"Task {i}: {task.description}\n")
                     f.write(f"Status: {task.status}\n")
@@ -87,8 +89,6 @@ class TaskManager:
         except Exception as e:
             print(f"Error saving tasks to file: {e}")
 
-
-
     def set_tasks_with_agents(self, task_assignments: List[Dict[str, str]]):
         """
         Clears the current task list and sets new tasks with their assigned agents.
@@ -107,19 +107,26 @@ class TaskManager:
         try:
             self.tasks = []
             for i, assignment in enumerate(task_assignments):
-                if not isinstance(assignment, dict) or 'task' not in assignment:
-                    raise ValueError(f"Each task assignment must be a dictionary with 'task' key at index {i}.")
-
-                task_description = assignment['task']
-                if not isinstance(task_description, str) or not task_description.strip():
-                    raise ValueError(f"Task description must be a non-empty string at index {i}.")
-
-                agent_type = assignment.get('agent', 'Default')
+                if not isinstance(assignment, dict) or "task" not in assignment:
+                    raise ValueError(
+                        f"Each task assignment must be a dictionary with 'task' key at index {i}."
+                    )
+
+                task_description = assignment["task"]
+                if (
+                    not isinstance(task_description, str)
+                    or not task_description.strip()
+                ):
+                    raise ValueError(
+                        f"Task description must be a non-empty string at index {i}."
+                    )
+
+                agent_type = assignment.get("agent", "Default")
 
                 task_obj = Task(
                     description=task_description.strip(),
                     status=self.STATUS_PENDING,
-                    agent_type=agent_type
+                    agent_type=agent_type,
                 )
 
                 self.tasks.append(task_obj)

{droidrun-0.3.10.dev14 → droidrun-0.4.0.dev1}/droidrun/agent/droid/__init__.py

@@ -7,7 +7,4 @@ This module provides a ReAct agent for automating Android devices using reasonin
 from droidrun.agent.codeact.codeact_agent import CodeActAgent
 from droidrun.agent.droid.droid_agent import DroidAgent
 
-__all__ = [
-    "CodeActAgent",
-    "DroidAgent"
-]
+__all__ = ["CodeActAgent", "DroidAgent"]