droidrun 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

droidrun/agent/utils/chat_utils.py

@@ -0,0 +1,312 @@
+import base64
+import re
+import inspect
+
+
+import json
+import logging
+from typing import List, TYPE_CHECKING, Optional, Tuple
+from droidrun.agent.context import Reflection
+from llama_index.core.base.llms.types import ChatMessage, ImageBlock, TextBlock
+
+if TYPE_CHECKING:
+    from droidrun.tools import Tools
+
+logger = logging.getLogger("droidrun")
+
+def message_copy(message: ChatMessage, deep = True) -> ChatMessage:
+    if deep:
+        copied_message = message.model_copy()
+        copied_message.blocks = [block.model_copy () for block in message.blocks]
+
+        return copied_message
+    copied_message = message.model_copy()
+
+    # Create a new, independent list containing the same block references
+    copied_message.blocks = list(message.blocks) # or original_message.blocks[:]
+
+    return copied_message
+
+async def add_reflection_summary(reflection: Reflection, chat_history: List[ChatMessage]) -> List[ChatMessage]:
+    """Add reflection summary and advice to help the planner understand what went wrong and what to do differently."""
+    
+    reflection_text = "\n### The last task failed. You have additional information about what happenend. \nThe Reflection from Previous Attempt:\n"
+    
+    if reflection.summary:
+        reflection_text += f"**What happened:** {reflection.summary}\n\n"
+    
+    if reflection.advice:
+        reflection_text += f"**Recommended approach for this retry:** {reflection.advice}\n"
+    
+    reflection_block = TextBlock(text=reflection_text)
+    
+    # Copy chat_history and append reflection block to the last message
+    chat_history = chat_history.copy()
+    chat_history[-1] = message_copy(chat_history[-1])
+    chat_history[-1].blocks.append(reflection_block)
+    
+    return chat_history
+
+def _format_ui_elements(ui_data, level=0) -> str:
+    """Format UI elements in natural language: index. className: resourceId, text - bounds"""
+    if not ui_data:
+        return ""
+    
+    formatted_lines = []
+    indent = "  " * level  # Indentation for nested elements
+    
+    # Handle both list and single element
+    elements = ui_data if isinstance(ui_data, list) else [ui_data]
+    
+    for element in elements:
+        if not isinstance(element, dict):
+            continue
+            
+        # Extract element properties
+        index = element.get('index', '')
+        class_name = element.get('className', '')
+        resource_id = element.get('resourceId', '')
+        text = element.get('text', '')
+        bounds = element.get('bounds', '')
+        children = element.get('children', [])
+        
+        
+        # Format the line: index. className: resourceId, text - bounds
+        line_parts = []
+        if index != '':
+            line_parts.append(f"{index}.")
+        if class_name:
+            line_parts.append(class_name + ":")
+        
+        details = []
+        if resource_id:
+            details.append(f'"{resource_id}"')
+        if text:
+            details.append(f'"{text}"')
+        if details:
+            line_parts.append(", ".join(details))
+        
+        if bounds:
+            line_parts.append(f"- ({bounds})")
+        
+        formatted_line = f"{indent}{' '.join(line_parts)}"
+        formatted_lines.append(formatted_line)
+        
+        # Recursively format children with increased indentation
+        if children:
+            child_formatted = _format_ui_elements(children, level + 1)
+            if child_formatted:
+                formatted_lines.append(child_formatted)
+    
+    return "\n".join(formatted_lines)
+
+async def add_ui_text_block(ui_state: str, chat_history: List[ChatMessage], copy = True) -> List[ChatMessage]:
+    """Add UI elements to the chat history without modifying the original."""
+    if ui_state:
+        # Parse the JSON and format it in natural language
+        try:
+            ui_data = json.loads(ui_state) if isinstance(ui_state, str) else ui_state
+            formatted_ui = _format_ui_elements(ui_data)
+            ui_block = TextBlock(text=f"\nCurrent Clickable UI elements from the device in the schema 'index. className: resourceId, text - bounds(x1,y1,x2,y2)':\n{formatted_ui}\n")
+        except (json.JSONDecodeError, TypeError):
+            # Fallback to original format if parsing fails
+            ui_block = TextBlock(text="\nCurrent Clickable UI elements from the device using the custom TopViewService:\n```json\n" + json.dumps(ui_state) + "\n```\n")
+        
+        if copy:
+            chat_history = chat_history.copy()
+            chat_history[-1] = message_copy(chat_history[-1])
+        chat_history[-1].blocks.append(ui_block)
+    return chat_history
+
+async def add_screenshot_image_block(screenshot, chat_history: List[ChatMessage], copy = True) -> None:
+    if screenshot:
+        image_block = ImageBlock(image=base64.b64encode(screenshot))
+        if copy:
+            chat_history = chat_history.copy()  # Create a copy of chat history to avoid modifying the original
+            chat_history[-1] = message_copy(chat_history[-1])
+        chat_history[-1].blocks.append(image_block)
+    return chat_history
+
+
+async def add_phone_state_block(phone_state, chat_history: List[ChatMessage]) -> List[ChatMessage]:
+    
+    # Format the phone state data nicely
+    if isinstance(phone_state, dict) and 'error' not in phone_state:
+        current_app = phone_state.get('currentApp', 'Unknown')
+        package_name = phone_state.get('packageName', 'Unknown')
+        keyboard_visible = phone_state.get('keyboardVisible', False)
+        focused_element = phone_state.get('focusedElement')
+        
+        # Format the focused element
+        if focused_element:
+            element_text = focused_element.get('text', 'No text')
+            element_class = focused_element.get('className', 'Unknown')
+            element_bounds = focused_element.get('bounds', 'Unknown')
+            element_type = focused_element.get('type', 'unknown')
+            element_resource_id = focused_element.get('resourceId', '')
+            
+            # Build focused element description
+            focused_desc = f"'{element_text}' ({element_class})"
+            if element_resource_id:
+                focused_desc += f" | ID: {element_resource_id}"
+            focused_desc += f" | Bounds: {element_bounds} | Type: {element_type}"
+        else:
+            focused_desc = "None"
+        
+        phone_state_text = f"""
+**Current Phone State:**
+• **App:** {current_app} ({package_name})
+• **Keyboard:** {'Visible' if keyboard_visible else 'Hidden'}
+• **Focused Element:** {focused_desc}
+        """
+    else:
+        # Handle error cases or malformed data
+        if isinstance(phone_state, dict) and 'error' in phone_state:
+            phone_state_text = f"\n📱 **Phone State Error:** {phone_state.get('message', 'Unknown error')}\n"
+        else:
+            phone_state_text = f"\n📱 **Phone State:** {phone_state}\n"
+    
+    ui_block = TextBlock(text=phone_state_text)
+    chat_history = chat_history.copy()
+    chat_history[-1] = message_copy(chat_history[-1])
+    chat_history[-1].blocks.append(ui_block)
+    return chat_history
+
+async def add_packages_block(packages, chat_history: List[ChatMessage]) -> List[ChatMessage]:
+    
+    ui_block = TextBlock(text=f"\nInstalled packages: {packages}\n```\n")
+    chat_history = chat_history.copy()
+    chat_history[-1] = message_copy(chat_history[-1])
+    chat_history[-1].blocks.append(ui_block)
+    return chat_history
+
+async def add_memory_block(memory: List[str], chat_history: List[ChatMessage]) -> List[ChatMessage]:
+    memory_block = "\n### Remembered Information:\n"
+    for idx, item in enumerate(memory, 1):
+        memory_block += f"{idx}. {item}\n"
+    
+    for i, msg in enumerate(chat_history):
+        if msg.role == "user":
+            if isinstance(msg.content, str):
+                updated_content = f"{memory_block}\n\n{msg.content}"
+                chat_history[i] = ChatMessage(role="user", content=updated_content)
+            elif isinstance(msg.content, list):
+                memory_text_block = TextBlock(text=memory_block)
+                content_blocks = [memory_text_block] + msg.content
+                chat_history[i] = ChatMessage(role="user", content=content_blocks)
+            break
+    return chat_history
+
+async def get_reflection_block(reflections: List[Reflection]) -> ChatMessage:
+    reflection_block = "\n### You also have additional Knowledge to help you guide your current task from previous expierences:\n"
+    for reflection in reflections:
+        reflection_block += f"**{reflection.advice}\n"
+    
+    return ChatMessage(role="user", content=reflection_block)
+        
+async def add_task_history_block(completed_tasks: list[dict], failed_tasks: list[dict], chat_history: List[ChatMessage]) -> List[ChatMessage]: 
+    task_history = ""
+
+    # Combine all tasks and show in chronological order
+    all_tasks = completed_tasks + failed_tasks
+    
+    if all_tasks:
+        task_history += "Task History (chronological order):\n"
+        for i, task in enumerate(all_tasks, 1):
+            if hasattr(task, 'description'):
+                status_indicator = "[success]" if hasattr(task, 'status') and task.status == "completed" else "[failed]"
+                task_history += f"{i}. {status_indicator} {task.description}\n"
+            elif isinstance(task, dict):
+                # For backward compatibility with dict format
+                task_description = task.get('description', str(task))
+                status_indicator = "[success]" if task in completed_tasks else "[failed]"
+                task_history += f"{i}. {status_indicator} {task_description}\n"
+            else:
+                status_indicator = "[success]" if task in completed_tasks else "[failed]"
+                task_history += f"{i}. {status_indicator} {task}\n"
+
+    
+    task_block = TextBlock(text=f"{task_history}")
+
+    chat_history = chat_history.copy()
+    chat_history[-1] = message_copy(chat_history[-1])
+    chat_history[-1].blocks.append(task_block)
+    return chat_history
+
+def parse_tool_descriptions(tool_list) -> str:
+    """Parses the available tools and their descriptions for the system prompt."""
+    logger.info("🛠️  Parsing tool descriptions...")
+    tool_descriptions = []
+    
+    for tool in tool_list.values():
+        assert callable(tool), f"Tool {tool} is not callable."
+        tool_name = tool.__name__
+        tool_signature = inspect.signature(tool)
+        tool_docstring = tool.__doc__ or "No description available."
+        formatted_signature = f"def {tool_name}{tool_signature}:\n    \"\"\"{tool_docstring}\"\"\"\n..."
+        tool_descriptions.append(formatted_signature)
+        logger.debug(f"  - Parsed tool: {tool_name}")
+    descriptions = "\n".join(tool_descriptions)
+    logger.info(f"🔩 Found {len(tool_descriptions)} tools.")
+    return descriptions
+
+
+def parse_persona_description(personas) -> str:
+    """Parses the available agent personas and their descriptions for the system prompt."""
+    logger.debug("👥 Parsing agent persona descriptions for Planner Agent...")
+    
+    if not personas:
+        logger.warning("No agent personas provided to Planner Agent")
+        return "No specialized agents available."
+    
+    persona_descriptions = []
+    for persona in personas:
+        # Format each persona with name, description, and expertise areas
+        expertise_list = ", ".join(persona.expertise_areas) if persona.expertise_areas else "General tasks"
+        formatted_persona = f"- **{persona.name}**: {persona.description}\n  Expertise: {expertise_list}"
+        persona_descriptions.append(formatted_persona)
+        logger.debug(f"  - Parsed persona: {persona.name}")
+    
+    # Join all persona descriptions into a single string
+    descriptions = "\n".join(persona_descriptions)
+    logger.debug(f"👤 Found {len(persona_descriptions)} agent personas.")
+    return descriptions
+
+
+def extract_code_and_thought(response_text: str) -> Tuple[Optional[str], str]:
+    """
+    Extracts code from Markdown blocks (```python ... ```) and the surrounding text (thought),
+    handling indented code blocks.
+
+    Returns:
+        Tuple[Optional[code_string], thought_string]
+    """
+    logger.debug("✂️ Extracting code and thought from response...")
+    code_pattern = r"^\s*```python\s*\n(.*?)\n^\s*```\s*?$"
+    code_matches = list(re.finditer(code_pattern, response_text, re.DOTALL | re.MULTILINE))
+
+    if not code_matches:
+        logger.debug("  - No code block found. Entire response is thought.")
+        return None, response_text.strip()
+
+    extracted_code_parts = []
+    for match in code_matches:
+            code_content = match.group(1)
+            extracted_code_parts.append(code_content)
+
+    extracted_code = "\n\n".join(extracted_code_parts)
+
+
+    thought_parts = []
+    last_end = 0
+    for match in code_matches:
+        start, end = match.span(0)
+        thought_parts.append(response_text[last_end:start])
+        last_end = end
+    thought_parts.append(response_text[last_end:])
+
+    thought_text = "".join(thought_parts).strip()
+    thought_preview = (thought_text[:100] + '...') if len(thought_text) > 100 else thought_text
+    logger.debug(f"  - Extracted thought: {thought_preview}")
+
+    return extracted_code, thought_text

