droidrun 0.3.10.dev11__tar.gz → 0.3.10.dev13__tar.gz

droidrun-0.3.10.dev13/.github/black.yml

@@ -0,0 +1,19 @@
+name: Lint
+
+on: [push, pull_request]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+      
+      - uses: psf/black@stable
+        with:
+          options: "--check --diff --verbose"
+          src: "."
+          version: "25.9.0"

{droidrun-0.3.10.dev11 → droidrun-0.3.10.dev13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: droidrun
-Version: 0.3.10.dev11
+Version: 0.3.10.dev13
 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.dev11 → droidrun-0.3.10.dev13}/droidrun/agent/codeact/codeact_agent.py

@@ -53,8 +53,10 @@ class CodeActAgent(Workflow):
         agent_config: AgentConfig,
         tools_instance: "Tools",
         custom_tools: dict = None,
+        atomic_tools: dict = None,
         debug: bool = False,
         shared_state: Optional["DroidAgentState"] = None,
+        safe_execution_config=None,
         *args,
         **kwargs,
     ):
@@ -77,8 +79,10 @@ class CodeActAgent(Workflow):
         self.goal = None
         self.code_exec_counter = 0
 
-        # Build tool list
-        merged_signatures = {**ATOMIC_ACTION_SIGNATURES, **(custom_tools or {})}
+        if atomic_tools is None:
+            atomic_tools = ATOMIC_ACTION_SIGNATURES
+
+        merged_signatures = {**atomic_tools, **(custom_tools or {})}
 
         self.tool_list = {}
         for action_name, signature in merged_signatures.items():
@@ -104,11 +108,20 @@ class CodeActAgent(Workflow):
         )
         self.system_prompt = ChatMessage(role="system", content=system_prompt_text)
 
+        # Get safety settings
+        safe_mode = self.config.safe_execution
+        safe_config = safe_execution_config
+
         self.executor = SimpleCodeExecutor(
             loop=asyncio.get_event_loop(),
             locals={},
             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,
         )
 
         logger.info("✅ CodeActAgent initialized successfully.")

{droidrun-0.3.10.dev11 → droidrun-0.3.10.dev13}/droidrun/agent/droid/droid_agent.py

