quash-mcp 0.2.13__tar.gz → 0.3.1__tar.gz

{quash_mcp-0.2.13 → quash_mcp-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quash-mcp
-Version: 0.2.13
+Version: 0.3.1
 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.13 → quash_mcp-0.3.1}/local_test.py

@@ -13,13 +13,27 @@ from quash_mcp.models import SessionDTO, ConfigInfo, UIStateInfo
 async def main():
     # Initialize the session state
     state = get_state()
-    state.config["api_key"] = "mhg_7S01mxJUB7q6k-sbFQeScYTX6ae3pehI"
+    state.config["api_key"] = "mhg__Sacdd_AiKSJgTow49F8p9Fu-UGyi_Wd"
     state.device_serial = "emulator-5554"
     state.portal_ready = True  # Assume portal is ready for local testing
 
+    # --- CONFIGURATION ---
+    state.config["model"] = "anthropic/claude-sonnet-4"
+    state.config["temperature"] = 0.2
+    state.config["vision"] = False
+    state.config["reasoning"] = True
+    state.config["reflection"] = True
+    state.config["debug"] = False
+    state.config["max_steps"] = 10
+    # ---------------------
+
     # Define the task
-    task = "Open chrome and open quashbugs.com website"
-    # task = "Open settings and scroll 3 times."
+    # task = "Open the google search app and search for bakeries."
+    # task = "Open settings."
+    # task = "Open Markor app, replace the contents of 'Abhinav.txt' to Hello World! and save the file as Done.md"
+    # task = "Tell me all the number drawn on the screen"
+    task = "Create a file with name test.md and write Hello World! and save it in markor app"
+    # task = "Tell me what you see drawn on screen"
 
     # Define a progress callback
     def progress_callback(message):
@@ -31,7 +45,7 @@ async def main():
         api_key=state.config["api_key"],
         task=task,
         device_serial=state.device_serial,
-        config=ConfigInfo(**state.config)
+        config=ConfigInfo(**{k: v for k, v in state.config.items() if k in ConfigInfo.model_fields})
     )
 
     # Print the initial session DTO
@@ -50,4 +64,4 @@ async def main():
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    asyncio.run(main())

{quash_mcp-0.2.13 → quash_mcp-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "quash-mcp"
-version = "0.2.13"
+version = "0.3.1"
 description = "Model Context Protocol server for Quash - AI-powered mobile automation agent"
 readme = "README.md"
 license = {text = "MIT"}

{quash_mcp-0.2.13 → quash_mcp-0.3.1}/quash_mcp/backend_client.py

@@ -35,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)
             }
@@ -211,7 +212,7 @@ class BackendClient:
 
             # Prepare files dict (only screenshot if provided)
             files = {}
-            if screenshot_bytes:
+            if screenshot_bytes and len(screenshot_bytes) > 0:
                 files["screenshot"] = ("screenshot.png", screenshot_bytes, "image/png")
 
             async with httpx.AsyncClient(timeout=self.timeout) as client:

{quash_mcp-0.2.13 → quash_mcp-0.3.1}/quash_mcp/device/state_capture.py

@@ -1,11 +1,7 @@
-"""
-Device state capture utilities.
-Captures UI state and screenshots from Android devices.
-"""
-
+import json
 import logging
 import requests
-from typing import Dict, Any, Optional, Tuple
+from typing import Dict, Any, Optional, Tuple, List
 from adbutils import adb
 
 logger = logging.getLogger("quash-device")
@@ -34,7 +30,7 @@ def get_current_package(serial: str) -> str:
         return "unknown"
 
 
-def get_accessibility_tree(serial: str, tcp_port: int = 8080) -> str:
+def get_accessibility_tree(serial: str, tcp_port: int = 8080) -> List[Dict[str, Any]]:
     """
     Get accessibility tree from Portal app via TCP.
 
@@ -43,7 +39,7 @@ def get_accessibility_tree(serial: str, tcp_port: int = 8080) -> str:
         tcp_port: Local TCP port for Portal communication
 
     Returns:
-        Accessibility tree XML string
+        Accessibility tree as a list of dictionaries, or an empty list if failed
     """
     try:
         device = adb.device(serial)