droidrun/agent/utils/executer.py

@@ -0,0 +1,132 @@
+import io
+import contextlib
+import ast
+import traceback
+import logging
+from typing import Any, Dict
+from droidrun.agent.utils.async_utils import async_to_sync
+from llama_index.core.workflow import Context
+import asyncio
+from asyncio import AbstractEventLoop
+import threading
+
+logger = logging.getLogger("droidrun")
+
+
+class SimpleCodeExecutor:
+    """
+    A simple code executor that runs Python code with state persistence.
+
+    This executor maintains a global and local state between executions,
+    allowing for variables to persist across multiple code runs.
+
+    NOTE: not safe for production use! Use with caution.
+    """
+
+    def __init__(
+        self,
+        loop: AbstractEventLoop,
+        locals: Dict[str, Any] = {},
+        globals: Dict[str, Any] = {},
+        tools={},
+        use_same_scope: bool = True,
+    ):
+        """
+        Initialize the code executor.
+
+        Args:
+            locals: Local variables to use in the execution context
+            globals: Global variables to use in the execution context
+            tools: List of tools available for execution
+        """
+
+        # loop throught tools and add them to globals, but before that check if tool value is async, if so convert it to sync. tools is a dictionary of tool name: function
+        # e.g. tools = {'tool_name': tool_function}
+
+        # check if tools is a dictionary
+        if isinstance(tools, dict):
+            logger.debug(
+                f"🔧 Initializing SimpleCodeExecutor with tools: {tools.items()}"
+            )
+            for tool_name, tool_function in tools.items():
+                if asyncio.iscoroutinefunction(tool_function):
+                    # If the function is async, convert it to sync
+                    tool_function = async_to_sync(tool_function)
+                # Add the tool to globals
+                globals[tool_name] = tool_function
+        elif isinstance(tools, list):
+            logger.debug(f"🔧 Initializing SimpleCodeExecutor with tools: {tools}")
+            # If tools is a list, convert it to a dictionary with tool name as key and function as value
+            for tool in tools:
+                if asyncio.iscoroutinefunction(tool):
+                    # If the function is async, convert it to sync
+                    tool = async_to_sync(tool)
+                # Add the tool to globals
+                globals[tool.__name__] = tool
+        else:
+            raise ValueError("Tools must be a dictionary or a list of functions.")
+
+        import time
+
+        globals["time"] = time
+
+        self.globals = globals
+        self.locals = locals
+        self.loop = loop
+        self.use_same_scope = use_same_scope
+        if self.use_same_scope:
+            # If using the same scope, set the globals and locals to the same dictionary
+            self.globals = self.locals = {
+                **self.locals,
+                **{k: v for k, v in self.globals.items() if k not in self.locals},
+            }
+
+    async def execute(self, ctx: Context, code: str) -> str:
+        """
+        Execute Python code and capture output and return values.
+
+        Args:
+            code: Python code to execute
+
+        Returns:
+            str: Output from the execution, including print statements.
+        """
+        # Update UI elements before execution
+        self.globals['ui_state'] = await ctx.get("ui_state", None)
+        
+        # Capture stdout and stderr
+        stdout = io.StringIO()
+        stderr = io.StringIO()
+
+        output = ""
+        try:
+            # Execute with captured output
+            thread_exception = []
+            with contextlib.redirect_stdout(stdout), contextlib.redirect_stderr(stderr):
+
+                def execute_code():
+                    try:
+                        exec(code, self.globals, self.locals)
+                    except Exception as e:
+                        import traceback
+
+                        thread_exception.append((e, traceback.format_exc()))
+
+                t = threading.Thread(target=execute_code)
+                t.start()
+                t.join()
+
+            # Get output
+            output = stdout.getvalue()
+            if stderr.getvalue():
+                output += "\n" + stderr.getvalue()
+            if thread_exception:
+                e, tb = thread_exception[0]
+                output += f"\nError: {type(e).__name__}: {str(e)}\n{tb}"
+
+        except Exception as e:
+            # Capture exception information
+            output = f"Error: {type(e).__name__}: {str(e)}\n"
+            output += traceback.format_exc()
+
+        return output

