minitap-mobile-use 0.0.1.dev0__py3-none-any.whl → 2.0.1__py3-none-any.whl

minitap/mobile_use/servers/stop_servers.py

@@ -4,6 +4,7 @@ from typing import List
 
 import psutil
 import requests
+
 from minitap.mobile_use.servers.config import server_settings
 from minitap.mobile_use.servers.device_hardware_bridge import DEVICE_HARDWARE_BRIDGE_PORT
 from minitap.mobile_use.utils.logger import get_server_logger
@@ -44,27 +45,23 @@ def stop_process_gracefully(process: psutil.Process, timeout: int = 5) -> bool:
             logger.success(f"Process {process.pid} ({process.name()}) already terminated")
             return True
 
-        logger.info(f"Stopping process {process.pid} ({process.name()})")
+        logger.debug(f"Stopping process {process.pid} ({process.name()})")
 
         process.terminate()
 
         try:
             process.wait(timeout=timeout)
-            logger.success(f"Process {process.pid} terminated gracefully")
             return True
         except psutil.TimeoutExpired:
             logger.warning(f"Process {process.pid} didn't terminate gracefully, force killing...")
             try:
                 process.kill()
                 process.wait(timeout=2)
-                logger.success(f"Process {process.pid} force killed")
                 return True
             except psutil.NoSuchProcess:
-                logger.success(f"Process {process.pid} already terminated during force kill")
                 return True
 
     except psutil.NoSuchProcess:
-        logger.success(f"Process {process.pid} no longer exists (already terminated)")
         return True
     except (psutil.AccessDenied, psutil.ZombieProcess) as e:
         logger.warning(f"Cannot stop process {process.pid}: {e}")
@@ -84,7 +81,7 @@ def check_service_health(port: int, service_name: str) -> bool:
             return False
 
         if response.status_code == 200:
-            logger.warning(f"{service_name} is still responding on port {port}")
+            logger.debug(f"{service_name} is still responding on port {port}")
             return True
     except requests.exceptions.RequestException:
         pass
@@ -167,19 +164,15 @@ def stop_device_hardware_bridge() -> bool:
 
 
 def stop_servers(
-    device_screen_api: bool = False, device_hardware_bridge: bool = False
+    should_stop_screen_api: bool = False, should_stop_hw_bridge: bool = False
 ) -> tuple[bool, bool]:
-    """Stop all servers and return (api_success, bridge_success).
-
-    Args:
-        device_screen_api: If True, stop the Device Screen API
-        device_hardware_bridge: If True, stop the Device Hardware Bridge
+    """Stop the servers and return whether they stopped successfully (api_success, bridge_success).
 
     Returns:
         Tuple of (api_stopped, bridge_stopped) booleans
     """
-    api_success = stop_device_screen_api() if device_screen_api else True
-    bridge_success = stop_device_hardware_bridge() if device_hardware_bridge else True
+    api_success = stop_device_screen_api() if should_stop_screen_api else True
+    bridge_success = stop_device_hardware_bridge() if should_stop_hw_bridge else True
 
     if api_success and bridge_success:
         logger.success("All servers stopped successfully")
@@ -195,7 +188,9 @@ def stop_servers(
 
 def main():
     """Main function to stop all servers."""
-    api_success, bridge_success = stop_servers(device_screen_api=True, device_hardware_bridge=True)
+    api_success, bridge_success = stop_servers(
+        should_stop_screen_api=True, should_stop_hw_bridge=True
+    )
     if api_success and bridge_success:
         return 0
     elif api_success or bridge_success:

minitap/mobile_use/services/llm.py

@@ -39,6 +39,7 @@ def get_openai_llm(
     client = ChatOpenAI(
         model=model_name,
         api_key=settings.OPENAI_API_KEY,
+        base_url=settings.OPENAI_BASE_URL,
         temperature=temperature,
     )
     return client

minitap/mobile_use/tools/index.py

@@ -5,13 +5,12 @@ from minitap.mobile_use.tools.mobile.copy_text_from import copy_text_from_wrappe
 from minitap.mobile_use.tools.mobile.erase_text import erase_text_wrapper
 from minitap.mobile_use.tools.mobile.input_text import input_text_wrapper
 from minitap.mobile_use.tools.mobile.launch_app import launch_app_wrapper
-from minitap.mobile_use.tools.mobile.list_packages import list_packages_wrapper
+from minitap.mobile_use.tools.mobile.find_packages import find_packages_wrapper
 from minitap.mobile_use.tools.mobile.long_press_on import long_press_on_wrapper
 from minitap.mobile_use.tools.mobile.open_link import open_link_wrapper
 from minitap.mobile_use.tools.mobile.paste_text import paste_text_wrapper
 from minitap.mobile_use.tools.mobile.press_key import press_key_wrapper
 
-# from minitap.mobile_use.tools.mobile.run_flow import run_flow_wrapper
 from minitap.mobile_use.tools.mobile.stop_app import stop_app_wrapper
 from minitap.mobile_use.tools.mobile.swipe import swipe_wrapper
 from minitap.mobile_use.tools.mobile.take_screenshot import take_screenshot_wrapper
@@ -28,10 +27,9 @@ EXECUTOR_WRAPPERS_TOOLS = [
     long_press_on_wrapper,
     swipe_wrapper,
     take_screenshot_wrapper,
-    # run_flow_wrapper, # To decomment when subflow is implemented
     copy_text_from_wrapper,
     input_text_wrapper,
-    list_packages_wrapper,
+    find_packages_wrapper,
     launch_app_wrapper,
     stop_app_wrapper,
     paste_text_wrapper,

minitap/mobile_use/tools/mobile/back.py

@@ -1,11 +1,10 @@
-from typing import Optional
-
 from langchain_core.messages import ToolMessage
 from langchain_core.tools import tool
 from langchain_core.tools.base import InjectedToolCallId
 from langgraph.types import Command
+from minitap.mobile_use.constants import EXECUTOR_MESSAGES_KEY
 from minitap.mobile_use.controllers.mobile_command_controller import back as back_controller
-from minitap.mobile_use.tools.tool_wrapper import ExecutorMetadata, ToolWrapper
+from minitap.mobile_use.tools.tool_wrapper import ToolWrapper
 from typing_extensions import Annotated
 from minitap.mobile_use.context import MobileUseContext
 from minitap.mobile_use.graph.state import State
@@ -18,7 +17,6 @@ def get_back_tool(ctx: MobileUseContext):
         tool_call_id: Annotated[str, InjectedToolCallId],
         state: Annotated[State, InjectedState],
         agent_thought: str,
-        executor_metadata: Optional[ExecutorMetadata],
     ):
         """Navigates to the previous screen. (Only works on Android for the moment)"""
         output = back_controller(ctx=ctx)
@@ -27,18 +25,16 @@ def get_back_tool(ctx: MobileUseContext):
             tool_call_id=tool_call_id,
             content=back_wrapper.on_failure_fn() if has_failed else back_wrapper.on_success_fn(),
             additional_kwargs={"error": output} if has_failed else {},
+            status="error" if has_failed else "success",
         )
         return Command(
-            update=back_wrapper.handle_executor_state_fields(
+            update=state.sanitize_update(
                 ctx=ctx,
-                state=state,
-                executor_metadata=executor_metadata,
-                tool_message=tool_message,
-                is_failure=has_failed,
-                updates={
+                update={
                     "agents_thoughts": [agent_thought],
-                    "messages": [tool_message],
+                    EXECUTOR_MESSAGES_KEY: [tool_message],
                 },
+                agent="executor",
             ),
         )
 

minitap/mobile_use/tools/mobile/copy_text_from.py

@@ -1,14 +1,13 @@
-from typing import Optional
-
 from langchain_core.messages import ToolMessage
 from langchain_core.tools import tool
 from langchain_core.tools.base import InjectedToolCallId
 from langgraph.types import Command
+from minitap.mobile_use.constants import EXECUTOR_MESSAGES_KEY
 from minitap.mobile_use.controllers.mobile_command_controller import SelectorRequest
 from minitap.mobile_use.controllers.mobile_command_controller import (
     copy_text_from as copy_text_from_controller,
 )
-from minitap.mobile_use.tools.tool_wrapper import ExecutorMetadata, ToolWrapper
+from minitap.mobile_use.tools.tool_wrapper import ToolWrapper
 from pydantic import Field
 from typing_extensions import Annotated
 from minitap.mobile_use.context import MobileUseContext
@@ -22,7 +21,6 @@ def get_copy_text_from_tool(ctx: MobileUseContext):
         tool_call_id: Annotated[str, InjectedToolCallId],
         state: Annotated[State, InjectedState],
         agent_thought: str,
-        executor_metadata: Optional[ExecutorMetadata],
         selector_request: SelectorRequest = Field(
             ..., description="The selector to copy text from"
         ),
@@ -50,18 +48,16 @@ def get_copy_text_from_tool(ctx: MobileUseContext):
             if has_failed
             else copy_text_from_wrapper.on_success_fn(selector_request),
             additional_kwargs={"error": output} if has_failed else {},
+            status="error" if has_failed else "success",
         )
         return Command(
-            update=copy_text_from_wrapper.handle_executor_state_fields(
+            update=state.sanitize_update(
                 ctx=ctx,
-                state=state,
-                executor_metadata=executor_metadata,
-                tool_message=tool_message,
-                is_failure=has_failed,
-                updates={
+                update={
                     "agents_thoughts": [agent_thought],
-                    "messages": [tool_message],
+                    EXECUTOR_MESSAGES_KEY: [tool_message],
                 },
+                agent="executor",
             ),
         )
 

minitap/mobile_use/tools/mobile/erase_text.py

@@ -7,6 +7,7 @@ from langgraph.prebuilt import InjectedState
 from langgraph.types import Command
 from typing_extensions import Annotated
 
+from minitap.mobile_use.constants import EXECUTOR_MESSAGES_KEY
 from minitap.mobile_use.controllers.mobile_command_controller import (
     ScreenDataResponse,
     WaitTimeout,
@@ -17,7 +18,7 @@ from minitap.mobile_use.controllers.mobile_command_controller import (
     erase_text as erase_text_controller,
 )
 from minitap.mobile_use.graph.state import State
-from minitap.mobile_use.tools.tool_wrapper import ExecutorMetadata, ToolWrapper
+from minitap.mobile_use.tools.tool_wrapper import ToolWrapper
 from minitap.mobile_use.utils.ui_hierarchy import find_element_by_resource_id
 from minitap.mobile_use.context import MobileUseContext
 
@@ -29,7 +30,6 @@ def get_erase_text_tool(ctx: MobileUseContext):
         state: Annotated[State, InjectedState],
         agent_thought: str,
         input_text_resource_id: str,
-        executor_metadata: Optional[ExecutorMetadata],
         nb_chars: Optional[int] = None,
     ):
         """