@@ -55,20 +51,27 @@ def get_accessibility_tree(serial: str, tcp_port: int = 8080) -> str:
         )
 
         if response.status_code == 200:
-            # Portal returns JSON with status and data fields
             data = response.json()
             if data.get("status") == "success":
-                return data.get("data", "<hierarchy></hierarchy>")
+                # The 'data' field should contain the JSON string of the a11y_tree
+                a11y_tree_json_str = data.get("data", "[]")
+                try:
+                    parsed_tree = json.loads(a11y_tree_json_str)
+                    logger.debug(f"get_accessibility_tree returning tree of length: {len(parsed_tree)}")
+                    return parsed_tree
+                except json.JSONDecodeError:
+                    logger.warning(f"Failed to parse a11y_tree JSON string: {a11y_tree_json_str}")
+                    return []
             else:
                 logger.warning(f"Portal error: {data.get('error', 'Unknown error')}")
-                return "<hierarchy></hierarchy>"
+                return []
         else:
             logger.warning(f"Failed to get accessibility tree: HTTP {response.status_code}")
-            return "<hierarchy></hierarchy>"
+            return []
 
     except Exception as e:
         logger.warning(f"Failed to get accessibility tree: {e}")
-        return "<hierarchy></hierarchy>"
+        return []
 
 
 def capture_screenshot(serial: str) -> Optional[bytes]:
@@ -83,7 +86,10 @@ def capture_screenshot(serial: str) -> Optional[bytes]:
     """
     try:
         device = adb.device(serial)
-        screenshot_bytes = device.shell("screencap -p", stream=True)
+        # device.shell("screencap -p", stream=True) returns an AdbConnection object (file-like)
+        # We need to read the bytes from it.
+        with device.shell("screencap -p", stream=True) as conn:
+            screenshot_bytes = conn.read(1024 * 1024 * 10) # Read up to 10MB
         return screenshot_bytes
     except Exception as e:
         logger.error(f"Failed to capture screenshot: {e}")

{quash_mcp-0.2.13 → quash_mcp-0.3.1}/quash_mcp/models.py

@@ -16,7 +16,7 @@ class ConfigInfo(BaseModel):
     debug: bool = False
 
 class UIStateInfo(BaseModel):
-    a11y_tree: str
+    a11y_tree: List[Dict[str, Any]]
     phone_state: Dict[str, Any]
 
 class ChatHistoryMessage(BaseModel):
@@ -31,6 +31,12 @@ class AgentStepDTO(BaseModel):
     cost: float
     timestamp: datetime = Field(default_factory=datetime.utcnow)
 
+class ReflectionInfo(BaseModel):
+    """Information about a reflection step."""
+    goal_achieved: bool
+    advice: Optional[str] = None
+    summary: Optional[str] = None
+
 class SessionDTO(BaseModel):
     session_id: str
     api_key: str
@@ -39,4 +45,9 @@ class SessionDTO(BaseModel):
     config: ConfigInfo
     chat_history: List[ChatHistoryMessage] = []
     steps: List[AgentStepDTO] = []
+    current_plan: Optional[List[str]] = None
+    current_task_index: int = 0
     ui_state: Optional[UIStateInfo] = None
+    last_reflection: Optional[ReflectionInfo] = None # Store the last reflection for the session
+
+    last_action_completed: Optional[bool] = None

{quash_mcp-0.2.13 → quash_mcp-0.3.1}/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:
@@ -181,7 +182,6 @@ from ..models import SessionDTO, UIStateInfo, ChatHistoryMessage, ConfigInfo, Ag
 
 async def execute_v3(
     task: str,
-    max_steps: int = 15,
     progress_callback: Optional[Callable[[str], None]] = None
 ) -> Dict[str, Any]:
     """