@@ -7,9 +7,10 @@ Architecture:
 - When reasoning=True: Uses Manager (planning) + Executor (action) workflows
 """
 
+import asyncio
 import logging
 from typing import List
-
+from droidrun.agent.utils.tools import create_tools_from_config
 import llama_index.core
 from llama_index.core.llms.llm import LLM
 from llama_index.core.workflow import Context, StartEvent, StopEvent, Workflow, step
@@ -29,9 +30,13 @@ from droidrun.agent.droid.events import (
     FinalizeEvent,
     ManagerInputEvent,
     ManagerPlanEvent,
+    ScripterExecutorInputEvent,
+    ScripterExecutorResultEvent,
 )
 from droidrun.agent.executor import ExecutorAgent
 from droidrun.agent.manager import ManagerAgent
+from droidrun.agent.scripter import ScripterAgent
+from droidrun.agent.utils.async_utils import wrap_async_tools
 from droidrun.agent.utils.tools import ATOMIC_ACTION_SIGNATURES, open_app
 from droidrun.agent.utils.trajectory import Trajectory
 from droidrun.config_manager.config_manager import (
@@ -51,6 +56,7 @@ from droidrun.telemetry import (
 )
 from droidrun.telemetry.phoenix import arize_phoenix_callback_handler
 from droidrun.tools import Tools
+from droidrun.agent.utils.llm_loader import load_agent_llms, validate_llm_dict
 
 logger = logging.getLogger("droidrun")
 
@@ -89,9 +95,8 @@ class DroidAgent(Workflow):
     def __init__(
         self,
         goal: str,
-        llms: dict[str, LLM] | LLM,
-        tools: Tools,
         config: DroidRunConfig | None = None,
+        llms: dict[str, LLM] | LLM | None = None,
         agent_config: AgentConfig | None = None,
         device_config: DeviceConfig | None = None,
         tools_config: ToolsConfig | None = None,
@@ -109,9 +114,9 @@ class DroidAgent(Workflow):
 
         Args:
             goal: User's goal or command
-            llms: Dict of agent-specific LLMs or single LLM for all
-            tools: Tools instance (AdbTools or IOSTools)
-            config: Full config override (optional)
+            config: Full config (required if llms not provided)
+            llms: Optional dict of agent-specific LLMs or single LLM for all.
+                  If not provided, LLMs will be loaded from config profiles.
             agent_config: Agent config override (optional)
             device_config: Device config override (optional)
             tools_config: Tools config override (optional)
@@ -141,10 +146,31 @@ class DroidAgent(Workflow):
             llm_profiles=base_config.llm_profiles,
         )
 
+        # Create tools from config
+        tools = create_tools_from_config(self.config.device)
+
         super().__init__(*args, timeout=timeout, **kwargs)
 
         self._configure_default_logging(debug=self.config.logging.debug)
 
+        # Load LLMs if not provided
+        if llms is None:
+            if config is None:
+                raise ValueError(
+                    "Either 'llms' or 'config' must be provided. "
+                    "If llms is not provided, config is required to load LLMs from profiles."
+                )
+
+
+            logger.info("🔄 Loading LLMs from config (llms not provided)...")
+
+
+            llms = load_agent_llms(
+                config=self.config,
+                **kwargs
+            )
+        validate_llm_dict(self.config, llms)
+
         if self.config.tracing.enabled:
             try:
                 handler = arize_phoenix_callback_handler()
@@ -167,11 +193,7 @@ class DroidAgent(Workflow):
             self.codeact_llm = llms.get('codeact')
             self.text_manipulator_llm = llms.get('text_manipulator')
             self.app_opener_llm = llms.get('app_opener')
-
-            if self.config.agent.reasoning and (not self.manager_llm or not self.executor_llm):
-                raise ValueError("When reasoning=True, 'manager' and 'executor' LLMs must be provided in llms dict")
-            if not self.codeact_llm:
-                raise ValueError("'codeact' LLM must be provided in llms dict")
+            self.scripter_llm = llms.get('scripter', self.codeact_llm)
 
             logger.info("📚 Using agent-specific LLMs from dictionary")
         else:
@@ -181,6 +203,7 @@ class DroidAgent(Workflow):
             self.codeact_llm = llms
             self.text_manipulator_llm = llms
             self.app_opener_llm = llms
+            self.scripter_llm = llms
 
 
         self.trajectory = Trajectory(goal=self.shared_state.instruction)
@@ -188,12 +211,13 @@ class DroidAgent(Workflow):
         self.task_iter = None
         self.current_episodic_memory = None
 
+        self.atomic_tools = ATOMIC_ACTION_SIGNATURES.copy()
+
         open_app_tool = {
             "arguments": ["text"],
             "description": "Open an app by name. Usage example: {\"action\": \"open_app\", \"text\": \"the name of app\"}",
             "function": open_app,
         }
-        # Merge with user-provided custom tools
         self.custom_tools = {**self.custom_tools, "open_app": open_app_tool}
 
         logger.info("🤖 Initializing DroidAgent...")
@@ -201,8 +225,9 @@ class DroidAgent(Workflow):
 
         self.tools_instance = tools
         self.tools_instance.save_trajectories = self.config.logging.save_trajectory
-        # Set app_opener_llm on tools instance for open_app custom tool
+        # Set LLMs on tools instance for helper tools
         self.tools_instance.app_opener_llm = self.app_opener_llm
+        self.tools_instance.text_manipulator_llm = self.text_manipulator_llm
 
 
         if self.config.agent.reasoning:
@@ -289,8 +314,10 @@ class DroidAgent(Workflow):
                 agent_config=self.config.agent,
                 tools_instance=self.tools_instance,
                 custom_tools=self.custom_tools,
+                atomic_tools=self.atomic_tools,
                 debug=self.config.logging.debug,
                 shared_state=self.shared_state,
+                safe_execution_config=self.config.safe_execution,
                 timeout=self.timeout,
             )
 
@@ -356,6 +383,15 @@ class DroidAgent(Workflow):
         logger.info(f"🚀 Running DroidAgent to achieve goal: {self.shared_state.instruction}")
         ctx.write_event_to_stream(ev)
 
+        self.tools_instance._set_context(ctx)
+
+        if not hasattr(self, '_tools_wrapped') and not self.config.agent.reasoning:
+
+            self.atomic_tools = wrap_async_tools(self.atomic_tools)
+            self.custom_tools = wrap_async_tools(self.custom_tools)
+
+            self._tools_wrapped = True
+            logger.debug("✅ Async tools wrapped for synchronous execution contexts")
 
         if not self.config.agent.reasoning:
             logger.info(f"🔄 Direct execution mode - executing goal: {self.shared_state.instruction}")
@@ -416,11 +452,11 @@ class DroidAgent(Workflow):
         self,
         ctx: Context,
         ev: ManagerPlanEvent
-    ) -> ExecutorInputEvent | FinalizeEvent:
+    ) -> ExecutorInputEvent | ScripterExecutorInputEvent | FinalizeEvent:
         """
         Process Manager output and decide next step.
 
