droidrun 0.3.10.dev5__py3-none-any.whl → 0.3.10.dev6__py3-none-any.whl

droidrun/app_cards/app_card_provider.py

@@ -0,0 +1,27 @@
+"""
+Abstract base class for app card providers.
+
+Providers load app-specific instruction cards based on package names.
+Supports multiple backends: local files, remote servers, or composite strategies.
+"""
+
+from abc import ABC, abstractmethod
+
+
+
+class AppCardProvider(ABC):
+    """Abstract interface for loading app-specific instruction cards."""
+
+    @abstractmethod
+    async def load_app_card(self, package_name: str, instruction: str = "") -> str:
+        """
+        Load app card for a given package asynchronously.
+
+        Args:
+            package_name: Android package name (e.g., "com.google.android.gm")
+            instruction: User's instruction/goal (optional context for server providers)
+
+        Returns:
+            App card content as string, or empty string if not found or on error
+        """
+        pass

droidrun/app_cards/providers/__init__.py

@@ -0,0 +1,7 @@
+"""App card provider implementations."""
+
+from droidrun.app_cards.providers.local_provider import LocalAppCardProvider
+from droidrun.app_cards.providers.server_provider import ServerAppCardProvider
+from droidrun.app_cards.providers.composite_provider import CompositeAppCardProvider
+
+__all__ = ["LocalAppCardProvider", "ServerAppCardProvider", "CompositeAppCardProvider"]

droidrun/app_cards/providers/composite_provider.py

@@ -0,0 +1,97 @@
+"""
+Composite app card provider.
+
+Tries server first, falls back to local if server fails or returns empty.
+"""
+
+import logging
+from typing import Dict
+
+from droidrun.config_manager.app_card_provider import AppCardProvider
+from droidrun.config_manager.providers.local_provider import LocalAppCardProvider
+from droidrun.config_manager.providers.server_provider import ServerAppCardProvider
+
+logger = logging.getLogger("droidrun")
+
+
+class CompositeAppCardProvider(AppCardProvider):
+    """
+    Load app cards from server with local fallback.
+
+    Strategy:
+    1. Try server first
+    2. If server fails or returns empty, try local
+    3. Return first non-empty result, or empty if both fail
+    """
+
+    def __init__(
+        self,
+        server_url: str,
+        app_cards_dir: str = "config/app_cards",
+        server_timeout: float = 2.0,
+        server_max_retries: int = 2
+    ):
+        """
+        Initialize composite provider.
+
+        Args:
+            server_url: Base URL of the app card server
+            app_cards_dir: Directory containing local app_cards.json
+            server_timeout: Server request timeout in seconds
+            server_max_retries: Number of server retry attempts
+        """
+        self.server_provider = ServerAppCardProvider(
+            server_url=server_url,
+            timeout=server_timeout,
+            max_retries=server_max_retries
+        )
+        self.local_provider = LocalAppCardProvider(app_cards_dir=app_cards_dir)
+
+    async def load_app_card(self, package_name: str, instruction: str = "") -> str:
+        """
+        Load app card with server-first, local-fallback strategy.
+
+        Args:
+            package_name: Android package name (e.g., "com.google.android.gm")
+            instruction: User instruction/goal
+
+        Returns:
+            App card content from server or local, or empty string if both fail
+        """
+        if not package_name:
+            return ""
+
+        # Try server first
+        server_result = await self.server_provider.load_app_card(package_name, instruction)
+
+        if server_result:
+            return server_result   
+
+        # Server failed or returned empty, try local
+        logger.debug(f"Composite provider: falling back to local for {package_name}")
+        local_result = await self.local_provider.load_app_card(package_name, instruction)
+
+        if local_result:
+            logger.info(f"Composite provider: using local fallback for {package_name}")
+        else:
+            logger.debug(f"Composite provider: no app card found for {package_name}")
+
+        return local_result
+
+    def clear_cache(self) -> None:
+        """Clear caches in both providers."""
+        self.server_provider.clear_cache()
+        self.local_provider.clear_cache()
+        logger.debug("Composite app card cache cleared")
+
+    def get_cache_stats(self) -> Dict[str, any]:
+        """
+        Get cache statistics from both providers.
+
+        Returns:
+            Dict with cache stats from server and local providers
+        """
+        return {
+            "server": self.server_provider.get_cache_stats(),
+            "local": self.local_provider.get_cache_stats(),
+        }

droidrun/app_cards/providers/local_provider.py

