Event Streaming

from droidrun.agent.droid import DroidAgent

# Create and run agent
agent = DroidAgent(goal="Open Gmail and check inbox", config=config)
handler = agent.run()

# Stream events in real-time
async for event in handler.stream_events():
    if isinstance(event, ManagerPlanDetailsEvent):
        print(f"📋 Plan: {event.plan}")
        print(f"🎯 Current subgoal: {event.current_subgoal}")

    elif isinstance(event, ExecutorActionEvent):
        print(f"⚡ Action: {event.description}")
        print(f"💭 Thought: {event.thought}")

    elif isinstance(event, ScreenshotEvent):
        save_screenshot(event.screenshot, "screenshot.png")

    elif isinstance(event, TaskThinkingEvent):
        print(f"🐍 Generated code:")
        if event.code:
            print(event.code)
        if event.thoughts:
            print(f"💭 Thoughts: {event.thoughts}")

# Wait for final result
result = await handler
print(f"✅ Success: {result.success}")
print(f"📝 Reason: {result.reason}")

class ManagerContextEvent(Event):
    """Signals that Manager has prepared context and is ready for LLM call"""
    pass  # No fields - this is just a signal event

class ManagerResponseEvent(Event):
    output_planning: str             # Raw validated LLM response from Manager
    usage: Optional[UsageResult]     # Token usage (requests, input/output tokens)

class ManagerPlanDetailsEvent(Event):
    plan: str              # Full task plan with subgoals
    current_subgoal: str   # Current subgoal being executed
    thought: str           # Manager's reasoning
    manager_answer: str    # Direct answer (if task is complete)
    memory_update: str     # Memory additions from this response
    success: bool | None   # True/False if complete, None if in progress
    full_response: str     # Complete LLM response from Manager

class ExecutorContextEvent(Event):
    messages: list  # ChatMessage list for LLM
    subgoal: str    # Current subgoal being executed

class ExecutorResponseEvent(Event):
    response_text: str               # Raw LLM response from Executor
    usage: Optional[UsageResult]     # Token usage (requests, input/output tokens)

class ExecutorActionEvent(Event):
    action_json: str    # JSON representation of selected action
    thought: str        # Executor's reasoning
    description: str    # Human-readable action description
    full_response: str  # Complete LLM response from Executor

class ExecutorActionResultEvent(Event):
    action: Dict        # The executed action
    outcome: bool       # Whether action succeeded
    error: str          # Error message (if failed)
    summary: str        # Human-readable summary of result
    thought: str        # Executor's reasoning
    action_json: str    # Raw action JSON
    full_response: str  # Complete LLM response from Executor

class TaskThinkingEvent(Event):
    thoughts: Optional[str]          # LLM's reasoning process
    code: Optional[str]              # Generated Python code
    usage: Optional[UsageResult]     # Token usage (requests, input/output tokens)

class TaskExecutionResultEvent(Event):
    output: str      # Execution output or error message

class ScripterThinkingEvent(Event):
    thoughts: str                    # LLM's reasoning process
    code: Optional[str]              # Generated Python code
    full_response: str               # Complete LLM response
    usage: Optional[UsageResult]     # Token usage (requests, input/output tokens)

class ScreenshotEvent(Event):
    screenshot: bytes  # PNG image data

class RecordUIStateEvent(Event):
    ui_state: list[Dict[str, Any]]  # Accessibility tree as structured data

class UsageResult(BaseModel):
    request_tokens: int   # Number of tokens in the prompt
    response_tokens: int  # Number of tokens in the response
    total_tokens: int     # Total tokens used (request + response)
    requests: int         # Number of LLM requests made

async def run_with_ui(goal: str):
    agent = DroidAgent(goal=goal, config=config)
    handler = agent.run()

    async for event in handler.stream_events():
        if isinstance(event, ManagerPlanDetailsEvent):
            ui.update_plan(event.plan)
            ui.update_current_step(event.current_subgoal)

        elif isinstance(event, ExecutorActionEvent):
            ui.add_action_log(event.description, event.thought)

        elif isinstance(event, ScreenshotEvent):
            ui.update_screenshot(event.screenshot)

    result = await handler
    ui.show_completion(result.success, result.reason)

async def track_token_usage(goal: str):
    agent = DroidAgent(goal=goal, config=config)
    handler = agent.run()

    total_tokens = 0
    total_requests = 0

    async for event in handler.stream_events():
        # Check for events that contain usage information
        if hasattr(event, 'usage') and event.usage:
            total_tokens += event.usage.total_tokens
            total_requests += event.usage.requests

            print(f"LLM call - Input: {event.usage.request_tokens}, "
                  f"Output: {event.usage.response_tokens}, "
                  f"Total: {event.usage.total_tokens}")

    result = await handler
    print(f"\n📊 Total tokens used: {total_tokens}")
    print(f"📊 Total LLM requests: {total_requests}")

import logging

logger = logging.getLogger("droidrun.monitor")

async def monitor_execution(goal: str):
    agent = DroidAgent(goal=goal, config=config)
    handler = agent.run()

    start_time = time.time()
    action_count = 0

    async for event in handler.stream_events():
        if isinstance(event, ExecutorActionEvent):
            action_count += 1
            logger.info(f"Action {action_count}: {event.description}")

        elif isinstance(event, TaskExecutionResultEvent):
            logger.info(f"Code execution result: {event.output}")

    result = await handler
    duration = time.time() - start_time

    logger.info(f"Task completed in {duration:.2f}s with {action_count} actions")
    logger.info(f"Result: {result.success} - {result.reason}")