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

droidrun/config_manager/config_manager.py

@@ -2,10 +2,14 @@ from __future__ import annotations
 
 import os
 import threading
-import yaml
+from dataclasses import asdict, dataclass, field
 from pathlib import Path
-from typing import Any, Callable, Optional, Dict
-from dataclasses import dataclass, field, asdict
+from typing import Any, Callable, Dict, List, Optional
+
+import yaml
+
+from droidrun.config_manager.path_resolver import PathResolver
+
 
 # ---------- Helpers / defaults ----------
 def _default_config_text() -> str:
@@ -17,13 +21,44 @@ def _default_config_text() -> str:
 agent:
   # Maximum number of steps per task
   max_steps: 15
-  # Enable vision capabilities per agent (screenshots)
-  vision:
-    manager: false
-    executor: false
-    codeact: false
   # Enable planning with reasoning mode
   reasoning: false
+  # Sleep duration after each action, waits for ui state to be updated (seconds)
+  after_sleep_action: 1.0
+  # Wait duration for UI to stabilize (seconds)
+  wait_for_stable_ui: 0.3
+  # Base directory for prompt templates
+  prompts_dir: config/prompts
+
+  # CodeAct Agent Configuration
+  codeact:
+    # Enable vision capabilities (screenshots)
+    vision: false
+    # System prompt filename (located in prompts_dir/codeact/)
+    system_prompt: system.md
+    # User prompt filename (located in prompts_dir/codeact/)
+    user_prompt: user.md
+
+  # Manager Agent Configuration
+  manager:
+    # Enable vision capabilities (screenshots)
+    vision: false
+    # System prompt filename (located in prompts_dir/manager/)
+    system_prompt: system.md
+
+  # Executor Agent Configuration
+  executor:
+    # Enable vision capabilities (screenshots)
+    vision: false
+    # System prompt filename (located in prompts_dir/executor/)
+    system_prompt: system.md
+
+  # App Cards Configuration
+  app_cards:
+    # Enable app-specific instruction cards
+    enabled: true
+    # Directory containing app card files
+    app_cards_dir: config/app_cards
 
 # === LLM Profiles ===
 # Define LLM configurations for each agent type
@@ -35,7 +70,7 @@ llm_profiles:
     temperature: 0.2
     kwargs:
       max_tokens: 8192
-      
+
   # Executor: Selects and executes atomic actions
   executor:
     provider: GoogleGenAI
@@ -43,7 +78,7 @@ llm_profiles:
     temperature: 0.1
     kwargs:
       max_tokens: 4096
-      
+
   # CodeAct: Generates and executes code actions
   codeact:
     provider: GoogleGenAI
@@ -51,7 +86,7 @@ llm_profiles:
     temperature: 0.2
     kwargs:
       max_tokens: 8192
-      
+
   # Text Manipulator: Edits text in input fields
   text_manipulator:
     provider: GoogleGenAI
@@ -59,7 +94,7 @@ llm_profiles:
     temperature: 0.3
     kwargs:
       max_tokens: 4096
-      
+
   # App Opener: Opens apps by name/description
   app_opener:
     provider: OpenAI
@@ -77,13 +112,11 @@ device:
   serial: null
   # Use TCP communication instead of content provider
   use_tcp: false
-  # Sleep duration after each action (seconds)
-  after_sleep_action: 1.0
 
 # === Telemetry Settings ===
 telemetry:
   # Enable anonymous telemetry
-  enabled: true
+  enabled: false
 
 # === Tracing Settings ===
 tracing:
@@ -96,18 +129,14 @@ logging:
   debug: false
   # Trajectory saving level (none, step, action)
   save_trajectory: none