@@ -222,6 +222,7 @@ async def execute_v3(
         "reflection": state.config["reflection"],
         "debug": state.config["debug"]
     }
+    max_steps = state.config.get("max_steps", 15)
 
     # Validate API key
     validation_result = await backend.validate_api_key(quash_api_key)
@@ -236,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
         }
 
@@ -250,76 +251,78 @@ 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 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)
+        config=ConfigInfo(**config),
+        last_action_completed=None  # Explicitly initialize the new field
     )
 
-    # Initialize local ADB tools for code execution
-    adb_tools = AdbTools(serial=state.device_serial, use_tcp=True)
+    # Initialize a single, powerful ADB tools instance from Mahoraga
+    mahoraga_tools = None
+    try:
+        mahoraga_tools = MahoragaAdbTools(
+            serial=state.device_serial,
+            use_tcp=True,
+            remote_tcp_port=8080
+        )
+    except Exception as e:
+        log_progress(f"⚠️ CRITICAL: Failed to initialize MahoragaAdbTools: {e}")
+        return {
+            "status": "error",
+            "message": f"💥 Failed to initialize ADB tools: {e}",
+        }
 
     # Code executor namespace - add tool functions so generated code can call them
     executor_globals = {
         "__builtins__": __builtins__,
-        "adb_tools": adb_tools
     }
 
-    # Add tool functions to executor namespace (like start_app, swipe, etc.)
-    if describe_tools and DEFAULT and MahoragaAdbTools:
-        try:
-            # Create a mahoraga AdbTools instance for tool execution
-            mahoraga_tools = MahoragaAdbTools(
-                serial=state.device_serial,
-                use_tcp=True,
-                remote_tcp_port=8080
-            )
-
-            # Get all tool functions from mahoraga AdbTools instance
-            tool_list = describe_tools(mahoraga_tools, exclude_tools=None)
-
-            # Filter by allowed tools from DEFAULT persona
-            allowed_tool_names = DEFAULT.allowed_tools if hasattr(DEFAULT, 'allowed_tools') else []
-            filtered_tools = {name: func for name, func in tool_list.items() if name in allowed_tool_names}
-
-            # Add each tool function to executor globals with print wrapper
-            for tool_name, tool_function in filtered_tools.items():
-                # Convert async functions to sync if needed
-                if asyncio.iscoroutinefunction(tool_function):
-                    if async_to_sync:
-                        tool_function = async_to_sync(tool_function)
-
-                # Wrap tool function to print its return value
-                def make_printing_wrapper(func):
-                    """Wrap a tool function to print its return value."""
-                    def wrapper(*args, **kwargs):
-                        result = func(*args, **kwargs)
-                        # Print the result so stdout captures it
-                        if result is not None:
-                            print(result)
-                        return result
-                    return wrapper
-
-                # Add wrapped function to globals so code can call it directly
-                executor_globals[tool_name] = make_printing_wrapper(tool_function)
-
-            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}")
-            import traceback
-            log_progress(f"Traceback: {traceback.format_exc()}")
+    # Add tool functions to executor namespace
+    try:
+        # Get all tool functions from the single mahoraga_tools instance
+        tool_list = describe_tools(mahoraga_tools, exclude_tools=None)
+
+        # Filter by allowed tools from DEFAULT persona
+        allowed_tool_names = DEFAULT.allowed_tools if hasattr(DEFAULT, 'allowed_tools') else []
+        filtered_tools = {name: func for name, func in tool_list.items() if name in allowed_tool_names}
+
+        # Add each tool function to executor globals with print wrapper
+        for tool_name, tool_function in filtered_tools.items():
+            # Convert async functions to sync if needed
+            if asyncio.iscoroutinefunction(tool_function):
+                if async_to_sync:
+                    tool_function = async_to_sync(tool_function)
+
+            # Wrap tool function to print its return value
+            def make_printing_wrapper(func):
+                """Wrap a tool function to print its return value."""
+                def wrapper(*args, **kwargs):
+                    result = func(*args, **kwargs)
+                    # Print the result so stdout captures it
+                    if result is not None:
+                        print(result)
+                    return result
+                return wrapper
+
+            # Add wrapped function to globals so code can call it directly
+            executor_globals[tool_name] = make_printing_wrapper(tool_function)
+
+        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}")
+        import traceback
+        log_progress(f"Traceback: {traceback.format_exc()}")
 
     executor_locals = {}
 
