quash-mcp 0.2.12__py3-none-any.whl → 0.2.14__py3-none-any.whl

quash_mcp/backend_client.py

@@ -8,6 +8,10 @@ import httpx
 from typing import Dict, Any, Optional
 import logging
 
+from .models import SessionDTO
+
+from .models import SessionDTO
+
 logger = logging.getLogger(__name__)
 
 
@@ -16,7 +20,7 @@ class BackendClient:
 
     def __init__(self):
         # Get backend URL from environment variable, default to production backend
-        self.base_url = os.getenv("MAHORAGA_BACKEND_URL", "https://mcpbe.quashbugs.com")
+        self.base_url = os.getenv("MAHORAGA_BACKEND_URL", "http://localhost:8000")
         self.timeout = 300.0  # 5 minutes for long-running LLM calls
         logger.info(f"🔧 Backend client initialized: URL={self.base_url}")
 
@@ -31,7 +35,8 @@ class BackendClient:
             Dict with validation result:
             {
                 "valid": bool,
-                "user": {"email": str, "name": str, "credits": float},
+                "user": {"email": str, "name": str},
+                "organization_credits": float,
                 "openrouter_api_key": str,
                 "error": str (if invalid)
             }
@@ -192,61 +197,18 @@ class BackendClient:
 
     async def execute_step(
         self,
-        api_key: str,
-        session_id: str,
-        step_number: int,
-        task: str,
-        ui_state: Dict[str, Any],
-        chat_history: list,
-        config: Dict[str, Any],
+        session: "SessionDTO",
         screenshot_bytes: Optional[bytes] = None
     ) -> Dict[str, Any]:
         """
-        Execute single agent step (V3 - Step-by-step execution).
-
-        Sends device state to backend, receives next action to execute.
-
-        Args:
-            api_key: Quash API key
-            session_id: Unique session identifier
-            step_number: Current step number
-            task: Original task description
-            ui_state: Device UI state (a11y_tree, phone_state)
-            chat_history: Previous conversation messages
-            config: Execution configuration
-            screenshot_bytes: Optional screenshot (only if vision=True)
-
-        Returns:
-            Dict with action to execute:
-            {
-                "action": {"type": str, "code": str, "reasoning": str},
-                "completed": bool,
-                "success": bool (if completed),
-                "final_message": str (if completed),
-                "assistant_response": str,
-                "tokens_used": {"prompt": int, "completion": int, "total": int},
-                "cost": float
-            }
+        Execute single agent step (V3 - DTO-based execution).
         """
         import json
 
         try:
             # Prepare form data (multipart)
-            data_dict = {
-                "api_key": api_key,
-                "session_id": session_id,
-                "step_number": step_number,
-                "task": task,
-                "ui_state": ui_state,
-                "chat_history": chat_history,
-                "config": config
-            }
-
-            # Convert to JSON string
-            data_json = json.dumps(data_dict)
-
-            # Prepare form data (data field as string)
-            form_data = {"data": data_json}
+            session_json = session.model_dump_json()
+            form_data = {"session_data": session_json}
 
             # Prepare files dict (only screenshot if provided)
             files = {}
@@ -254,7 +216,6 @@ class BackendClient:
                 files["screenshot"] = ("screenshot.png", screenshot_bytes, "image/png")
 
             async with httpx.AsyncClient(timeout=self.timeout) as client:
-                # Send both form data and files (multipart/form-data)
                 response = await client.post(
                     f"{self.base_url}/api/agent/step",
                     data=form_data,
@@ -283,60 +244,18 @@ class BackendClient:
 
     async def finalize_session(
         self,
-        api_key: str,
-        session_id: str,
-        task: str,
-        device_serial: str,
-        status: str,
-        final_message: Optional[str] = None,
-        error: Optional[str] = None,
-        duration_seconds: float = 0.0,
-        config: Optional[Dict[str, Any]] = None
+        session: "SessionDTO",
     ) -> Dict[str, Any]:
         """
         Finalize a session and aggregate execution record.
-
-        Called when task ends for ANY reason: normal completion, max steps, error, interrupt.
-
-        Args:
-            api_key: Quash API key
-            session_id: Session identifier to finalize
-            task: Original task description
-            device_serial: Device serial number
-            status: "success", "failed", "max_steps", "error", "interrupted"
-            final_message: Final message from agent
-            error: Error message if failed
-            duration_seconds: Total execution time
-            config: Execution configuration
-
-        Returns:
-            Dict with finalization result:
-            {
-                "finalized": bool,
-                "execution_id": str,
-                "total_steps": int,
-                "total_tokens": {"prompt": int, "completion": int, "total": int},
-                "total_cost": float,
-                "error": str (if failed)
-            }
         """
-        logger.info(f"🏁 Finalizing session {session_id} - Status: {status}")
+        logger.info(f"🏁 Finalizing session {session.session_id}")
 
         try:
             async with httpx.AsyncClient(timeout=self.timeout) as client:
                 response = await client.post(
                     f"{self.base_url}/api/agent/finalize",
-                    json={
-                        "api_key": api_key,
-                        "session_id": session_id,
-                        "task": task,
-                        "device_serial": device_serial,
-                        "status": status,
-                        "final_message": final_message,
-                        "error": error,
-                        "duration_seconds": duration_seconds,
-                        "config": config or {}
-                    }
+                    data={"session_data": session.model_dump_json(exclude={'ui_state', 'chat_history'})}
                 )
 
                 if response.status_code == 200:
@@ -345,8 +264,9 @@ class BackendClient:
                         logger.info(f"✅ Session finalized: {result.get('total_steps')} steps, ${result.get('total_cost', 0):.4f}")
                     return result
                 else:
-                    logger.warning(f"Failed to finalize session: HTTP {response.status_code}")
-                    return {"finalized": False, "error": f"HTTP {response.status_code}"}
+                    error_details = response.json() if response.headers.get("content-type") == "application/json" else response.text
+                    logger.warning(f"Failed to finalize session: HTTP {response.status_code} - Details: {error_details}")
+                    return {"finalized": False, "error": f"HTTP {response.status_code} - Details: {error_details}"}
 
         except Exception as e:
             logger.error(f"Failed to finalize session: {e}")

quash_mcp/device/adb_tools.py

@@ -102,6 +102,48 @@ class AdbTools:
             logger.error(f"Failed to remove TCP port forwarding: {e}")
             return False
 
+    def get_accessibility_tree(self) -> str:
+        """
+        Get the current accessibility tree (UI hierarchy) as an XML string.
+        """
+        try:
+            # Use uiautomator dump to get the UI hierarchy
+            result = self.device.shell("uiautomator dump --compressed")
+            # The dump command writes to /sdcard/window_dump.xml
+            # We need to read it back
+            xml_content = self.device.pull("/sdcard/window_dump.xml").decode("utf-8")
+            # Clean up the dumped file from the device
+            self.device.shell("rm /sdcard/window_dump.xml")
+            return xml_content
+        except Exception as e:
+            logger.error(f"Failed to get accessibility tree: {e}", exc_info=True)
+            return f"<error>Failed to get accessibility tree: {e}</error>"
+
+    def get_phone_state(self) -> dict[str, any]:
+        """
+        Get basic phone state information, like current app package.
+        """
+        try:
+            current_app = self.device.current_app()
+            return {
+                "package": current_app.package,
+                "activity": current_app.activity,
+                "pid": current_app.pid,
+            }
+        except Exception as e:
+            logger.error(f"Failed to get phone state: {e}", exc_info=True)
+            return {"package": "unknown", "error": str(e)}
+
+    def get_screenshot(self) -> bytes:
+        """
+        Get a screenshot of the device as PNG bytes.
+        """
+        try:
+            return self.device.screenshot()
+        except Exception as e:
+            logger.error(f"Failed to get screenshot: {e}", exc_info=True)
+            return b""
+
     def __del__(self):
         """Cleanup when the object is destroyed."""
         if hasattr(self, "tcp_forwarded") and self.tcp_forwarded:

quash_mcp/device/state_capture.py

@@ -103,6 +103,11 @@ def get_device_state(serial: str) -> Tuple[Dict[str, Any], Optional[bytes]]:
     # Get current package
     current_package = get_current_package(serial)
 
+    logger.debug("Capturing device state...")
+
+    # Get current package
+    current_package = get_current_package(serial)
+
     # Get accessibility tree
     a11y_tree = get_accessibility_tree(serial)
 

quash_mcp/models.py

@@ -0,0 +1,42 @@
+from pydantic import BaseModel, Field
+from typing import Optional, List, Dict, Any
+from datetime import datetime
+
+class TokensInfo(BaseModel):
+    prompt: int
+    completion: int
+    total: int
+
+class ConfigInfo(BaseModel):
+    model: str
+    temperature: float
+    vision: bool = False
+    reasoning: bool = False
+    reflection: bool = False
+    debug: bool = False
+
+class UIStateInfo(BaseModel):
+    a11y_tree: str
+    phone_state: Dict[str, Any]
+
+class ChatHistoryMessage(BaseModel):
+    role: str
+    content: str
+
+class AgentStepDTO(BaseModel):
+    step_number: int
+    reasoning: Optional[str] = None
+    code: Optional[str] = None
+    tokens_used: TokensInfo
+    cost: float
+    timestamp: datetime = Field(default_factory=datetime.utcnow)
+
+class SessionDTO(BaseModel):
+    session_id: str
+    api_key: str
+    task: str
+    device_serial: str
+    config: ConfigInfo
+    chat_history: List[ChatHistoryMessage] = []
+    steps: List[AgentStepDTO] = []
+    ui_state: Optional[UIStateInfo] = None

quash_mcp/tools/execute_v3.py

@@ -17,6 +17,7 @@ from ..state import get_state
 from ..backend_client import get_backend_client
 from ..device.state_capture import get_device_state
 from ..device.adb_tools import AdbTools
+import logging
 
 # Import mahoraga components for tool functions
 try:
@@ -149,7 +150,7 @@ def wait_for_action_effect(
     """
     # Check if action should change UI
     code_lower = executed_code.lower()
-    if "get_state" in code_lower or "complete(" in code_lower:
+    if "get_state" in code_lower:
         # Action doesn't change UI - no need to wait
         time.sleep(0.1)
         return get_state_func(device_serial)[0], None, False
@@ -177,6 +178,8 @@ def wait_for_action_effect(
 # MAIN EXECUTION FUNCTION
 # ============================================================
 
+from ..models import SessionDTO, UIStateInfo, ChatHistoryMessage, ConfigInfo, AgentStepDTO
+
 async def execute_v3(
     task: str,
     max_steps: int = 15,
@@ -184,25 +187,6 @@ async def execute_v3(
 ) -> Dict[str, Any]:
     """
     Execute automation task using step-by-step backend communication.
-
-    Each step:
-    1. Capture device state (State A)
-    2. Send to backend for AI decision
-    3. Execute returned action locally
-    4. POLL until state changes (State B ≠ State A) or timeout
-    5. Send State B to backend in next iteration
-    6. Repeat until complete
-
-    This ensures the backend always sees the UPDATED state after each action,
-    preventing the agent from making decisions based on stale state.
-
-    Args:
-        task: Natural language task description
-        max_steps: Maximum number of steps to execute (default: 15)
-        progress_callback: Optional callback for progress updates
-
-    Returns:
-        Dict with execution result and details
     """
     state = get_state()
     backend = get_backend_client()
@@ -253,12 +237,12 @@ async def execute_v3(
 
     # Check credits
     user_info = validation_result.get("user", {})
-    credits = user_info.get("credits", 0)
+    organization_credits = validation_result.get("organization_credits", 0)
 
-    if credits <= 0:
+    if organization_credits <= 0:
         return {
             "status": "error",
-            "message": f"❌ Insufficient credits. Current balance: ${credits:.2f}",
+            "message": f"❌ Insufficient credits. Current balance: ${organization_credits:.2f}",
             "user": user_info
         }
 
@@ -267,20 +251,23 @@ async def execute_v3(
         if progress_callback:
             progress_callback(message)
 
-    log_progress(f"✅ API Key validated - Credits: ${credits:.2f}")
+    log_progress(f"✅ API Key validated - Credits: ${organization_credits:.2f}")
     log_progress(f"👤 User: {user_info.get('name', 'Unknown')}")
     log_progress(f"🚀 Starting task: {task}")
     log_progress(f"📱 Device: {state.device_serial}")
     log_progress(f"🧠 Model: {config['model']}")
+
     log_progress(f"🔢 Max steps: {max_steps}")
 
-    # Initialize execution
-    start_time = time.time()
-    session_id = f"session_{uuid.uuid4().hex[:12]}"
-    step_number = 0
-    chat_history = []
-    total_tokens = {"prompt": 0, "completion": 0, "total": 0}
-    total_cost = 0.0
+    # Initialize Session DTO
+
+    session = SessionDTO(
+        session_id=f"session_{uuid.uuid4().hex[:12]}",
+        api_key=quash_api_key,
+        task=task,
+        device_serial=state.device_serial,
+        config=ConfigInfo(**config)
+    )
 
     # Initialize local ADB tools for code execution
     adb_tools = AdbTools(serial=state.device_serial, use_tcp=True)
@@ -329,6 +316,15 @@ async def execute_v3(
                 # Add wrapped function to globals so code can call it directly
                 executor_globals[tool_name] = make_printing_wrapper(tool_function)
 
+            # Override the 'complete' function to be a no-op
+            # The backend already handles completion via the 'completed' flag
+            def complete_no_op(success=True, reason=""):
+                """No-op wrapper for complete() - completion is handled by backend."""
+                print(f"complete() called: success={success}, reason='{reason}'")
+                return None
+
+            executor_globals['complete'] = complete_no_op
+
             log_progress(f"🔧 Loaded {len(filtered_tools)} tool functions: {list(filtered_tools.keys())}")
         except Exception as e:
             log_progress(f"⚠️ Warning: Could not load tool functions: {e}")
@@ -337,43 +333,48 @@ async def execute_v3(
 
     executor_locals = {}
 
+    start_time = time.time()
+
     try:
         # ============================================================
         # STEP-BY-STEP EXECUTION LOOP
         # ============================================================
-        while step_number < max_steps:  # Use user-provided max_steps
-            step_number += 1
-            log_progress(f"🧠 Step {step_number}/{max_steps}: Analyzing...")
 
-            # 1. Capture device state (State A)
+        while len(session.steps) < max_steps:
+
+            log_progress(f"🧠 Step {len(session.steps) + 1}/{max_steps}: Analyzing...")
+
+            # 1. Capture device state and update session DTO
             try:
                 ui_state_dict, screenshot_bytes = get_device_state(state.device_serial)
 
-                # Only include screenshot if vision is enabled
+                session.ui_state = UIStateInfo(**ui_state_dict)
+                # Update local tools with new state
+                if mahoraga_tools and "a11y_tree" in ui_state_dict and isinstance(ui_state_dict["a11y_tree"], str):
+                    try:
+                        import json
+                        a11y_tree_obj = json.loads(ui_state_dict["a11y_tree"])
+                        mahoraga_tools.update_state(a11y_tree_obj)
+                    except (json.JSONDecodeError, TypeError):
+                        pass # Ignore if not a valid JSON string
+
                 if not config["vision"]:
                     screenshot_bytes = None
 
-                # Log current state
                 current_package = ui_state_dict.get("phone_state", {}).get("package", "unknown")
                 log_progress(f"📱 Current app: {current_package}")
 
             except Exception as e:
                 log_progress(f"⚠️ Warning: Failed to capture device state: {e}")
-                ui_state_dict = {
-                    "a11y_tree": [{"index": 0, "text": "Error capturing UI", "children": []}],
-                    "phone_state": {"package": "unknown"}
-                }
+                session.ui_state = UIStateInfo(
+                    a11y_tree="<error>Failed to capture UI</error>",
+                    phone_state={"package": "unknown"}
+                )
                 screenshot_bytes = None
 
-            # 2. Send to backend for AI decision
+            # 2. Send session DTO to backend for AI decision
             step_result = await backend.execute_step(
-                api_key=quash_api_key,
-                session_id=session_id,
-                step_number=step_number,
-                task=task,
-                ui_state=ui_state_dict,
-                chat_history=chat_history,
-                config=config,
+                session=session,
                 screenshot_bytes=screenshot_bytes
             )
 
@@ -384,20 +385,20 @@ async def execute_v3(
                     "status": "error",
                     "message": step_result["message"],
                     "error": step_result["error"],
-                    "steps_taken": step_number,
-                    "tokens": total_tokens,
-                    "cost": total_cost,
+                    "steps_taken": len(session.steps),
+                    "tokens": None,
+                    "cost": None,
                     "duration_seconds": time.time() - start_time
                 }
 
-            # Update usage tracking
-            step_tokens = step_result.get("tokens_used", {})
-            step_cost = step_result.get("cost", 0.0)
+            # Update Session DTO with new step and chat history
+            new_step_data = step_result.get("new_step")
+            if new_step_data:
+                new_step = AgentStepDTO(**new_step_data)
+                session.steps.append(new_step)
+            assistant_response = step_result.get("assistant_response", "")
+            session.chat_history.append(ChatHistoryMessage(role="assistant", content=assistant_response))
 
-            total_tokens["prompt"] += step_tokens.get("prompt", 0)
-            total_tokens["completion"] += step_tokens.get("completion", 0)
-            total_tokens["total"] += step_tokens.get("total", 0)
-            total_cost += step_cost
 
             # Get action from backend
             action = step_result.get("action", {})
@@ -405,78 +406,36 @@ async def execute_v3(
             code = action.get("code")
             reasoning = action.get("reasoning")
 
+
             # Log reasoning
             if reasoning:
                 log_progress(f"🤔 Reasoning: {reasoning}")
 
-            # Update chat history
-            assistant_response = step_result.get("assistant_response", "")
-            chat_history.append({"role": "assistant", "content": assistant_response})
-
-            # 3. Check if task is complete
-            if step_result.get("completed", False):
-                success = step_result.get("success", False)
-                final_message = step_result.get("final_message", "Task completed")
-
-                duration = time.time() - start_time
-
-                if success:
-                    log_progress(f"✅ Task completed successfully in {step_number} steps")
-                    log_progress(f"💰 Usage: {total_tokens['total']} tokens, ${total_cost:.4f}")
-
-                    return {
-                        "status": "success",
-                        "steps_taken": step_number,
-                        "final_message": final_message,
-                        "message": f"✅ Success: {final_message}",
-                        "tokens": total_tokens,
-                        "cost": total_cost,
-                        "duration_seconds": duration
-                    }
-                else:
-                    log_progress(f"❌ Task failed: {final_message}")
-                    log_progress(f"💰 Usage: {total_tokens['total']} tokens, ${total_cost:.4f}")
 
-                    return {
-                        "status": "failed",
-                        "steps_taken": step_number,
-                        "final_message": final_message,
-                        "message": f"❌ Failed: {final_message}",
-                        "tokens": total_tokens,
-                        "cost": total_cost,
-                        "duration_seconds": duration
-                    }
-
-            # 4. Execute action locally
+            # 3. Execute action locally FIRST (if provided)
+            # NOTE: Backend should have already removed complete() from the code
             if code and action_type == "execute_code":
                 log_progress(f"⚡ Executing action...")
 
-                # Store old UI state for comparison
-                old_ui_state = ui_state_dict.copy()
+                log_progress(f"```python\n{code}\n```") # Log the code
+
+                old_ui_state = session.ui_state.model_dump().copy()
 
                 try:
                     import io
                     import contextlib
 
-                    # Capture stdout and stderr to get tool function outputs
                     stdout = io.StringIO()
                     stderr = io.StringIO()
 
                     with contextlib.redirect_stdout(stdout), contextlib.redirect_stderr(stderr):
-                        # Execute code in sandbox
                         exec(code, executor_globals, executor_locals)
 
-                    # Get captured output
                     execution_output = stdout.getvalue()
                     error_output = stderr.getvalue()
 
-                    # ============================================================
-                    # CRITICAL: Wait for state change (polling-based event detection)
-                    # ============================================================
                     log_progress(f"⏳ Waiting for UI state to update...")
-
                     try:
-                        # Poll until state changes or timeout
                         new_ui_state_dict, _, state_changed = wait_for_action_effect(
                             get_device_state,
                             state.device_serial,
@@ -486,7 +445,6 @@ async def execute_v3(
                             poll_interval=0.5
                         )
 
-                        # Log what happened
                         if state_changed:
                             old_pkg = old_ui_state.get("phone_state", {}).get("package", "")
                             new_pkg = new_ui_state_dict.get("phone_state", {}).get("package", "")
@@ -495,6 +453,7 @@ async def execute_v3(
                                 log_progress(f"✅ State changed: App switched ({old_pkg} → {new_pkg})")
                             else:
                                 log_progress(f"✅ State changed: UI updated")
+
                         else:
                             log_progress(f"⚠️ WARNING: State did NOT change after action (timeout)")
                             log_progress(f"   This might mean the action had no effect or took too long")
@@ -502,10 +461,8 @@ async def execute_v3(
                     except Exception as e:
                         log_progress(f"⚠️ Error during state change detection: {e}")
                         state_changed = False
-                        # Fallback: Just wait a bit
                         time.sleep(1.5)
 
-                    # Build feedback message
                     feedback_parts = []
 
                     if execution_output:
@@ -523,56 +480,80 @@ async def execute_v3(
 
                     log_progress(f"✅ {feedback[:200]}")
 
-                    # Add execution result to chat history
-                    chat_history.append({
-                        "role": "user",
-                        "content": f"Execution Result:\n```\n{feedback}\n```"
-                    })
+                    session.chat_history.append(ChatHistoryMessage(role="user", content=f"Execution Result:\n```\n{feedback}\n```"))
+
+                    # Introduce a small delay to allow UI effects to settle before checking completion
+                    time.sleep(1.0) # Added delay
 
                 except Exception as e:
                     error_msg = f"Error during execution: {str(e)}"
                     log_progress(f"💥 Action failed: {error_msg}")
 
-                    # Add error to chat history
-                    chat_history.append({
-                        "role": "user",
-                        "content": f"Execution Error:\n```\n{error_msg}\n```"
-                    })
+                    session.chat_history.append(ChatHistoryMessage(role="user", content=f"Execution Error:\n```\n{error_msg}\n```"))
 
-            else:
-                # No code to execute
+            elif not code:
                 log_progress("⚠️ No action code provided by backend")
-                chat_history.append({
-                    "role": "user",
-                    "content": "No code was provided. Please provide code to execute."
-                })
+                session.chat_history.append(ChatHistoryMessage(role="user", content="No code was provided. Please provide code to execute."))
+
+
+            # 4. Check if task is complete AFTER executing action
+            if step_result.get("completed", False):
+                success = step_result.get("success", False)
+                final_message = step_result.get("final_message", "Task completed")
+
+                duration = time.time() - start_time
+
+                if success:
+                    log_progress(f"✅ Task completed successfully!")
+                else:
+                    log_progress(f"❌ Task marked as failed")
+
+                # Finalize session on backend
+                finalize_result = await backend.finalize_session(session=session)
+
+                if success:
+                    log_progress(f"✅ Task completed successfully in {len(session.steps)} steps")
+                    log_progress(f"💰 Usage: {finalize_result.get('total_tokens', {}).get('total')} tokens, ${finalize_result.get('total_cost', 0):.4f}")
+
+                    return {
+                        "status": "success",
+                        "steps_taken": len(session.steps),
+                        "final_message": final_message,
+                        "message": f"✅ Success: {final_message}",
+                        "tokens": finalize_result.get("total_tokens"),
+                        "cost": finalize_result.get("total_cost"),
+                        "duration_seconds": duration
+                    }
+                else:
+                    log_progress(f"❌ Task failed: {final_message}")
+                    log_progress(f"💰 Usage: {finalize_result.get('total_tokens', {}).get('total')} tokens, ${finalize_result.get('total_cost', 0):.4f}")
+
+                    return {
+                        "status": "failed",
+                        "steps_taken": len(session.steps),
+                        "final_message": final_message,
+                        "message": f"❌ Failed: {final_message}",
+                        "tokens": finalize_result.get("total_tokens"),
+                        "cost": finalize_result.get("total_cost"),
+                        "duration_seconds": duration
+                    }
+
 
         # Max steps reached
         log_progress(f"⚠️ Reached maximum steps ({max_steps})")
-        log_progress(f"💰 Usage: {total_tokens['total']} tokens, ${total_cost:.4f}")
 
         duration = time.time() - start_time
 
-        # Finalize session on backend to create execution record
-        await backend.finalize_session(
-            api_key=quash_api_key,
-            session_id=session_id,
-            task=task,
-            device_serial=state.device_serial,
-            status="max_steps",
-            final_message=f"Reached maximum step limit of {max_steps}",
-            error=None,
-            duration_seconds=duration,
-            config=config
-        )
+        # Finalize session on backend
+        finalize_result = await backend.finalize_session(session=session)
 
         return {
             "status": "failed",
-            "steps_taken": step_number,
+            "steps_taken": len(session.steps),
             "final_message": f"Reached maximum step limit of {max_steps}",
             "message": "❌ Failed: Maximum steps reached",
-            "tokens": total_tokens,
-            "cost": total_cost,
+            "tokens": finalize_result.get("total_tokens"),
+            "cost": finalize_result.get("total_cost"),
             "duration_seconds": duration
         }
 
@@ -581,24 +562,14 @@ async def execute_v3(
         duration = time.time() - start_time
 
         # Finalize session on backend
-        await backend.finalize_session(
-            api_key=quash_api_key,
-            session_id=session_id,
-            task=task,
-            device_serial=state.device_serial,
-            status="interrupted",
-            final_message="Task interrupted by user",
-            error=None,
-            duration_seconds=duration,
-            config=config
-        )
+        finalize_result = await backend.finalize_session(session=session)
 
         return {
             "status": "interrupted",
             "message": "ℹ️ Task execution interrupted",
-            "steps_taken": step_number,
-            "tokens": total_tokens,
-            "cost": total_cost,
+            "steps_taken": len(session.steps),
+            "tokens": finalize_result.get("total_tokens"),
+            "cost": finalize_result.get("total_cost"),
             "duration_seconds": duration
         }
 
@@ -608,25 +579,15 @@ async def execute_v3(
         duration = time.time() - start_time
 
         # Finalize session on backend
-        await backend.finalize_session(
-            api_key=quash_api_key,
-            session_id=session_id,
-            task=task,
-            device_serial=state.device_serial,
-            status="error",
-            final_message=None,
-            error=error_msg,
-            duration_seconds=duration,
-            config=config
-        )
+        finalize_result = await backend.finalize_session(session=session)
 
         return {
             "status": "error",
             "message": f"💥 Execution error: {error_msg}",
             "error": error_msg,
-            "steps_taken": step_number,
-            "tokens": total_tokens,
-            "cost": total_cost,
+            "steps_taken": len(session.steps),
+            "tokens": finalize_result.get("total_tokens"),
+            "cost": finalize_result.get("total_cost"),
             "duration_seconds": duration
         }
 

{quash_mcp-0.2.12.dist-info → quash_mcp-0.2.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quash-mcp
-Version: 0.2.12
+Version: 0.2.14
 Summary: Model Context Protocol server for Quash - AI-powered mobile automation agent
 Project-URL: Homepage, https://quashbugs.com
 Project-URL: Repository, https://github.com/quash/quash-mcp

{quash_mcp-0.2.12.dist-info → quash_mcp-0.2.14.dist-info}/RECORD

@@ -1,12 +1,13 @@
 quash_mcp/__init__.py,sha256=LImiWCRgjAbb5DZXBq2DktUEAbftvnO61Vil4Ayun9A,39
 quash_mcp/__main__.py,sha256=WCg5OlnXhr6i0XJHAUGpbhliMy3qE2SJkFzVD4wO-lw,239
-quash_mcp/backend_client.py,sha256=zm_rh7C6yx6Y62YZ32w_nTiff0h8i0CE0OZXLUiqZwE,12794
+quash_mcp/backend_client.py,sha256=jQ_OFOhdbGlTr42VCZMu5XP3_TJPsWCpTX_2iBppafo,9949
+quash_mcp/models.py,sha256=0S7uCZZRRtQuSwIwKTDKZnX2HRMYOBDoDcl7-b8Tzpk,1001
 quash_mcp/server.py,sha256=scUGnplxjsvyYLK2q6hrjl-5Chkdnat9pODDtLzsQFY,15519
 quash_mcp/state.py,sha256=Tnt795GnZcas-h62Y6KYyIZVopeoWPM0TbRwOeVFYj4,4394
 quash_mcp/device/__init__.py,sha256=6e8CtHolt-vJKPxZUU_Vsd6-QGqos9VrFykaLTT90rk,772
-quash_mcp/device/adb_tools.py,sha256=Q0HIZHLBswaD94Qa7AA2VtjY31EZ68l0YClJDmMjOBU,3778
+quash_mcp/device/adb_tools.py,sha256=SsYnzGjG3XsfbiAHiC7PpgLdC149kRH-YkoXQZvxvWc,5439
 quash_mcp/device/portal.py,sha256=sDLJOruUwwNNxIDriiXB4vT0BZYILidgzVgdhHCEkDY,5241
-quash_mcp/device/state_capture.py,sha256=2aq7A-CwKRSbXZAob-JdoK6FfGfLJRB77tMYyo-O2Vo,3349
+quash_mcp/device/state_capture.py,sha256=WUNewRlgi_A6L8usWsga-9iqMTroCuSaZ0OdY8EheU0,3473
 quash_mcp/tools/__init__.py,sha256=r4fMAjHDjHUbimRwYW7VYUDkQHs12UVsG_IBmWpeX9s,249
 quash_mcp/tools/build.py,sha256=M6tGXWrQNkdtCYYrK14gUaoufQvyoor_hNN0lBPSVHY,30321
 quash_mcp/tools/build_old.py,sha256=6M9gaqZ_dX4B7UFTxSMD8T1BX0zEwQUL7RJ8ItNfB54,6016
@@ -14,10 +15,10 @@ quash_mcp/tools/configure.py,sha256=cv4RTolu6qae-XzyACSJUDrALfd0gYC-XE5s66_zfNk,
 quash_mcp/tools/connect.py,sha256=Kc7RGRUgtd2sR_bv6U4CB4kWSaLfsDc5kBo9u4FEjzs,4799
 quash_mcp/tools/execute.py,sha256=kR3VzIl31Lek-js4Hgxs-S_ls4YwKnbqkt79KFbvFuM,909
 quash_mcp/tools/execute_v2_backup.py,sha256=waWnaD0dEVcOJgRBbqZo3HnxME1s6YUOn8aRbm4R3X4,6081
-quash_mcp/tools/execute_v3.py,sha256=8WHiEcVWUcAekh7MGaqpXKYGAzdilQ1HaNankMoAxHI,23506
+quash_mcp/tools/execute_v3.py,sha256=zlkQqjdohE6bFQKMwWf4MeL59iCAbcfOVW6dCNl_veQ,22661
 quash_mcp/tools/runsuite.py,sha256=gohLk9FpN8v7F0a69fspqOqUexTcslpYf3qU-iIZZ3s,7220
 quash_mcp/tools/usage.py,sha256=g76A6FO36fThoyRFG7q92QmS3Kh1pIKOrhYOzUdIubA,1155
-quash_mcp-0.2.12.dist-info/METADATA,sha256=ymeZQAKXV5hQElUhEGeiM5HEyVG9seGjhl0q-Y87nYU,8424
-quash_mcp-0.2.12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-quash_mcp-0.2.12.dist-info/entry_points.txt,sha256=9sbDxrx0ApGDVRS-IE3mQgSao3DwKnnV_k-_ipFn9QI,52
-quash_mcp-0.2.12.dist-info/RECORD,,
+quash_mcp-0.2.14.dist-info/METADATA,sha256=r-rZWyw5mSL799jHIeqqSYvt0q_G23VevDXfaPTBr3w,8424
+quash_mcp-0.2.14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+quash_mcp-0.2.14.dist-info/entry_points.txt,sha256=9sbDxrx0ApGDVRS-IE3mQgSao3DwKnnV_k-_ipFn9QI,52
+quash_mcp-0.2.14.dist-info/RECORD,,