-
+  rich_text: false
 # === Tool Settings ===
 tools:
   # Enable drag tool
   allow_drag: false
 """
 
-def _default_project_config_path() -> Path:
-    """
-    Use module-relative resolution: two parents above this file -> project root.
-    """
-    return Path(__file__).resolve().parents[2] / "config.yaml"
+# Removed: _default_project_config_path() - now using PathResolver
 
 
 # ---------- Config Schema ----------
@@ -120,7 +149,7 @@ class LLMProfile:
     base_url: Optional[str] = None
     api_base: Optional[str] = None
     kwargs: Dict[str, Any] = field(default_factory=dict)
-    
+
     def to_load_llm_kwargs(self) -> Dict[str, Any]:
         """Convert profile to kwargs for load_llm function."""
         result = {
@@ -138,36 +167,63 @@ class LLMProfile:
 
 
 @dataclass
-class VisionConfig:
-    """Per-agent vision settings."""
-    manager: bool = False
-    executor: bool = False
-    codeact: bool = False
-    
-    def to_dict(self) -> Dict[str, bool]:
-        return {"manager": self.manager, "executor": self.executor, "codeact": self.codeact}
-    
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "VisionConfig":
-        """Create VisionConfig from dictionary or bool."""
-        if isinstance(data, bool):
-            # Support single bool → apply to all agents
-            return cls(manager=data, executor=data, codeact=data)
-        return cls(
-            manager=data.get("manager", False),
-            executor=data.get("executor", False),
-            codeact=data.get("codeact", False),
-        )
+class CodeActConfig:
+    """CodeAct agent configuration."""
+    vision: bool = False
+    system_prompt: str = "system.md"
+    user_prompt: str = "user.md"
+
+
+@dataclass
+class ManagerConfig:
+    """Manager agent configuration."""
+    vision: bool = False
+    system_prompt: str = "system.md"
+
+
+@dataclass
+class ExecutorConfig:
+    """Executor agent configuration."""
+    vision: bool = False
+    system_prompt: str = "system.md"
+
+
+@dataclass
+class AppCardConfig:
+    """App card configuration."""
+    enabled: bool = True
+    app_cards_dir: str = "config/app_cards"
 
 
 @dataclass
 class AgentConfig:
     """Agent-related configuration."""
     max_steps: int = 15
-    vision: VisionConfig = field(default_factory=VisionConfig)
     reasoning: bool = False
     after_sleep_action: float = 1.0
     wait_for_stable_ui: float = 0.3
+    prompts_dir: str = "config/prompts"
+
+    codeact: CodeActConfig = field(default_factory=CodeActConfig)
+    manager: ManagerConfig = field(default_factory=ManagerConfig)
+    executor: ExecutorConfig = field(default_factory=ExecutorConfig)
+    app_cards: AppCardConfig = field(default_factory=AppCardConfig)
+
+    def get_codeact_system_prompt_path(self) -> str:
+        """Get full path to CodeAct system prompt."""
+        return f"{self.prompts_dir}/codeact/{self.codeact.system_prompt}"
+
+    def get_codeact_user_prompt_path(self) -> str:
+        """Get full path to CodeAct user prompt."""
+        return f"{self.prompts_dir}/codeact/{self.codeact.user_prompt}"
+
+    def get_manager_system_prompt_path(self) -> str:
+        """Get full path to Manager system prompt."""
+        return f"{self.prompts_dir}/manager/{self.manager.system_prompt}"
+
+    def get_executor_system_prompt_path(self) -> str:
+        """Get full path to Executor system prompt."""
+        return f"{self.prompts_dir}/executor/{self.executor.system_prompt}"
 
 
 @dataclass
@@ -180,7 +236,7 @@ class DeviceConfig:
 @dataclass
 class TelemetryConfig:
     """Telemetry configuration."""
-    enabled: bool = True
+    enabled: bool = False
 
 
 @dataclass
@@ -194,7 +250,7 @@ class LoggingConfig:
     """Logging configuration."""
     debug: bool = False
     save_trajectory: str = "none"
-
+    rich_text: bool = False
 
 @dataclass
 class ToolsConfig:
@@ -217,7 +273,7 @@ class DroidRunConfig:
         """Ensure default profiles exist."""
         if not self.llm_profiles:
             self.llm_profiles = self._default_profiles()
-    
+
     @staticmethod
     def _default_profiles() -> Dict[str, LLMProfile]:
         """Get default agent specific LLM profiles."""
@@ -247,7 +303,7 @@ class DroidRunConfig:
                 kwargs={}
             ),
             "app_opener": LLMProfile(
-                provider="OpenAI",
+                provider="GoogleGenAI",
                 model="models/gemini-2.5-pro",
                 temperature=0.0,
                 kwargs={}
@@ -261,11 +317,6 @@ class DroidRunConfig:
         result["llm_profiles"] = {
             name: asdict(profile) for name, profile in self.llm_profiles.items()
         }
-        # Convert VisionConfig to dict
-        if isinstance(result["agent"]["vision"], dict):
-            pass  # Already a dict from asdict
-        else:
-            result["agent"]["vision"] = self.agent.vision.to_dict()
         return result
 
     @classmethod
@@ -275,18 +326,34 @@ class DroidRunConfig:
         llm_profiles = {}
         for name, profile_data in data.get("llm_profiles", {}).items():
             llm_profiles[name] = LLMProfile(**profile_data)
-        
-        # Parse agent config with vision
+
+        # Parse agent config with sub-configs
         agent_data = data.get("agent", {})
-        vision_data = agent_data.get("vision", {})
-        vision_config = VisionConfig.from_dict(vision_data)
-        
+
+        codeact_data = agent_data.get("codeact", {})
+        codeact_config = CodeActConfig(**codeact_data) if codeact_data else CodeActConfig()
+
+        manager_data = agent_data.get("manager", {})
+        manager_config = ManagerConfig(**manager_data) if manager_data else ManagerConfig()
+
+        executor_data = agent_data.get("executor", {})
+        executor_config = ExecutorConfig(**executor_data) if executor_data else ExecutorConfig()
+
+        app_cards_data = agent_data.get("app_cards", {})
+        app_cards_config = AppCardConfig(**app_cards_data) if app_cards_data else AppCardConfig()
+
         agent_config = AgentConfig(
             max_steps=agent_data.get("max_steps", 15),
-            vision=vision_config,
             reasoning=agent_data.get("reasoning", False),
+            after_sleep_action=agent_data.get("after_sleep_action", 1.0),
+            wait_for_stable_ui=agent_data.get("wait_for_stable_ui", 0.3),
+            prompts_dir=agent_data.get("prompts_dir", "config/prompts"),
+            codeact=codeact_config,
+            manager=manager_config,
+            executor=executor_config,
+            app_cards=app_cards_config,
         )
-        
+
         return cls(
             agent=agent_config,
             llm_profiles=llm_profiles,
@@ -304,17 +371,20 @@ class ConfigManager:
     Thread-safe singleton ConfigManager with typed configuration schema.
 
     Usage:
-        from droidrun.config_manager import config
-        
+        from droidrun.config_manager.config_manager import ConfigManager
+
+        # Create config instance (singleton pattern)
+        config = ConfigManager()
+
         # Access typed config objects
         print(config.agent.max_steps)
-        
-        # Load all 3 LLMs
+
+        # Load all LLMs
         llms = config.load_all_llms()
-        fast_llm = llms['fast']
-        mid_llm = llms['mid']
-        smart_llm = llms['smart']
-        
+        manager_llm = llms['manager']
+        executor_llm = llms['executor']
+        codeact_llm = llms['codeact']
+
         # Modify and save
         config.save()
     """