@@ -339,14 +342,14 @@ async def execute_v3(
                 ui_state_dict, screenshot_bytes = get_device_state(state.device_serial)
 
                 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):
+                if mahoraga_tools and "a11y_tree" in ui_state_dict and isinstance(ui_state_dict["a11y_tree"], list):
                     try:
-                        import json
-                        a11y_tree_obj = json.loads(ui_state_dict["a11y_tree"])
+                        a11y_tree_obj = ui_state_dict["a11y_tree"]
                         mahoraga_tools.update_state(a11y_tree_obj)
-                    except (json.JSONDecodeError, TypeError):
-                        pass # Ignore if not a valid JSON string
+                    except Exception as e:
+                        log_progress(f"⚠️ Warning: Failed to update mahoraga_tools state: {e}")
 
                 if not config["vision"]:
                     screenshot_bytes = None
@@ -357,7 +360,7 @@ async def execute_v3(
             except Exception as e:
                 log_progress(f"⚠️ Warning: Failed to capture device state: {e}")
                 session.ui_state = UIStateInfo(
-                    a11y_tree="<error>Failed to capture UI</error>",
+                    a11y_tree=[],
                     phone_state={"package": "unknown"}
                 )
                 screenshot_bytes = None
@@ -381,14 +384,29 @@ async def execute_v3(
                     "duration_seconds": time.time() - start_time
                 }
 
-            # Update Session DTO with new step and chat history
+            # CRITICAL: Update the client's session DTO with the one returned from the backend
+            updated_session_data = step_result.get("updated_session")
+            if updated_session_data:
+                # Ensure last_action_completed field exists
+                if "last_action_completed" not in updated_session_data:
+                    updated_session_data["last_action_completed"] = None
+                session = SessionDTO(**updated_session_data)
+            else:
+                # Fallback: if updated_session not returned, update locally
+                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))
+
+            # CRITICAL FIX: Handle plan generation responses (which have new_step=None)
+            # These don't create actual steps, just show the plan
             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))
-
+            if new_step_data is None and not updated_session_data:
+                # Plan was generated but no step was added
+                # This is normal - plan is informational only
+                pass
 
             # Get action from backend
             action = step_result.get("action", {})
@@ -396,60 +414,18 @@ async def execute_v3(
             code = action.get("code")
             reasoning = action.get("reasoning")
 
-
             # Log reasoning
             if reasoning:
                 log_progress(f"🤔 Reasoning: {reasoning}")
 
+            # CRITICAL FIX: Reset completion flag before executing
+            session.last_action_completed = False
 
-            # 3. Check if task is complete BEFORE 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")
+            # 3. Execute action locally (if provided)
+            if code and (action_type == "execute_code" or action_type == "complete"):
 
-                # 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
-                    }
-
-
-            # 4. Execute action locally (only if task is not complete)
-            if code and action_type == "execute_code":
                 log_progress(f"⚡ Executing action...")
-
-                log_progress(f"```python\n{code}\n```") # Log the code
+                log_progress(f"```python\n{code}\n```")
 
                 old_ui_state = session.ui_state.model_dump().copy()
 