@@ -0,0 +1,116 @@
+"""
+Local file-based app card provider.
+
+Loads app cards from local filesystem using app_cards.json mapping.
+"""
+
+import json
+import logging
+from pathlib import Path
+from typing import Dict
+
+from droidrun.config_manager.app_card_provider import AppCardProvider
+from droidrun.config_manager.path_resolver import PathResolver
+
+logger = logging.getLogger("droidrun")
+
+
+class LocalAppCardProvider(AppCardProvider):
+    """Load app cards from local filesystem with in-memory caching."""
+
+    def __init__(self, app_cards_dir: str = "config/app_cards"):
+        """
+        Initialize local provider.
+
+        Args:
+            app_cards_dir: Directory containing app_cards.json and markdown files
+        """
+        # Resolve app_cards.json path once
+        mapping_path = PathResolver.resolve(f"{app_cards_dir}/app_cards.json")
+        self.app_cards_dir = mapping_path.parent
+
+        # Load mapping immediately
+        try:
+            if mapping_path.exists():
+                with open(mapping_path, "r", encoding="utf-8") as f:
+                    self.mapping = json.load(f)
+                logger.debug(f"Loaded app_cards.json with {len(self.mapping)} entries")
+            else:
+                logger.warning(f"app_cards.json not found at {mapping_path}")
+                self.mapping = {}
+        except Exception as e:
+            logger.warning(f"Failed to load app_cards.json: {e}")
+            self.mapping = {}
+
+        # Content cache: (package_name, instruction) -> content
+        self._content_cache: Dict[tuple[str, str], str] = {}
+
+    async def load_app_card(self, package_name: str, instruction: str = "") -> str:
+        """
+        Load app card for a package name from local files.
+
+        Args:
+            package_name: Android package name (e.g., "com.google.android.gm")
+            instruction: User instruction (for cache key consistency, not used in loading)
+
+        Returns:
+            App card content or empty string if not found
+        """
+        if not package_name:
+            return ""
+
+        # Check content cache first
+        cache_key = (package_name, instruction)
+        if cache_key in self._content_cache:
+            logger.debug(f"App card cache hit: {package_name}")
+            return self._content_cache[cache_key]
+
+        # Check if package exists in mapping
+        if package_name not in self.mapping:
+            self._content_cache[cache_key] = ""
+            return ""
+
+        # Get app card file path (relative to app_cards_dir)
+        filename = self.mapping[package_name]
+        app_card_path = self.app_cards_dir / filename
+
+        # Read file
+        try:
+            if not app_card_path.exists():
+                self._content_cache[cache_key] = ""
+                logger.debug(f"App card not found: {app_card_path}")
+                return ""
+
+            # Async file read
+            import asyncio
+            loop = asyncio.get_event_loop()
+            content = await loop.run_in_executor(
+                None, app_card_path.read_text, "utf-8"
+            )
+
+            # Cache and return
+            self._content_cache[cache_key] = content
+            logger.info(f"Loaded app card for {package_name} from {app_card_path}")
+            return content
+
+        except Exception as e:
+            logger.warning(f"Failed to load app card for {package_name}: {e}")
+            self._content_cache[cache_key] = ""
+            return ""
+
+    def clear_cache(self) -> None:
+        """Clear content cache (useful for testing or runtime reloading)."""
+        self._content_cache.clear()
+        logger.debug("Local app card cache cleared")
+
+    def get_cache_stats(self) -> Dict[str, int]:
+        """
+        Get cache statistics.
+
+        Returns:
+            Dict with cache stats (useful for debugging)
+        """
+        return {
+            "content_entries": len(self._content_cache),
+            "mapping_entries": len(self.mapping),
+        }

droidrun/app_cards/providers/server_provider.py

