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

droidrun/agent/utils/executer.py

@@ -1,9 +1,10 @@
-import io
 import contextlib
-import traceback
+import io
 import logging
-from typing import Any, Dict, Optional
+import traceback
 from asyncio import AbstractEventLoop
+from typing import Any, Dict, Optional
+
 from pydantic import BaseModel
 
 logger = logging.getLogger("droidrun")
@@ -11,7 +12,7 @@ logger = logging.getLogger("droidrun")
 class ExecuterState(BaseModel):
     """State object for the code executor."""
     ui_state: Optional[Any] = None
-    
+
     class Config:
         arbitrary_types_allowed = True
 
@@ -70,7 +71,7 @@ class SimpleCodeExecutor:
         self.locals = locals
         self.loop = loop
         self.use_same_scope = use_same_scope
-        
+
         if self.use_same_scope:
             # If using the same scope, merge globals and locals
             self.globals = self.locals = {
@@ -85,7 +86,7 @@ class SimpleCodeExecutor:
         """
         # Update UI state
         self.globals['ui_state'] = ui_state
-        
+
         # Capture stdout and stderr
         stdout = io.StringIO()
         stderr = io.StringIO()
@@ -111,7 +112,7 @@ class SimpleCodeExecutor:
     async def execute(self, state: ExecuterState, code: str) -> str:
         """
         Execute Python code and capture output and return values.
-        
+
         Runs the code in a separate thread to prevent blocking.
 
         Args:
@@ -123,7 +124,7 @@ class SimpleCodeExecutor:
         """
         # Get UI state from the state object
         ui_state = state.ui_state
-        
+
         # Run the execution in a thread pool executor
         output = await self.loop.run_in_executor(
             None,
@@ -131,5 +132,5 @@ class SimpleCodeExecutor:
             code,
             ui_state
         )
-        
-        return output
+
+        return output

droidrun/agent/utils/llm_picker.py

@@ -1,11 +1,14 @@
 import importlib
 import logging
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from llama_index.core.llms.llm import LLM
 
 from droidrun.agent.usage import track_usage
 
+if TYPE_CHECKING:
+    from droidrun.config_manager.config_manager import LLMProfile
+
 # Configure logging
 logger = logging.getLogger("droidrun")
 
@@ -104,6 +107,65 @@ def load_llm(provider_name: str, **kwargs: Any) -> LLM:
         raise e
 
 
+def load_llms_from_profiles(
+    profiles: dict[str, "LLMProfile"],
+    profile_names: list[str] | None = None,
+    **override_kwargs_per_profile
+) -> dict[str, LLM]:
+    """
+    Load multiple LLMs from LLMProfile objects.
+
+    Args:
+        profiles: Dict of profile_name -> LLMProfile objects
+        profile_names: List of profile names to load. If None, loads all 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:
+        >>> config = ConfigManager()
+        >>> llms = load_llms_from_profiles(config.llm_profiles)
+        >>> manager_llm = llms['manager']
+
+        >>> # Load specific profiles with overrides
+        >>> llms = load_llms_from_profiles(
+        ...     config.llm_profiles,
+        ...     profile_names=['manager', 'executor'],
+        ...     manager={'temperature': 0.1}
+        ... )
+    """
+    if profile_names is None:
+        profile_names = list(profiles.keys())
+
+    llms = {}
+    for profile_name in profile_names:
+        logger.debug(f"Loading LLM for profile: {profile_name}")
+
+        if profile_name not in profiles:
+            raise KeyError(
+                f"Profile '{profile_name}' not found. "
+                f"Available profiles: {list(profiles.keys())}"
+            )
+
+        profile = profiles[profile_name]
+
+        # Get base kwargs from profile
+        kwargs = profile.to_load_llm_kwargs()
+
+        # Apply profile-specific overrides if provided
+        if profile_name in override_kwargs_per_profile:
+            logger.debug(f"Applying overrides for {profile_name}: {override_kwargs_per_profile[profile_name]}")
+            kwargs.update(override_kwargs_per_profile[profile_name])
+
+        # Load the LLM
+        llms[profile_name] = load_llm(provider_name=profile.provider, **kwargs)
+        logger.debug(f"Successfully loaded {profile_name} LLM: {profile.provider}/{profile.model}")
+
+    return llms
+
+
 # --- Example Usage ---
 if __name__ == "__main__":
     # Install the specific LLM integrations you want to test:

droidrun/agent/utils/tools.py

@@ -1,5 +1,5 @@
-from typing import TYPE_CHECKING, List
 import time
+from typing import TYPE_CHECKING, List
 
 if TYPE_CHECKING:
     from droidrun.tools import Tools
@@ -127,6 +127,35 @@ def open_app(tool_instance: "Tools", text: str) -> str:
     return result
 
 
+def remember(tool_instance: "Tools", information: str) -> str:
+    """
+    Remember important information for later use.
+
+    Args:
+        tool_instance: The Tools instance
+        information: The information to remember
+
+    Returns:
+        Confirmation message
+    """
+    return tool_instance.remember(information)
+
+
+def complete(tool_instance: "Tools", success: bool, reason: str = "") -> None:
+    """
+    Mark the task as complete.
+
+    Args:
+        tool_instance: The Tools instance
+        success: Whether the task was completed successfully
+        reason: Explanation for success or failure
+
+    Returns:
+        None
+    """
+    tool_instance.complete(success, reason)
+
+
 # =============================================================================
 # ATOMIC ACTION SIGNATURES - Single source of truth for both Executor and CodeAct
 # =============================================================================

droidrun/app_cards/app_card_provider.py

@@ -0,0 +1,26 @@
+"""
+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.composite_provider import CompositeAppCardProvider
+from droidrun.app_cards.providers.local_provider import LocalAppCardProvider
+from droidrun.app_cards.providers.server_provider import ServerAppCardProvider
+
+__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.app_cards.app_card_provider import AppCardProvider
+from droidrun.app_cards.providers.local_provider import LocalAppCardProvider
+from droidrun.app_cards.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,115 @@
+"""
+Local file-based app card provider.
+
+Loads app cards from local filesystem using app_cards.json mapping.
+"""
+
+import json
+import logging
+from typing import Dict
+
+from droidrun.app_cards.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.app_cards.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/logs.py

@@ -21,14 +21,14 @@ from droidrun.agent.droid.events import (
     FinalizeEvent,
     TaskRunnerEvent,
 )
-from droidrun.agent.manager.events import (
-    ManagerInternalPlanEvent,
-    ManagerThinkingEvent,
-)
 from droidrun.agent.executor.events import (
     ExecutorInternalActionEvent,
     ExecutorInternalResultEvent,
 )
+from droidrun.agent.manager.events import (
+    ManagerInternalPlanEvent,
+    ManagerThinkingEvent,
+)
 
 
 class LogHandler(logging.Handler):