@@ -466,6 +442,13 @@ async def execute_v3(
                     execution_output = stdout.getvalue()
                     error_output = stderr.getvalue()
 
+                    # CRITICAL FIX: Check if complete() was actually called
+                    if mahoraga_tools and mahoraga_tools.finished:
+                        log_progress("✅ Agent has signaled task completion via complete()")
+                        session.last_action_completed = True
+                    else:
+                        session.last_action_completed = False
+
                     log_progress(f"⏳ Waiting for UI state to update...")
                     try:
                         new_ui_state_dict, _, state_changed = wait_for_action_effect(
@@ -485,7 +468,6 @@ 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")
@@ -500,7 +482,10 @@ async def execute_v3(
                     if execution_output:
                         feedback_parts.append(f"Action output: {execution_output.strip()}")
 
-                    if state_changed:
+                    # CRITICAL FIX: Report completion status in feedback
+                    if session.last_action_completed:
+                        feedback_parts.append("Sub-task completed successfully (complete() was called)")
+                    elif state_changed:
                         feedback_parts.append("UI state updated successfully")
                     else:
                         feedback_parts.append("WARNING: UI state did not change (action may have failed)")
@@ -512,27 +497,86 @@ async def execute_v3(
 
                     log_progress(f"✅ {feedback[:200]}")
 
-                    session.chat_history.append(ChatHistoryMessage(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```"
+                    ))
 
+                    time.sleep(0.5)
 
                 except Exception as e:
                     error_msg = f"Error during execution: {str(e)}"
                     log_progress(f"💥 Action failed: {error_msg}")
+                    session.last_action_completed = False
+
+                    session.chat_history.append(ChatHistoryMessage(
+                        role="user",
+                        content=f"Execution Error:\n```\n{error_output.strip()}\n```"
+                    ))
+
+            # 4. Check if overall task is complete
+            # CRITICAL FIX: In reasoning mode with planning, DON'T exit on first complete() call
+            # The backend controls when all tasks are done via the "complete" action type
+            should_exit = False
+
+            if mahoraga_tools and mahoraga_tools.finished:
+                # Check if this is the FINAL completion from the backend
+                # In reasoning mode, the backend returns action.type="complete" when ALL tasks are done
+                action_type = action.get("type", "")
+
+                if action_type == "complete":
+                    # Backend explicitly says we're done with ALL tasks
+                    should_exit = True
+                    success = mahoraga_tools.success
+                    final_message = mahoraga_tools.reason
+                elif config["reasoning"] and session.current_plan:
+                    # In reasoning mode with a plan, a single complete() call is just for one sub-task
+                    # Continue the loop - the backend will advance to the next task
+                    log_progress(f"✅ Sub-task completed. Moving to next task...")
+                    should_exit = False
+                else:
+                    # Non-reasoning mode: first complete() means done
+                    should_exit = True
+                    success = mahoraga_tools.success
+                    final_message = mahoraga_tools.reason
+
+            if should_exit and mahoraga_tools and mahoraga_tools.finished:
+                success = mahoraga_tools.success
+                final_message = mahoraga_tools.reason
+                duration = time.time() - start_time
 
-                    session.chat_history.append(ChatHistoryMessage(role="user", content=f"Execution Error:\n```\n{error_msg}\n```"))
+                if success:
+                    log_progress(f"✅ Task completed successfully!")
+                else:
+                    log_progress(f"❌ Task marked as failed: {final_message}")
 
-            elif not code:
-                log_progress("⚠️ No action code provided by backend")
-                session.chat_history.append(ChatHistoryMessage(role="user", content="No code was provided. Please provide code to execute."))
+                # Finalize session on backend
+                finalize_result = await backend.finalize_session(session=session)
+                total_tokens = finalize_result.get("total_tokens", {})
+                total_cost = finalize_result.get("total_cost", 0)
 
+                log_progress(f"💰 Usage: {total_tokens.get('total')} tokens, ${total_cost:.4f}")
 
+                return {
+                    "status": "success" if success else "failed",
+                    "steps_taken": len(session.steps),
+                    "final_message": final_message,
+                    "message": f"✅ Success: {final_message}" if success else f"❌ Failed: {final_message}",
+                    "tokens": total_tokens,
+                    "cost": total_cost,
+                    "duration_seconds": duration
+                }
+
+            elif not code:
+                log_progress("⚠️ No action code provided by backend")
+                session.chat_history.append(ChatHistoryMessage(
+                    role="user",
+                    content="No code was provided. Please provide code to execute."
+                ))
 
         # Max steps reached
         log_progress(f"⚠️ Reached maximum steps ({max_steps})")
-
         duration = time.time() - start_time
-
-        # Finalize session on backend
         finalize_result = await backend.finalize_session(session=session)
 
         return {
@@ -548,8 +592,6 @@ async def execute_v3(
     except KeyboardInterrupt:
         log_progress("ℹ️ Task interrupted by user")
         duration = time.time() - start_time
-
-        # Finalize session on backend
         finalize_result = await backend.finalize_session(session=session)
 
         return {
@@ -565,8 +607,6 @@ async def execute_v3(
         error_msg = str(e)
         log_progress(f"💥 Error: {error_msg}")
         duration = time.time() - start_time
-
-        # Finalize session on backend
         finalize_result = await backend.finalize_session(session=session)
 
         return {
@@ -581,5 +621,5 @@ async def execute_v3(
 
     finally:
         # Cleanup TCP forwarding
-        if adb_tools:
-            adb_tools.teardown_tcp_forward()
+        if mahoraga_tools:
+            mahoraga_tools.teardown_tcp_forward()

quash_mcp-0.2.13/test_backend_integration.py

@@ -1,100 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test script to verify MCP -> Backend integration.
-Tests API key validation and execution logging with real backend.
-"""
-
-import asyncio
-import os
-import sys
-from pathlib import Path
-from dotenv import load_dotenv
-
-# Load .env file from project root
-project_root = Path(__file__).parent.parent
-env_file = project_root / ".env"
-load_dotenv(env_file)
-
-# Add src to path
-sys.path.insert(0, str(Path(__file__).parent / "src"))
-
-from backend_client import get_backend_client
-
-
-async def test_integration():
-    """Test MCP backend integration."""
-
-    print("=" * 60)
-    print("🧪 Testing Mahoraga MCP -> Backend Integration")
-    print("=" * 60)
-
-    # Check environment
-    mock_mode = os.getenv("MAHORAGA_MOCK_BACKEND", "true")
-    backend_url = os.getenv("MAHORAGA_BACKEND_URL", "http://localhost:8000")
-
-    print(f"\n📋 Configuration:")
-    print(f"   Mock Mode: {mock_mode}")
-    print(f"   Backend URL: {backend_url}")
-
-    # Get backend client
-    client = get_backend_client()
-
-    # Test API key from database
-    test_api_key = "mah_test1234567890abcdef"
-
-    print(f"\n🔑 Testing API Key Validation...")
-    print(f"   API Key: {test_api_key}")
-
-    # Test validation
-    result = await client.validate_api_key(test_api_key)
-
-    if result.get("valid"):
-        print("   ✅ API Key Valid!")
-        user = result.get("user", {})
-        print(f"   👤 User: {user.get('name')} ({user.get('email')})")
-        print(f"   💰 Credits: ${user.get('credits', 0):.2f}")
-    else:
-        print(f"   ❌ API Key Invalid: {result.get('error')}")
-        return False
-
-    # Test execution logging
-    print(f"\n📊 Testing Execution Logging...")
-
-    log_result = await client.log_execution(
-        api_key=test_api_key,
-        execution_id="test_exec_integration_001",
-        status="completed",
-        tokens={"prompt": 150, "completion": 75, "total": 225},
-        cost=0.05
-    )
-
-    if log_result.get("logged"):
-        print("   ✅ Execution Logged!")
-        print(f"   💸 Credits Deducted: ${log_result.get('credits_deducted', 0):.2f}")
-        print(f"   💰 New Balance: ${log_result.get('new_balance', 0):.2f}")
-    else:
-        print(f"   ❌ Logging Failed: {log_result.get('error')}")
-        return False
-
-    # Verify credits were deducted
-    print(f"\n🔍 Verifying Credit Deduction...")
-
-    verify_result = await client.validate_api_key(test_api_key)
-    if verify_result.get("valid"):
-        new_credits = verify_result.get("user", {}).get("credits", 0)
-        print(f"   ✅ Credits Updated: ${new_credits:.2f}")
-
-    print(f"\n" + "=" * 60)
-    print("✅ All Integration Tests Passed!")
-    print("=" * 60)
-    print("\n💡 Next Steps:")
-    print("   1. MCP is now connected to real backend")
-    print("   2. Test with actual MCP execute command")
-    print("   3. Build web portal for user management")
-
-    return True
-
-
-if __name__ == "__main__":
-    success = asyncio.run(test_integration())
-    sys.exit(0 if success else 1)

quash_mcp-0.2.13/test_tools_loading.py

@@ -1,81 +0,0 @@
-"""
-Test script to verify tool functions are loaded correctly.
-"""
-
-import sys
-sys.path.insert(0, '/Users/abhinavsai/POC/mahoraga-mac/quash-mcp')
-sys.path.insert(0, '/Users/abhinavsai/POC/mahoraga-mac/mahoraga')
-
-def test_tool_loading():
-    print("Testing tool loading...")
-
-    try:
-        # Import mahoraga components
-        from mahoraga.tools import Tools, describe_tools
-        from mahoraga.tools.adb import AdbTools as MahoragaAdbTools
-        from mahoraga.agent.context.personas import DEFAULT
-        from mahoraga.agent.utils.async_utils import async_to_sync
-
-        print("✅ All imports successful")
-
-        # Create a mahoraga AdbTools instance
-        print("\nCreating mahoraga AdbTools instance...")
-        mahoraga_tools = MahoragaAdbTools(
-            serial="emulator-5554",  # Use your device serial
-            use_tcp=True,
-            remote_tcp_port=8080
-        )
-        print(f"✅ Created mahoraga AdbTools instance")
-        print(f"   - Serial: {mahoraga_tools.device.serial}")
-        print(f"   - TCP forwarded: {mahoraga_tools.tcp_forwarded}")
-
-        # Get tool list
-        print("\nGetting tool list...")
-        tool_list = describe_tools(mahoraga_tools, exclude_tools=None)
-        print(f"✅ Got {len(tool_list)} tools:")
-        for tool_name, tool_func in tool_list.items():
-            print(f"   - {tool_name}: {tool_func}")
-
-        # Filter by allowed tools
-        print(f"\nFiltering by DEFAULT persona allowed tools...")
-        allowed_tool_names = DEFAULT.allowed_tools
-        print(f"   Allowed tools: {allowed_tool_names}")
-
-        filtered_tools = {name: func for name, func in tool_list.items() if name in allowed_tool_names}
-        print(f"✅ Filtered to {len(filtered_tools)} tools:")
-        for tool_name in filtered_tools.keys():
-            print(f"   - {tool_name}")
-
-        # Test executor globals setup
-        print("\nSetting up executor globals...")
-        executor_globals = {"__builtins__": __builtins__}
-
-        for tool_name, tool_function in filtered_tools.items():
-            import asyncio
-            if asyncio.iscoroutinefunction(tool_function):
-                tool_function = async_to_sync(tool_function)
-            executor_globals[tool_name] = tool_function
-
-        print(f"✅ Executor globals set up with {len(executor_globals)} items")
-
-        # Test that functions are callable
-        print("\nTesting function availability...")
-        test_functions = ['start_app', 'swipe', 'press_key', 'tap_by_index']
-        for func_name in test_functions:
-            if func_name in executor_globals:
-                print(f"   ✅ {func_name} is available")
-            else:
-                print(f"   ❌ {func_name} is NOT available")
-
-        print("\n✅ All tests passed!")
-        return True
-
-    except Exception as e:
-        print(f"\n❌ Test failed: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-if __name__ == "__main__":
-    success = test_tool_loading()
-    sys.exit(0 if success else 1)