@@ -0,0 +1,126 @@
+"""
+Server-based app card provider.
+
+Fetches app cards from a remote HTTP server.
+"""
+
+import logging
+from typing import Dict
+
+import httpx
+
+from droidrun.config_manager.app_card_provider import AppCardProvider
+
+logger = logging.getLogger("droidrun")
+
+
+class ServerAppCardProvider(AppCardProvider):
+    """Load app cards from remote server with in-memory caching."""
+
+    def __init__(
+        self,
+        server_url: str,
+        timeout: float = 2.0,
+        max_retries: int = 2
+    ):
+        """
+        Initialize server provider.
+
+        Args:
+            server_url: Base URL of the app card server (e.g., "https://api.example.com")
+            timeout: Request timeout in seconds
+            max_retries: Number of retry attempts on failure
+        """
+        self.server_url = server_url.rstrip("/")
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self._content_cache: Dict[tuple[str, str], str] = {}
+
+    async def load_app_card(self, package_name: str, instruction: str = "") -> str:
+        """
+        Load app card from remote server.
+
+        Args:
+            package_name: Android package name (e.g., "com.google.android.gm")
+            instruction: User instruction/goal (sent to server for context)
+
+        Returns:
+            App card content or empty string if not found or on error
+        """
+        if not package_name:
+            return ""
+
+        # Check content cache first (key: package_name, instruction)
+        cache_key = (package_name, instruction)
+        if cache_key in self._content_cache:
+            return self._content_cache[cache_key]
+
+        # Make HTTP request with retries
+        endpoint = f"{self.server_url}/app-cards"
+        payload = {
+            "package_name": package_name,
+            "instruction": instruction
+        }
+
+        for attempt in range(1, self.max_retries + 1):
+            try:
+                async with httpx.AsyncClient(timeout=self.timeout) as client:
+                    response = await client.post(endpoint, json=payload)
+
+                    if response.status_code == 200:
+                        data = response.json()
+                        app_card = data.get("app_card", "")
+
+                        # Cache the result (even if empty)
+                        self._content_cache[cache_key] = app_card
+                        return app_card
+
+                    elif response.status_code == 404:
+                        # Not found is expected, cache empty result
+                        self._content_cache[cache_key] = ""
+                        return ""
+
+                    else:
+                        logger.warning(
+                            f"Server returned status {response.status_code} for {package_name} "
+                            f"(attempt {attempt}/{self.max_retries})"
+                        )
+
+            except httpx.TimeoutException:
+                logger.warning(
+                    f"Server request timeout for {package_name} "
+                    f"(attempt {attempt}/{self.max_retries})"
+                )
+
+            except httpx.RequestError as e:
+                logger.warning(
+                    f"Server request failed for {package_name}: {e} "
+                    f"(attempt {attempt}/{self.max_retries})"
+                )
+
+            except Exception as e:
+                logger.warning(
+                    f"Unexpected error loading app card from server: {e} "
+                    f"(attempt {attempt}/{self.max_retries})"
+                )
+
+        # All retries failed, cache empty result
+        logger.warning(f"Failed to load app card from server after {self.max_retries} attempts")
+        self._content_cache[cache_key] = ""
+        return ""
+
+    def clear_cache(self) -> None:
+        """Clear content cache."""
+        self._content_cache.clear()
+        logger.debug("Server app card cache cleared")
+
+    def get_cache_stats(self) -> Dict[str, int]:
+        """
+        Get cache statistics.
+
+        Returns:
+            Dict with cache stats (useful for debugging)
+        """
+        return {
+            "content_entries": len(self._content_cache),
+        }

droidrun/cli/main.py

@@ -8,14 +8,13 @@ import os
 import warnings
 from contextlib import nullcontext
 from functools import wraps
-from pathlib import Path
 
 import click
 from adbutils import adb
 from rich.console import Console
 
 from droidrun.agent.droid import DroidAgent