-        Checks if task is complete or if Executor should take action.
+        Checks if task is complete, if ScripterAgent should run, or if Executor should take action.
         """
         # Check for answer-type termination
         if ev.manager_answer.strip():
@@ -432,6 +468,21 @@ class DroidAgent(Workflow):
                 reason=ev.manager_answer
             )
 
+        # Check for <script> tag in current_subgoal, then extract from full plan
+        if '<script>' in ev.current_subgoal:
+            # Found script tag in subgoal - now search the entire plan
+            start_idx = ev.plan.find('<script>')
+            end_idx = ev.plan.find('</script>')
+
+            if start_idx != -1 and end_idx != -1 and end_idx > start_idx:
+                # Extract content between first <script> and first </script> in plan
+                task = ev.plan[start_idx + len('<script>'):end_idx].strip()
+                logger.info(f"🐍 Routing to ScripterAgent: {task[:80]}...")
+                return ScripterExecutorInputEvent(task=task)
+            else:
+                # <script> found in subgoal but not properly closed in plan - log warning
+                logger.warning("⚠️ Found <script> in subgoal but not properly closed in plan, treating as regular subgoal")
+
         # Continue to Executor with current subgoal
         logger.info(f"▶️  Proceeding to Executor with subgoal: {ev.current_subgoal}")
         return ExecutorInputEvent(current_subgoal=ev.current_subgoal)
@@ -507,7 +558,82 @@ class DroidAgent(Workflow):
         return ManagerInputEvent()
 
     # ========================================================================
-    # End Manager/Executor Workflow Steps
+    # Script Executor Workflow Steps
+    # ========================================================================
+
+    @step
+    async def run_scripter(
+        self,
+        ctx: Context,
+        ev: ScripterExecutorInputEvent
+    ) -> ScripterExecutorResultEvent:
+        """
+        Instantiate and run ScripterAgent for off-device operations.
+        """
+        logger.info(f"🐍 Starting ScripterAgent for task: {ev.task[:2000]}...")
+
+        # Create fresh ScripterAgent instance for this task
+        scripter_agent = ScripterAgent(
+            llm=self.scripter_llm,
+            agent_config=self.config.agent,
+            shared_state=self.shared_state,
+            task=ev.task,
+            safe_execution_config=self.config.safe_execution,
+            timeout=self.timeout
+        )
+
+        # Run ScripterAgent workflow
+        handler = scripter_agent.run()
+
+        # Stream nested events
+        async for nested_ev in handler.stream_events():
+            ctx.write_event_to_stream(nested_ev)
+
+        result = await handler
+
+        # Store in shared state
+        script_record = {
+            'task': ev.task,
+            'message': result['message'],
+            'success': result['success'],
+            'code_executions': result.get('code_executions', 0)
+        }
+        self.shared_state.scripter_history.append(script_record)
+        self.shared_state.last_scripter_message = result['message']
+        self.shared_state.last_scripter_success = result['success']
+
+        logger.info(f"🐍 ScripterAgent finished: {result['message'][:2000]}...")
+
+        return ScripterExecutorResultEvent(
+            task=ev.task,
+            message=result['message'],
+            success=result['success'],
+            code_executions=result.get('code_executions', 0)
+        )
+
+    @step
+    async def handle_scripter_result(
+        self,
+        ctx: Context,
+        ev: ScripterExecutorResultEvent
+    ) -> ManagerInputEvent:
+        """
+        Process ScripterAgent result and loop back to Manager.
+        """
+        if ev.success:
+            logger.info(f"✅ Script completed successfully in {ev.code_executions} steps")
+        else:
+            logger.warning(f"⚠️ Script failed or reached max steps: {ev.message}")
+
+        # Increment DroidAgent step counter
+        self.shared_state.step_number += 1
+        logger.info(f"🔄 Step {self.shared_state.step_number}/{self.config.agent.max_steps} complete, looping to Manager")
+
+        # Loop back to Manager (script result in shared_state)
+        return ManagerInputEvent()
+
+    # ========================================================================
+    # End Manager/Executor/Script Workflow Steps
     # ========================================================================
 
     @step
@@ -534,6 +660,8 @@ class DroidAgent(Workflow):
         if self.trajectory and self.config.logging.save_trajectory != "none":
             self.trajectory.save_trajectory()
 
+        self.tools_instance._set_context(None)
+
         return StopEvent(result)
 
     def handle_stream_event(self, ev: Event, ctx: Context):

{droidrun-0.3.10.dev11 → droidrun-0.3.10.dev13}/droidrun/agent/droid/events.py

@@ -103,6 +103,11 @@ class DroidAgentState(BaseModel):
     error_flag_plan: bool = False
     err_to_manager_thresh: int = 2
 
+    # Script execution tracking
+    scripter_history: List[Dict] = Field(default_factory=list)
+    last_scripter_message: str = ""
+    last_scripter_success: bool = True
+
     # Output
     output_dir: str = ""
 
@@ -179,3 +184,24 @@ class ExecutorResultEvent(Event):
     outcome: bool
     error: str
     summary: str
+
+
+# ============================================================================
+# Script executor coordination events
+# ============================================================================
+
+class ScripterExecutorInputEvent(Event):
+    """Trigger ScripterAgent workflow for off-device operations"""
+    task: str
+
+
+class ScripterExecutorResultEvent(Event):
+    """
+    Coordination event from ScripterAgent to DroidAgent.
+
+    Used for workflow step routing only (NOT streamed to frontend).
+    """
+    task: str
+    message: str  # Response from response() function
+    success: bool
+    code_executions: int

{droidrun-0.3.10.dev11 → droidrun-0.3.10.dev13}/droidrun/agent/executor/executor_agent.py

@@ -67,7 +67,12 @@ class ExecutorAgent(Workflow):
         self.vision = agent_config.executor.vision
         self.tools_instance = tools_instance
         self.shared_state = shared_state
-        self.custom_tools = custom_tools or {}
+
+        # Merge custom_tools with atomic actions (same as CodeActAgent)
+        atomic_tools = ATOMIC_ACTION_SIGNATURES
+        merged_signatures = {**atomic_tools, **(custom_tools or {})}
+        self.all_actions = merged_signatures  # Store merged dict for prompt
+        self.custom_tools = custom_tools or {}  # Keep for execution lookup
 
         logger.info("✅ ExecutorAgent initialized successfully.")
 
@@ -120,7 +125,7 @@ class ExecutorAgent(Workflow):
                 "plan": self.shared_state.plan,
                 "subgoal": subgoal,
                 "progress_status": self.shared_state.progress_status,
-                "atomic_actions": ATOMIC_ACTION_SIGNATURES,
+                "atomic_actions": self.all_actions,  # Now includes custom tools!
                 "action_history": action_history
             }
         )
@@ -296,7 +301,7 @@ class ExecutorAgent(Workflow):
                 if text is None:
                     return False, "Missing 'text' parameter", "Failed: open_app requires text"
 
-                result = open_app(self.tools_instance, text)
+                result = await open_app(self.tools_instance, text)
                 return True, "None", f"Opened app: {text}"
 
             else:

{droidrun-0.3.10.dev11 → droidrun-0.3.10.dev13}/droidrun/agent/manager/manager_agent.py

@@ -161,7 +161,9 @@ class ManagerAgent(Workflow):
                 "important_notes": "",  # TODO: implement
                 "error_history": error_history,
                 "text_manipulation_enabled": has_text_to_modify,
-                "custom_tools_descriptions": build_custom_tool_descriptions(self.custom_tools)
+                "custom_tools_descriptions": build_custom_tool_descriptions(self.custom_tools),
+                "scripter_execution_enabled": self.agent_config.scripter.enabled,
+                "scripter_max_steps": self.agent_config.scripter.max_steps,
             }
         )
 
@@ -219,6 +221,23 @@ class ManagerAgent(Workflow):
             if screenshot and self.vision:
                 messages[last_user_idx]['content'].append({"image": screenshot})
 
+            # Add script result if available
+            if self.shared_state.last_scripter_message:
+                status = "SUCCESS" if self.shared_state.last_scripter_success else "FAILED"
+                script_context = (
+                    f"\n<script_result status=\"{status}\">\n"
+                    f"{self.shared_state.last_scripter_message}\n"
+                    f"</script_result>\n"
+                )
+
+                if messages[last_user_idx]['content'] and 'text' in messages[last_user_idx]['content'][0]:
+                    messages[last_user_idx]['content'][0]['text'] += script_context
+                else:
+                    messages[last_user_idx]['content'].insert(0, {"text": script_context})
+
+                # Clear after injection (avoid duplicate injection)
+                self.shared_state.last_scripter_message = ""
+
             # Add PREVIOUS device state to SECOND-TO-LAST user message (if exists)
             if len(user_indices) >= 2:
                 second_last_user_idx = user_indices[-2]

{droidrun-0.3.10.dev11 → droidrun-0.3.10.dev13}/droidrun/agent/manager/prompts.py

@@ -17,6 +17,7 @@ def parse_manager_response(response: str) -> dict:
 
     Also derives:
     - current_subgoal: first line of plan (with list markers removed)
+    - If first item is <script> tag, extract script content as current_subgoal
 
     Args:
         response: Raw LLM response text
@@ -26,7 +27,7 @@ def parse_manager_response(response: str) -> dict:
             - thought: str
             - memory: str
             - plan: str
-            - current_subgoal: str (first line of plan, cleaned)
+            - current_subgoal: str (first line of plan, cleaned, or script content)
             - request_accomplished: str (from request_accomplished tag)
     """
     def extract(tag: str) -> str:
@@ -42,19 +43,27 @@ def parse_manager_response(response: str) -> dict:
 
     # Parse current subgoal from first line of plan
     current_goal_text = plan
-    # Prefer newline-separated plans; take the first non-empty line
-    plan_lines = [line.strip() for line in current_goal_text.splitlines() if line.strip()]
-    if plan_lines:
-        first_line = plan_lines[0]
+
+    # Check if first item is a <script> tag
+    script_match = re.search(r'^\s*<script>(.*?)</script>', current_goal_text, re.DOTALL)
+
+    if script_match:
+        # Script is first task - extract script content with tag
+        current_subgoal = f"<script>{script_match.group(1).strip()}</script>"
     else:
-        first_line = current_goal_text.strip()
+        # Regular subgoal - use existing logic
+        plan_lines = [line.strip() for line in current_goal_text.splitlines() if line.strip()]
+        if plan_lines:
+            first_line = plan_lines[0]
+        else:
+            first_line = current_goal_text.strip()
 
-    # Remove common list markers like "1.", "-", "*", or bullet characters
-    first_line = re.sub(r"^\s*\d+\.\s*", "", first_line)  # Remove "1. ", "2. ", etc.
-    first_line = re.sub(r"^\s*[-*]\s*", "", first_line)    # Remove "- " or "* "
-    first_line = re.sub(r"^\s*•\s*", "", first_line)      # Remove bullet "• "
+        # Remove common list markers like "1.", "-", "*", or bullet characters
+        first_line = re.sub(r"^\s*\d+\.\s*", "", first_line)  # Remove "1. ", "2. ", etc.
+        first_line = re.sub(r"^\s*[-*]\s*", "", first_line)    # Remove "- " or "* "
+        first_line = re.sub(r"^\s*•\s*", "", first_line)      # Remove bullet "• "
 