@@ -87,19 +87,17 @@ def get_erase_text_tool(ctx: MobileUseContext):
                 nb_char_erased=nb_char_erased, new_text_value=new_text_value
             ),
             additional_kwargs={"error": output} if has_failed else {},
+            status="error" if has_failed else "success",
         )
 
         return Command(
-            update=erase_text_wrapper.handle_executor_state_fields(
+            update=state.sanitize_update(
                 ctx=ctx,
-                state=state,
-                executor_metadata=executor_metadata,
-                tool_message=tool_message,
-                is_failure=has_failed,
-                updates={
+                update={
                     "agents_thoughts": [agent_thought],
-                    "messages": [tool_message],
+                    EXECUTOR_MESSAGES_KEY: [tool_message],
                 },
+                agent="executor",
             ),
         )
 

minitap/mobile_use/tools/mobile/find_packages.py

@@ -0,0 +1,69 @@
+from langchain_core.messages import ToolMessage
+from langchain_core.tools import tool
+from langchain_core.tools.base import InjectedToolCallId
+from langgraph.prebuilt import InjectedState
+from langgraph.types import Command
+from minitap.mobile_use.agents.hopper.hopper import HopperOutput, hopper
+from minitap.mobile_use.constants import EXECUTOR_MESSAGES_KEY
+from minitap.mobile_use.context import MobileUseContext
+from minitap.mobile_use.controllers.platform_specific_commands_controller import list_packages
+from minitap.mobile_use.graph.state import State
+from minitap.mobile_use.tools.tool_wrapper import ToolWrapper
+from typing_extensions import Annotated
+
+
+def get_find_packages_tool(ctx: MobileUseContext):
+    @tool
+    async def find_packages(
+        tool_call_id: Annotated[str, InjectedToolCallId],
+        state: Annotated[State, InjectedState],
+        appNames: list[str],
+        agent_thought: str,
+    ) -> Command:
+        """
+        Finds relevant applications.
+        Outputs the full package names list (android) or bundle ids list (IOS).
+        """
+        output: str = list_packages(ctx=ctx)
+
+        try:
+            hopper_output: HopperOutput = await hopper(
+                ctx=ctx,
+                request=f"I'm looking for the package names of the following apps: {appNames}",
+                data=output,
+            )
+            tool_message = ToolMessage(
+                tool_call_id=tool_call_id,
+                content=find_packages_wrapper.on_success_fn(
+                    hopper_output.step, hopper_output.output
+                ),
+                status="success",
+            )
+        except Exception as e:
+            print("Failed to extract insights from data: " + str(e))
+            tool_message = ToolMessage(
+                tool_call_id=tool_call_id,
+                content=find_packages_wrapper.on_failure_fn(),
+                additional_kwargs={"output": output},
+                status="error",
+            )
+
+        return Command(
+            update=state.sanitize_update(
+                ctx=ctx,
+                update={
+                    "agents_thoughts": [agent_thought, tool_message.content],
+                    EXECUTOR_MESSAGES_KEY: [tool_message],
+                },
+                agent="executor",
+            ),
+        )
+
+    return find_packages
+
+
+find_packages_wrapper = ToolWrapper(
+    tool_fn_getter=get_find_packages_tool,
+    on_success_fn=lambda thought, output: f"Packages found successfully ({thought}): {output}",
+    on_failure_fn=lambda: "Failed to find packages.",
+)

minitap/mobile_use/tools/mobile/input_text.py

@@ -1,17 +1,119 @@
-from typing import Optional
+from __future__ import annotations
+
+from typing import Literal
 
 from langchain_core.messages import ToolMessage
 from langchain_core.tools import tool
 from langchain_core.tools.base import InjectedToolCallId
+from langgraph.prebuilt import InjectedState
 from langgraph.types import Command
+from pydantic import BaseModel
+from typing_extensions import Annotated
+
+from minitap.mobile_use.constants import EXECUTOR_MESSAGES_KEY
+from minitap.mobile_use.context import MobileUseContext
+from minitap.mobile_use.controllers.mobile_command_controller import (
+    CoordinatesSelectorRequest,
+    IdSelectorRequest,
+    SelectorRequestWithCoordinates,
+    tap,
+)
 from minitap.mobile_use.controllers.mobile_command_controller import (
     input_text as input_text_controller,
 )
-from minitap.mobile_use.tools.tool_wrapper import ExecutorMetadata, ToolWrapper
-from typing_extensions import Annotated
 from minitap.mobile_use.graph.state import State
-from langgraph.prebuilt import InjectedState
-from minitap.mobile_use.context import MobileUseContext
+from minitap.mobile_use.tools.tool_wrapper import ToolWrapper
+from minitap.mobile_use.utils.logger import get_logger
+from minitap.mobile_use.utils.ui_hierarchy import (
+    Point,
+    find_element_by_resource_id,
+    get_bounds_for_element,
+    is_element_focused,
+)
+
+logger = get_logger(__name__)
+
+
+class InputResult(BaseModel):
+    """Result of an input operation from the controller layer."""
+
+    ok: bool
+    error: str | None = None
+
+
+def _focus_element_if_needed(
+    ctx: MobileUseContext,
+    state: State,
+    resource_id: str,
+) -> bool:
+    """
+    Ensures the element identified by `resource_id` is focused.
+    """
+    rich_hierarchy: list[dict] = ctx.hw_bridge_client.get_rich_hierarchy()
+    rich_elt = find_element_by_resource_id(
+        ui_hierarchy=rich_hierarchy,
+        resource_id=resource_id,
+        is_rich_hierarchy=True,
+    )
+    if rich_elt and not is_element_focused(rich_elt):
+        tap(ctx=ctx, selector_request=IdSelectorRequest(id=resource_id))
+        logger.debug(f"Focused (tap) on resource_id={resource_id}")
+        rich_hierarchy = ctx.hw_bridge_client.get_rich_hierarchy()
+        rich_elt = find_element_by_resource_id(
+            ui_hierarchy=rich_hierarchy,
+            resource_id=resource_id,
+            is_rich_hierarchy=True,
+        )
+    if rich_elt and is_element_focused(rich_elt):
+        logger.debug(f"Text input is focused: {resource_id}")
+        return True
+
+    logger.warning(f"Failed to focus resource_id={resource_id}")
+    return False
+
+
+def _move_cursor_to_end_if_bounds(
+    ctx: MobileUseContext,
+    state: State,
+    resource_id: str,
+) -> None:
+    """
+    Best-effort move of the text cursor near the end of the input by tapping the
+    bottom-right area of the focused element (if bounds are available).
+    """
+    elt = find_element_by_resource_id(
+        ui_hierarchy=state.latest_ui_hierarchy or [],
+        resource_id=resource_id,
+    )
+    if not elt:
+        return
+
+    bounds = get_bounds_for_element(elt)
+    if not bounds:
+        return
+
+    logger.debug("Tapping near the end of the input to move the cursor")
+    bottom_right: Point = bounds.get_relative_point(x_percent=0.99, y_percent=0.99)
+    tap(
+        ctx=ctx,
+        selector_request=SelectorRequestWithCoordinates(
+            coordinates=CoordinatesSelectorRequest(
+                x=bottom_right.x,
+                y=bottom_right.y,
+            ),
+        ),
+    )
+    logger.debug(f"Tapped end of input {resource_id} at ({bottom_right.x}, {bottom_right.y})")
+
+
+def _controller_input_text(ctx: MobileUseContext, text: str) -> InputResult:
+    """
+    Thin wrapper to normalize the controller result.
+    """
+    controller_out = input_text_controller(ctx=ctx, text=text)
+    if controller_out is None:
+        return InputResult(ok=True)
+    return InputResult(ok=False, error=str(controller_out))
 
 
 def get_input_text_tool(ctx: MobileUseContext):
@@ -20,47 +122,44 @@ def get_input_text_tool(ctx: MobileUseContext):
         tool_call_id: Annotated[str, InjectedToolCallId],
         state: Annotated[State, InjectedState],
         agent_thought: str,
-        executor_metadata: Optional[ExecutorMetadata],
         text: str,
+        text_input_resource_id: str,
     ):
         """
-        Inputs the specified text into the UI (works even if no field is focused).
+        Focus a text field and type text into it.
 
-        Example:
-            - inputText: "Hello World"
+        - Ensure the corresponding element is focused (tap if necessary).
+        - If bounds are available, tap near the end to place the cursor at the end.
+        - Type the provided `text` using the controller.
+        """
+        focused = _focus_element_if_needed(ctx=ctx, state=state, resource_id=text_input_resource_id)
+        if focused:
+            _move_cursor_to_end_if_bounds(ctx=ctx, state=state, resource_id=text_input_resource_id)
 
-        Notes:
-        - Unicode not supported on Android.
+        result = _controller_input_text(ctx=ctx, text=text)
 
-        Random Input Options:
-            - inputRandomEmail
-            - inputRandomPersonName
-            - inputRandomNumber (with optional 'length', default 8)
-            - inputRandomText (with optional 'length', default 8)
+        status: Literal["success", "error"] = "success" if result.ok else "error"
+        content_msg = (
+            input_text_wrapper.on_success_fn(text)
+            if result.ok
+            else input_text_wrapper.on_failure_fn(text)
+        )
 
-        Tip:
-            Use `copyTextFrom` to reuse generated inputs in later steps.
-        """
-        output = input_text_controller(ctx=ctx, text=text)
-        has_failed = output is not None
         tool_message = ToolMessage(
             tool_call_id=tool_call_id,
-            content=input_text_wrapper.on_failure_fn(text)
-            if has_failed
-            else input_text_wrapper.on_success_fn(text),
-            additional_kwargs={"error": output} if has_failed else {},
+            content=content_msg,
+            additional_kwargs={"error": result.error} if not result.ok else {},
+            status=status,
         )
+
         return Command(
-            update=input_text_wrapper.handle_executor_state_fields(
+            update=state.sanitize_update(
                 ctx=ctx,
-                state=state,
-                executor_metadata=executor_metadata,
-                tool_message=tool_message,
-                is_failure=has_failed,
-                updates={
+                update={
                     "agents_thoughts": [agent_thought],
-                    "messages": [tool_message],
+                    EXECUTOR_MESSAGES_KEY: [tool_message],
                 },
+                agent="executor",
             ),
         )
 

minitap/mobile_use/tools/mobile/launch_app.py

@@ -1,13 +1,12 @@
-from typing import Optional
-
 from langchain_core.messages import ToolMessage
 from langchain_core.tools import tool
 from langchain_core.tools.base import InjectedToolCallId
 from langgraph.types import Command
+from minitap.mobile_use.constants import EXECUTOR_MESSAGES_KEY
 from minitap.mobile_use.controllers.mobile_command_controller import (
     launch_app as launch_app_controller,
 )
-from minitap.mobile_use.tools.tool_wrapper import ExecutorMetadata, ToolWrapper
+from minitap.mobile_use.tools.tool_wrapper import ToolWrapper
 from typing_extensions import Annotated
 from minitap.mobile_use.context import MobileUseContext
 from minitap.mobile_use.graph.state import State
@@ -20,7 +19,6 @@ def get_launch_app_tool(ctx: MobileUseContext):
         tool_call_id: Annotated[str, InjectedToolCallId],
         state: Annotated[State, InjectedState],
         agent_thought: str,
-        executor_metadata: Optional[ExecutorMetadata],
         package_name: str,
     ):
         """
@@ -34,18 +32,16 @@ def get_launch_app_tool(ctx: MobileUseContext):
             if has_failed
             else launch_app_wrapper.on_success_fn(package_name),
             additional_kwargs={"error": output} if has_failed else {},
+            status="error" if has_failed else "success",
         )
         return Command(
-            update=launch_app_wrapper.handle_executor_state_fields(
+            update=state.sanitize_update(
                 ctx=ctx,
-                state=state,
-                executor_metadata=executor_metadata,
-                tool_message=tool_message,
-                is_failure=has_failed,
-                updates={
+                update={
                     "agents_thoughts": [agent_thought],
-                    "messages": [tool_message],
+                    EXECUTOR_MESSAGES_KEY: [tool_message],
                 },
+                agent="executor",
             ),
         )
 

minitap/mobile_use/tools/mobile/long_press_on.py

@@ -5,13 +5,14 @@ from langchain_core.tools import tool
 from langchain_core.tools.base import InjectedToolCallId
 from langgraph.prebuilt import InjectedState
 from langgraph.types import Command
+from minitap.mobile_use.constants import EXECUTOR_MESSAGES_KEY
 from minitap.mobile_use.context import MobileUseContext
 from minitap.mobile_use.controllers.mobile_command_controller import SelectorRequest
 from minitap.mobile_use.controllers.mobile_command_controller import (
     long_press_on as long_press_on_controller,
 )
 from minitap.mobile_use.graph.state import State
-from minitap.mobile_use.tools.tool_wrapper import ExecutorMetadata, ToolWrapper
+from minitap.mobile_use.tools.tool_wrapper import ToolWrapper
 from typing_extensions import Annotated
 
 
@@ -21,7 +22,6 @@ def get_long_press_on_tool(ctx: MobileUseContext):
         tool_call_id: Annotated[str, InjectedToolCallId],
         state: Annotated[State, InjectedState],
         agent_thought: str,
-        executor_metadata: Optional[ExecutorMetadata],
         selector_request: SelectorRequest,
         index: Optional[int] = None,
     ):
@@ -37,18 +37,16 @@ def get_long_press_on_tool(ctx: MobileUseContext):
             if has_failed
             else long_press_on_wrapper.on_success_fn(),
             additional_kwargs={"error": output} if has_failed else {},
+            status="error" if has_failed else "success",
         )
         return Command(
-            update=long_press_on_wrapper.handle_executor_state_fields(
+            update=state.sanitize_update(
                 ctx=ctx,
-                state=state,
-                executor_metadata=executor_metadata,
-                tool_message=tool_message,
-                is_failure=has_failed,
-                updates={
+                update={
                     "agents_thoughts": [agent_thought],
-                    "messages": [tool_message],
+                    EXECUTOR_MESSAGES_KEY: [tool_message],
                 },
+                agent="executor",
             ),
         )
 

minitap/mobile_use/tools/mobile/open_link.py

@@ -1,16 +1,15 @@
-from typing import Optional
-
 from langchain_core.messages import ToolMessage
 from langchain_core.tools import tool
 from langchain_core.tools.base import InjectedToolCallId
 from langgraph.prebuilt import InjectedState
 from langgraph.types import Command
+from minitap.mobile_use.constants import EXECUTOR_MESSAGES_KEY
 from minitap.mobile_use.context import MobileUseContext
 from minitap.mobile_use.controllers.mobile_command_controller import (
     open_link as open_link_controller,
 )
 from minitap.mobile_use.graph.state import State
-from minitap.mobile_use.tools.tool_wrapper import ExecutorMetadata, ToolWrapper
+from minitap.mobile_use.tools.tool_wrapper import ToolWrapper
 from typing_extensions import Annotated
 
 
@@ -20,7 +19,6 @@ def get_open_link_tool(ctx: MobileUseContext):
         tool_call_id: Annotated[str, InjectedToolCallId],
         state: Annotated[State, InjectedState],
         agent_thought: str,
-        executor_metadata: Optional[ExecutorMetadata],
         url: str,
     ):
         """
@@ -34,18 +32,16 @@ def get_open_link_tool(ctx: MobileUseContext):
             if has_failed
             else open_link_wrapper.on_success_fn(url),
             additional_kwargs={"error": output} if has_failed else {},
+            status="error" if has_failed else "success",
         )
         return Command(
-            update=open_link_wrapper.handle_executor_state_fields(
+            update=state.sanitize_update(
                 ctx=ctx,
-                state=state,
-                executor_metadata=executor_metadata,
-                tool_message=tool_message,
-                is_failure=has_failed,
-                updates={
+                update={
                     "agents_thoughts": [agent_thought],
-                    "messages": [tool_message],
+                    EXECUTOR_MESSAGES_KEY: [tool_message],
                 },
+                agent="executor",
             ),
         )