-from droidrun.agent.utils.llm_picker import load_llm
+from droidrun.agent.utils.llm_picker import load_llm, load_llms_from_profiles
 from droidrun.cli.logs import LogHandler
 from droidrun.config_manager.config_manager import (
     AgentConfig,
@@ -240,7 +239,7 @@ async def run_command(
                 if temperature is not None:
                     overrides = {name: {'temperature': temperature} for name in profile_names}
 
-                llms = config.load_all_llms(profile_names=profile_names, **overrides)
+                llms = load_llms_from_profiles(config.llm_profiles, profile_names=profile_names, **overrides)
                 logger.info(f"🧠 Loaded {len(llms)} agent-specific LLMs from profiles")
 
             # ================================================================
@@ -532,29 +531,43 @@ def run(
 ):
     """Run a command on your Android device using natural language."""
 
-    # Call our standalone function
-    return run_command(
-        command,
-        config,
-        device,
-        provider,
-        model,
-        steps,
-        base_url,
-        api_base,
-        vision,
-        manager_vision,
-        executor_vision,
-        codeact_vision,
-        reasoning,
-        tracing,
-        debug,
-        use_tcp,
-        temperature=temperature,
-        save_trajectory=save_trajectory,
-        allow_drag=allow_drag,
-        ios=ios if ios is not None else False,
-    )
+    try:
+        run_command(
+            command,
+            config,
+            device,
+            provider,
+            model,
+            steps,
+            base_url,
+            api_base,
+            vision,
+            manager_vision,
+            executor_vision,
+            codeact_vision,
+            reasoning,
+            tracing,
+            debug,
+            use_tcp,
+            temperature=temperature,
+            save_trajectory=save_trajectory,
+            allow_drag=allow_drag,
+            ios=ios if ios is not None else False,
+        )
+    finally:
+        # Disable DroidRun keyboard after execution
+        try:
+            if not (ios if ios is not None else False):
+                device_serial = adb.device().serial
+                if device_serial:
+                    tools = AdbTools(serial=device, use_tcp=use_tcp if use_tcp is not None else False)
+                    if hasattr(tools, 'device') and tools.device:
+                        tools.device.shell("ime disable com.droidrun.portal/.DroidrunKeyboardIME")
+                        click.echo("DroidRun keyboard disabled successfully")
+                    # Cleanup tools
+                    del tools
+        except Exception as disable_e:
+            click.echo(f"Warning: Failed to disable DroidRun keyboard: {disable_e}")
 
 
 @cli.command()
@@ -756,8 +769,206 @@ def ping(device: str | None, use_tcp: bool, debug: bool):
 cli.add_command(macro_cli, name="macro")
 
 
+async def test(command: str):
+    config = ConfigManager(path="config.yaml")
+    # Initialize logging first (use config default if debug not specified)
+    debug_mode = debug if debug is not None else config.logging.debug
+    log_handler = configure_logging(command, debug_mode, config.logging.rich_text)
+    logger = logging.getLogger("droidrun")
+
+    log_handler.update_step("Initializing...")
+
+    with log_handler.render():
+        try:
+            logger.info(f"🚀 Starting: {command}")
+            print_telemetry_message()
+
+            # ================================================================
+            # STEP 1: Build config objects with CLI overrides
+            # ================================================================
+
+            # Build agent-specific configs with vision overrides
+            if vision is not None:
+                # --vision flag overrides all agents
+                manager_vision_val = vision
+                executor_vision_val = vision
+                codeact_vision_val = vision
+                logger.debug(f"CLI override: vision={vision} (all agents)")
+            else:
+                # Use individual overrides or config defaults
+                manager_vision_val = config.agent.manager.vision
+                executor_vision_val = config.agent.executor.vision
+                codeact_vision_val = config.agent.codeact.vision
+
+            manager_cfg = ManagerConfig(
+                vision=manager_vision_val,
+                system_prompt="rev1.jinja2"
+            )
+
+            executor_cfg = ExecutorConfig(
+                vision=executor_vision_val,
+                system_prompt="rev1.jinja2"
+            )
+
+            codeact_cfg = CodeActConfig(
+                vision=codeact_vision_val,
+                system_prompt=config.agent.codeact.system_prompt,
+                user_prompt=config.agent.codeact.user_prompt
+            )
+
+            agent_cfg = AgentConfig(
+                max_steps=steps if steps is not None else config.agent.max_steps,
+                reasoning=reasoning if reasoning is not None else config.agent.reasoning,
+                after_sleep_action=config.agent.after_sleep_action,
+                wait_for_stable_ui=config.agent.wait_for_stable_ui,
+                prompts_dir=config.agent.prompts_dir,
+                manager=manager_cfg,
+                executor=executor_cfg,
+                codeact=codeact_cfg,
+                app_cards=config.agent.app_cards,
+            )
+
+            device_cfg = DeviceConfig(
+                serial=device if device is not None else config.device.serial,
+                use_tcp=use_tcp if use_tcp is not None else config.device.use_tcp,
+            )
+
+            tools_cfg = ToolsConfig(
+                allow_drag=allow_drag if allow_drag is not None else config.tools.allow_drag,
+            )
+
+            logging_cfg = LoggingConfig(
+                debug=debug if debug is not None else config.logging.debug,
+                save_trajectory=save_trajectory if save_trajectory is not None else config.logging.save_trajectory,
+                rich_text=config.logging.rich_text,
+            )
+
+            tracing_cfg = TracingConfig(
+                enabled=tracing if tracing is not None else config.tracing.enabled,
+            )
+
+            # ================================================================
+            # STEP 3: Load LLMs
+            # ================================================================
+
+            log_handler.update_step("Loading LLMs...")
+
+            # No custom provider/model - use profiles from config
+            logger.info("📋 Loading LLMs from config profiles...")
+
+            profile_names = ['manager', 'executor', 'codeact', 'text_manipulator', 'app_opener']
+
+            # Apply temperature override to all profiles if specified
+            overrides = {}
+            if temperature is not None:
+                overrides = {name: {'temperature': temperature} for name in profile_names}
+
+            llms = load_llms_from_profiles(config.llm_profiles, profile_names=profile_names, **overrides)
+            logger.info(f"🧠 Loaded {len(llms)} agent-specific LLMs from profiles")
+
+            # ================================================================
+            # STEP 4: Setup device and tools
+            # ================================================================
+
+            log_handler.update_step("Setting up tools...")
+
+            device_serial = device_cfg.serial
+            if device_serial is None and not ios:
+                logger.info("🔍 Finding connected device...")
+                devices = adb.list()
+                if not devices:
+                    raise ValueError("No connected devices found.")
+                device_serial = devices[0].serial
+                device_cfg = DeviceConfig(serial=device_serial, use_tcp=device_cfg.use_tcp)
+                logger.info(f"📱 Using device: {device_serial}")
+            elif device_serial is None and ios:
+                raise ValueError("iOS device not specified. Please specify device base url via --device")
+            else:
+                logger.info(f"📱 Using device: {device_serial}")
+
+            tools = (
+                AdbTools(
+                    serial=device_serial,
+                    use_tcp=device_cfg.use_tcp,
+                    app_opener_llm=llms.get('app_opener'),
+                    text_manipulator_llm=llms.get('text_manipulator')
+                )
+                if not ios
+                else IOSTools(url=device_serial)
+            )
+
+            excluded_tools = [] if tools_cfg.allow_drag else ["drag"]
+
+            # ================================================================
+            # STEP 5: Initialize DroidAgent with all settings
+            # ================================================================
+
+            log_handler.update_step("Initializing DroidAgent...")
+
+            mode = "planning with reasoning" if agent_cfg.reasoning else "direct execution"
+            logger.info(f"🤖 Agent mode: {mode}")
+            logger.info(f"👁️  Vision settings: Manager={agent_cfg.manager.vision}, "
+                       f"Executor={agent_cfg.executor.vision}, CodeAct={agent_cfg.codeact.vision}")
+
+            if tracing_cfg.enabled:
+                logger.info("🔍 Tracing enabled")
+
+            droid_agent = DroidAgent(
+                goal=command,
+                llms=llms,
+                tools=tools,
+                config=config,
+                agent_config=agent_cfg,
+                device_config=device_cfg,
+                tools_config=tools_cfg,
+                logging_config=logging_cfg,
+                tracing_config=tracing_cfg,
+                excluded_tools=excluded_tools,
+                timeout=1000,
+            )
+
+            # ================================================================
+            # STEP 6: Run agent
+            # ================================================================
+
+            logger.info("▶️  Starting agent execution...")
+            logger.info("Press Ctrl+C to stop")
+            log_handler.update_step("Running agent...")
+
+            try:
+                handler = droid_agent.run()
+
+                async for event in handler.stream_events():
+                    log_handler.handle_event(event)
+                result = await handler  # noqa: F841
+
+            except KeyboardInterrupt:
+                log_handler.is_completed = True
+                log_handler.is_success = False
+                log_handler.current_step = "Stopped by user"
+                logger.info("⏹️ Stopped by user")
+
+            except Exception as e:
+                log_handler.is_completed = True
+                log_handler.is_success = False
+                log_handler.current_step = f"Error: {e}"
+                logger.error(f"💥 Error: {e}")
+                if logging_cfg.debug:
+                    import traceback
+                    logger.debug(traceback.format_exc())
+
+        except Exception as e:
+            log_handler.current_step = f"Error: {e}"
+            logger.error(f"💥 Setup error: {e}")
+            debug_mode = debug if debug is not None else config.logging.debug
+            if debug_mode:
+                import traceback
+                logger.debug(traceback.format_exc())
+
+
+
 if __name__ == "__main__":
-    command = "Download clash royale app"
+    command = "set gboard to the default keyboard"
     device = None
     provider = "GoogleGenAI"
     model = "models/gemini-2.5-flash"
@@ -765,7 +976,7 @@ if __name__ == "__main__":
     api_key = os.getenv("GOOGLE_API_KEY")
     steps = 15
     vision = True
-    reasoning = True
+    reasoning = False
     tracing = True
     debug = True
     use_tcp = False
@@ -774,6 +985,6 @@ if __name__ == "__main__":
     ios = False
     save_trajectory = "none"
     allow_drag = False
-    run_command(
-        command
+    asyncio.run(
+        test(command)
     )