@@ -335,18 +405,19 @@ class ConfigManager:
 
         self._lock = threading.RLock()
 
-        # resolution order:
-        # 1) explicit path arg
+        # Resolution order:
+        # 1) Explicit path arg
         # 2) DROIDRUN_CONFIG env var
-        # 3) module-relative project_root/config.yaml (two parents up)
+        # 3) Default "config.yaml" (checks working dir, then project dir)
         if path:
-            self.path = Path(path).expanduser().resolve()
+            self.path = PathResolver.resolve(path)
         else:
             env = os.environ.get("DROIDRUN_CONFIG")
             if env:
-                self.path = Path(env).expanduser().resolve()
+                self.path = PathResolver.resolve(env)
             else:
-                self.path = _default_project_config_path().resolve()
+                # Default: checks CWD first, then project dir
+                self.path = PathResolver.resolve("config.yaml")
 
         # Initialize with default config
         self._config = DroidRunConfig()
@@ -393,24 +464,24 @@ class ConfigManager:
         """Access tools configuration."""
         with self._lock:
             return self._config.tools
-    
+
     @property
     def llm_profiles(self) -> Dict[str, LLMProfile]:
         """Access LLM profiles."""
         with self._lock:
             return self._config.llm_profiles
-    
+
     # ---------------- LLM Profile Helpers ----------------
     def get_llm_profile(self, profile_name: str) -> LLMProfile:
         """
         Get an LLM profile by name.
-        
+
         Args:
             profile_name: Name of the profile (fast, mid, smart, custom, etc.)
-        
+
         Returns:
             LLMProfile object
-            
+
         Raises:
             KeyError: If profile_name doesn't exist
         """