droidrun/agent/utils/llm_picker.py

@@ -0,0 +1,147 @@
+import importlib
+import logging
+from typing import Any
+from llama_index.core.llms.llm import LLM
+# Configure logging
+logger = logging.getLogger("droidrun")
+
+def load_llm(provider_name: str, **kwargs: Any) -> LLM:
+    """
+    Dynamically loads and initializes a LlamaIndex LLM.
+
+    Imports `llama_index.llms.<provider_name_lower>`, finds the class named
+    `provider_name` within that module, verifies it's an LLM subclass,
+    and initializes it with kwargs.
+
+    Args:
+        provider_name: The case-sensitive name of the provider and the class
+                       (e.g., "OpenAI", "Ollama", "HuggingFaceLLM").
+        **kwargs: Keyword arguments for the LLM class constructor.
+
+    Returns:
+        An initialized LLM instance.
+
+    Raises:
+        ModuleNotFoundError: If the provider's module cannot be found.
+        AttributeError: If the class `provider_name` is not found in the module.
+        TypeError: If the found class is not a subclass of LLM or if kwargs are invalid.
+        RuntimeError: For other initialization errors.
+    """
+    if not provider_name:
+        raise ValueError("provider_name cannot be empty.")
+    if provider_name == "OpenAILike":
+        module_provider_part = "openai_like"
+    elif provider_name == "GoogleGenAI":
+        module_provider_part = "google_genai"
+    else:
+        # Use lowercase for module path, handle hyphens for package name suggestion
+        lower_provider_name = provider_name.lower()
+        # Special case common variations like HuggingFaceLLM -> huggingface module
+        if lower_provider_name.endswith("llm"):
+            module_provider_part = lower_provider_name[:-3].replace("-", "_")
+        else:
+            module_provider_part = lower_provider_name.replace("-", "_")
+    module_path = f"llama_index.llms.{module_provider_part}"
+    install_package_name = f"llama-index-llms-{module_provider_part.replace('_', '-')}"
+
+    try:
+        logger.debug(f"Attempting to import module: {module_path}")
+        llm_module = importlib.import_module(module_path)
+        logger.debug(f"Successfully imported module: {module_path}")
+
+    except ModuleNotFoundError:
+        logger.error(f"Module '{module_path}' not found. Try: pip install {install_package_name}")
+        raise ModuleNotFoundError(
+            f"Could not import '{module_path}'. Is '{install_package_name}' installed?"
+        ) from None
+
+    try:
+        logger.debug(f"Attempting to get class '{provider_name}' from module {module_path}")
+        llm_class = getattr(llm_module, provider_name)
+        logger.debug(f"Found class: {llm_class.__name__}")
+
+        # Verify the class is a subclass of LLM
+        if not isinstance(llm_class, type) or not issubclass(llm_class, LLM):
+            raise TypeError(f"Class '{provider_name}' found in '{module_path}' is not a valid LLM subclass.")
+
+        # Filter out None values from kwargs
+        filtered_kwargs = {k: v for k, v in kwargs.items() if v is not None}
+        
+        # Initialize
+        logger.debug(f"Initializing {llm_class.__name__} with kwargs: {list(filtered_kwargs.keys())}")
+        llm_instance = llm_class(**filtered_kwargs)
+        logger.debug(f"Successfully loaded and initialized LLM: {provider_name}")
+        if not llm_instance:
+            raise RuntimeError(f"Failed to initialize LLM instance for {provider_name}.")
+        return llm_instance
+
+    except AttributeError:
+        logger.error(f"Class '{provider_name}' not found in module '{module_path}'.")
+        raise AttributeError(
+            f"Could not find class '{provider_name}' in module '{module_path}'. Check spelling and capitalization."
+        ) from None
+    except TypeError as e:
+        logger.error(f"Error initializing {provider_name}: {e}")
+        raise # Re-raise TypeError (could be from issubclass check or __init__)
+    except Exception as e:
+        logger.error(f"An unexpected error occurred initializing {provider_name}: {e}")
+        raise e
+    
+# --- Example Usage ---
+if __name__ == "__main__":
+    # Install the specific LLM integrations you want to test:
+    # pip install \
+    #   llama-index-llms-anthropic \
+    #   llama-index-llms-deepseek \
+    #   llama-index-llms-gemini \
+    #   llama-index-llms-openai
+
+    # Example 1: Load Anthropic (requires ANTHROPIC_API_KEY env var or kwarg)
+    print("\n--- Loading Anthropic ---")
+    try:
+        anthropic_llm = load_llm(
+            "Anthropic",
+            model="claude-3-7-sonnet-latest",
+        )
+        print(f"Loaded LLM: {type(anthropic_llm)}")
+        print(f"Model: {anthropic_llm.metadata}")
+    except Exception as e:
+        print(f"Failed to load Anthropic: {e}")
+
+    # Example 2: Load DeepSeek (requires DEEPSEEK_API_KEY env var or kwarg)
+    print("\n--- Loading DeepSeek ---")
+    try:
+        deepseek_llm = load_llm(
+            "DeepSeek",
+            model="deepseek-reasoner",
+            api_key="your api",  # or set DEEPSEEK_API_KEY
+        )
+        print(f"Loaded LLM: {type(deepseek_llm)}")
+        print(f"Model: {deepseek_llm.metadata}")
+    except Exception as e:
+        print(f"Failed to load DeepSeek: {e}")
+
+    # Example 3: Load Gemini (requires GOOGLE_APPLICATION_CREDENTIALS or kwarg)
+    print("\n--- Loading Gemini ---")
+    try:
+        gemini_llm = load_llm(
+            "Gemini",
+            model="gemini-2.0-fash",
+        )
+        print(f"Loaded LLM: {type(gemini_llm)}")
+        print(f"Model: {gemini_llm.metadata}")
+    except Exception as e:
+        print(f"Failed to load Gemini: {e}")
+
+    # Example 4: Load OpenAI (requires OPENAI_API_KEY env var or kwarg)
+    print("\n--- Loading OpenAI ---")
+    try:
+        openai_llm = load_llm(
+            "OpenAI",
+            model="gp-4o",
+            temperature=0.5,
+        )
+        print(f"Loaded LLM: {type(openai_llm)}")
+        print(f"Model: {openai_llm.metadata}")
+    except Exception as e:
+        print(f"Failed to load OpenAI: {e}")