-    current_subgoal = first_line.strip()
+        current_subgoal = first_line.strip()
 
     return {
         "thought": thought,

droidrun-0.3.10.dev13/droidrun/agent/scripter/__init__.py

@@ -0,0 +1,7 @@
+"""
+ScripterAgent - ReAct agent for executing Python scripts (off-device operations).
+"""
+
+from droidrun.agent.scripter.scripter_agent import ScripterAgent
+
+__all__ = ["ScripterAgent"]

droidrun-0.3.10.dev13/droidrun/agent/scripter/events.py

@@ -0,0 +1,36 @@
+"""
+Events for ScripterAgent workflow.
+"""
+
+from typing import List, Optional
+
+from llama_index.core.workflow import Event
+
+
+class ScripterInputEvent(Event):
+    """Input to LLM (chat history)."""
+    input: List  # List of ChatMessages
+
+
+class ScripterThinkingEvent(Event):
+    """LLM generated thought + code."""
+    thoughts: str
+    code: Optional[str] = None
+    full_response: str = ""  # Full LLM response (for fallback when no code)
+
+
+class ScripterExecutionEvent(Event):
+    """Trigger code execution."""
+    code: str
+
+
+class ScripterExecutionResultEvent(Event):
+    """Code execution result."""
+    output: str
+
+
+class ScripterEndEvent(Event):
+    """Script agent finished."""
+    message: str  # Message to Manager
+    success: bool  # True if response() called, False if max_steps
+    code_executions: int = 0