@@ -420,62 +491,62 @@ class ConfigManager:
                     f"LLM profile '{profile_name}' not found. "
                     f"Available profiles: {list(self._config.llm_profiles.keys())}"
                 )
-            
+
             return self._config.llm_profiles[profile_name]
-    
+
     def load_llm_from_profile(self, profile_name: str, **override_kwargs):
         """
         Load an LLM using a profile configuration.
-        
+
         Args:
             profile_name: Name of the profile to use (fast, mid, smart, custom)
             **override_kwargs: Additional kwargs to override profile settings
-            
+
         Returns:
             Initialized LLM instance
-            
+
         Example:
             # Use specific profile
             llm = config.load_llm_from_profile("smart")
-            
+
             # Override specific settings
             llm = config.load_llm_from_profile("fast", temperature=0.5)
         """
         from droidrun.agent.utils.llm_picker import load_llm
-        
+
         profile = self.get_llm_profile(profile_name)
-        
+
         # Get kwargs from profile
         kwargs = profile.to_load_llm_kwargs()
-        
+
         # Override with any provided kwargs
         kwargs.update(override_kwargs)
-        
+
         # Load the LLM
         return load_llm(provider_name=profile.provider, **kwargs)
-    
+
     def load_all_llms(self, profile_names: Optional[list[str]] = None, **override_kwargs_per_profile):
         """
         Load multiple LLMs from profiles for different use cases.
-        
+
         Args:
             profile_names: List of profile names to load. If None, loads agent-specific profiles
             **override_kwargs_per_profile: Dict of profile-specific overrides
                 Example: manager={'temperature': 0.1}, executor={'max_tokens': 8000}
-        
+
         Returns:
             Dict mapping profile names to initialized LLM instances
-            
+
         Example:
             # Load all agent-specific profiles
             llms = config.load_all_llms()
             manager_llm = llms['manager']
             executor_llm = llms['executor']
             codeact_llm = llms['codeact']
-            
+
             # Load specific profiles
             llms = config.load_all_llms(['manager', 'executor'])
-            
+
             # Load with overrides
             llms = config.load_all_llms(
                 manager={'temperature': 0.1},
@@ -483,24 +554,24 @@ class ConfigManager:
             )
         """
         from droidrun.agent.utils.llm_picker import load_llm
-        
+
         if profile_names is None:
             profile_names = ["manager", "executor", "codeact", "text_manipulator", "app_opener"]
-        
+
         llms = {}
         for profile_name in profile_names:
             profile = self.get_llm_profile(profile_name)
-            
+
             # Get kwargs from profile
             kwargs = profile.to_load_llm_kwargs()
-            
+
             # Apply profile-specific overrides if provided
             if profile_name in override_kwargs_per_profile:
                 kwargs.update(override_kwargs_per_profile[profile_name])
-            
+
             # Load the LLM
             llms[profile_name] = load_llm(provider_name=profile.provider, **kwargs)
-        
+
         return llms
 
     # ---------------- I/O ----------------
@@ -569,6 +640,35 @@ class ConfigManager:
             import copy
             return copy.deepcopy(self._config.to_dict())
 
+    # Implemented for for config webiu so we can have dropdown prompt selection. but canceled webui plan.
+    def list_available_prompts(self, agent_type: str) -> List[str]:
+        """
+        List all available prompt files for a given agent type.
+
+        Args:
+            agent_type: One of "codeact", "manager", "executor"
+
+        Returns:
+            List of prompt filenames available in the agent's prompts directory
+
+        Example:
+            >>> config.list_available_prompts("manager")
+            ['system.md', 'experimental.md', 'minimal.md']
+        """
+        agent_type = agent_type.lower()
+        if agent_type not in ["codeact", "manager", "executor"]:
+            raise ValueError(f"Invalid agent_type: {agent_type}. Must be one of: codeact, manager, executor")
+
+        # Resolve prompts directory
+        prompts_path = f"{self.agent.prompts_dir}/{agent_type}"
+        prompts_dir = PathResolver.resolve(prompts_path)
+
+        if not prompts_dir.exists():
+            return []
+
+        # List all .md files in the directory
+        return sorted([f.name for f in prompts_dir.glob("*.md")])
+
     # useful for tests to reset singleton state
     @classmethod
     def _reset_instance_for_testing(cls) -> None:
@@ -579,5 +679,3 @@ class ConfigManager:
         return f"<ConfigManager path={self.path!s}>"
 
 
-# ---------- global singleton ----------
-config = ConfigManager()

droidrun/config_manager/path_resolver.py

@@ -0,0 +1,104 @@
+"""
+Unified path resolution for DroidRun.
+
+This module provides a single path resolver that handles all file path resolution
+with consistent priority: working directory first, then project directory.
+"""
+
+from pathlib import Path
+from typing import Union
+
+
+class PathResolver:
+    """
+    Unified path resolver for all DroidRun file operations.
+
+    Resolution order:
+    1. Absolute paths → use as-is
+    2. Relative paths → check working dir first, then project dir
+    3. For creation → prefer working dir
+    """
+
+    @staticmethod
+    def get_project_root() -> Path:
+        """
+        Get the project root directory (where config.yaml lives).
+
+        This is 2 parents up from this file's location:
+        droidrun/config_manager/path_resolver.py -> droidrun/ (project root)
+        """
+        return Path(__file__).resolve().parents[2]
+
+    @staticmethod
+    def resolve(
+        path: Union[str, Path],
+        create_if_missing: bool = False,
+        must_exist: bool = False
+    ) -> Path:
+        """
+        Universal path resolver for all file operations.
+
+        Resolution order:
+        1. Absolute path → use as-is
+        2. Relative path:
+           - If creating: prefer working directory
+           - If reading: check working dir first, then project dir
+        3. If must_exist and not found → raise FileNotFoundError
+
+        Args:
+            path: Path to resolve (str or Path object)
+            create_if_missing: If True, prefer working dir for relative paths (output mode)
+            must_exist: If True, raise FileNotFoundError if path doesn't exist
+
+        Returns:
+            Resolved Path object
+
+        Raises:
+            FileNotFoundError: If must_exist=True and path not found in any location
+
+        Examples:
+            # Reading config (checks CWD first, then project dir)
+            config_path = PathResolver.resolve("config.yaml")
+
+            # Creating output (creates in CWD)
+            output_dir = PathResolver.resolve("trajectories", create_if_missing=True)
+
+            # Loading prompts (must exist, checks both locations)
+            prompt = PathResolver.resolve("config/prompts/system.md", must_exist=True)
+
+            # Absolute path (used as-is)
+            abs_path = PathResolver.resolve("/tmp/output")
+        """
+        # Convert to Path and expand user home directory (~/)
+        path = Path(path).expanduser()
+
+        # Absolute paths: use as-is
+        if path.is_absolute():
+            if must_exist and not path.exists():
+                raise FileNotFoundError(f"Path not found: {path}")
+            return path
+
+        # Relative paths: check working dir and project dir
+        cwd_path = Path.cwd() / path
+        project_path = PathResolver.get_project_root() / path
+
+        # For creation, always prefer working directory (user's context)
+        if create_if_missing:
+            return cwd_path
+
+        # For reading, check both locations (working dir first)
+        if cwd_path.exists():
+            return cwd_path
+        if project_path.exists():
+            return project_path
+
+        # Not found in either location
+        if must_exist:
+            raise FileNotFoundError(
+                f"Path not found in:\n"
+                f"  - Working dir: {cwd_path}\n"
+                f"  - Project dir: {project_path}"
+            )
+
+        # Default to working dir (user's context)
+        return cwd_path