minitap-mobile-use 2.4.0__tar.gz → 2.5.0__tar.gz

{minitap_mobile_use-2.4.0 → minitap_mobile_use-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: minitap-mobile-use
-Version: 2.4.0
+Version: 2.5.0
 Summary: AI-powered multi-agent system that automates real Android and iOS devices through low-level control using LangGraph.
 Author: Pierre-Louis Favreau, Jean-Pierre Lo, Nicolas Dehandschoewercker
 License: MIT License

minitap_mobile_use-2.5.0/minitap/mobile_use/sdk/examples/platform_manual_task_example.py

@@ -0,0 +1,65 @@
+"""
+Platform Usage - Manual Task Creation Example
+
+This example demonstrates how to use the mobile-use SDK with manual task creation:
+- Agent with minitap_api_key
+- PlatformTaskRequest with ManualTaskConfig instead of task_id
+- Task configuration provided directly in code (goal, output_description)
+- No need to pre-create task in platform UI
+
+Platform Model:
+- API key provides authentication and agent configuration
+- ManualTaskConfig creates task on-the-fly with:
+  - max_steps: 400 (fixed)
+  - enable_remote_tracing: True (fixed)
+  - profile: "default" (fixed)
+  - goal: provided by you
+  - output_description: provided by you (optional)
+
+Run:
+- python src/mobile_use/sdk/examples/platform_manual_task_example.py
+"""
+
+import asyncio
+
+from minitap.mobile_use.sdk import Agent
+from minitap.mobile_use.sdk.types import ManualTaskConfig, PlatformTaskRequest
+
+
+async def main() -> None:
+    """
+    Main execution function demonstrating manual task creation pattern.
+
+    Visit https://platform.minitap.ai to get your API key.
+    Set MINITAP_API_KEY and MINITAP_API_BASE_URL environment variables.
+    """
+    agent = Agent()
+    agent.init()
+
+    # Example 1: Simple manual task
+    result = await agent.run_task(
+        request=PlatformTaskRequest(
+            task=ManualTaskConfig(
+                goal="Open the settings app and tell me the battery level",
+            ),
+            profile="default",  # Optional, defaults to "default"
+        )
+    )
+    print("Result 1:", result)
+
+    # Example 2: Manual task with output description
+    result = await agent.run_task(
+        request=PlatformTaskRequest(
+            task=ManualTaskConfig(
+                goal="Find the first 3 unread emails in Gmail",
+                output_description="A JSON array with sender and subject for each email",
+            ),
+        )
+    )
+    print("Result 2:", result)
+
+    agent.clean()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{minitap_mobile_use-2.4.0 → minitap_mobile_use-2.5.0}/minitap/mobile_use/sdk/services/platform.py

@@ -23,6 +23,7 @@ from minitap.mobile_use.sdk.types.platform import (
 )
 from minitap.mobile_use.sdk.types.task import (
     AgentProfile,
+    ManualTaskConfig,
     PlatformTaskInfo,
     PlatformTaskRequest,
     TaskRequest,
@@ -59,28 +60,61 @@ class PlatformService:
 
     async def create_task_run(self, request: PlatformTaskRequest) -> PlatformTaskInfo:
         try:
-            logger.info(f"Getting task: {request.task}")
-            response = await self._client.get(url=f"v1/tasks/{request.task}")
-            response.raise_for_status()
-            task_data = response.json()
-            task = TaskResponse(**task_data)
-            profile, agent_profile = await self._get_profile(
-                profile_name=request.profile or DEFAULT_PROFILE,
-            )
-            task_request = TaskRequest(
-                # Remote configuration
-                max_steps=task.options.max_steps,
-                goal=task.input_prompt,
-                output_description=task.output_description,
-                enable_remote_tracing=task.options.enable_tracing,
-                profile=profile.name,
-                # Local configuration
-                record_trace=request.record_trace,
-                trace_path=request.trace_path,
-                llm_output_path=request.llm_output_path,
-                thoughts_output_path=request.thoughts_output_path,
-            )
-            task_run = await self._create_task_run(task=task, profile=profile)
+            # Check if task is a string (fetch from platform) or ManualTaskConfig (create manually)
+            if isinstance(request.task, str):
+                # Fetch task from platform
+                logger.info(f"Getting task: {request.task}")
+                response = await self._client.get(url=f"v1/tasks/{request.task}")
+                response.raise_for_status()
+                task_data = response.json()
+                task = TaskResponse(**task_data)
+
+                profile, agent_profile = await self._get_profile(
+                    profile_name=request.profile or DEFAULT_PROFILE,
+                )
+
+                task_request = TaskRequest(
+                    # Remote configuration
+                    max_steps=task.options.max_steps,
+                    goal=task.input_prompt,
+                    output_description=task.output_description,
+                    enable_remote_tracing=task.options.enable_tracing,
+                    profile=profile.name,
+                    # Local configuration
+                    record_trace=request.record_trace,
+                    trace_path=request.trace_path,
+                    llm_output_path=request.llm_output_path,
+                    thoughts_output_path=request.thoughts_output_path,
+                )
+
+                task_run = await self._create_task_run(task=task, profile=profile)
+            else:
+                # Create task manually from ManualTaskConfig
+                logger.info(f"Creating manual task with goal: {request.task.goal}")
+
+                profile, agent_profile = await self._get_profile(
+                    profile_name=request.profile or DEFAULT_PROFILE,
+                )
+
+                task_request = TaskRequest(
+                    # Manual configuration
+                    max_steps=400,
+                    goal=request.task.goal,
+                    output_description=request.task.output_description,
+                    enable_remote_tracing=True,
+                    profile=DEFAULT_PROFILE,
+                    # Local configuration
+                    record_trace=request.record_trace,
+                    trace_path=request.trace_path,
+                    llm_output_path=request.llm_output_path,
+                    thoughts_output_path=request.thoughts_output_path,
+                )
+
+                task_run = await self._create_manual_task_run(
+                    manual_config=request.task,
+                    profile=profile,
+                )
+
             return PlatformTaskInfo(
                 task_request=task_request,
                 llm_profile=agent_profile,
@@ -226,6 +260,35 @@ class PlatformService:
         except httpx.HTTPStatusError as e:
             raise PlatformServiceError(message=f"Failed to create task run: {e}")
 
+    async def _create_manual_task_run(
+        self,
+        manual_config: ManualTaskConfig,
+        profile: LLMProfileResponse,
+    ) -> TaskRunResponse:
+        """
+        Create an orphan task run from a manual task configuration.
+        This creates a task run without a pre-existing task using the /orphan endpoint.
+        """
+        try:
+            logger.info(f"Creating orphan task run with goal: {manual_config.goal}")
+
+            # Create an orphan task run directly
+            orphan_payload = {
+                "inputPrompt": manual_config.goal,
+                "outputDescription": manual_config.output_description,
+                "llmProfileId": profile.id,
+            }
+
+            response = await self._client.post(url="v1/task-runs/orphan", json=orphan_payload)
+            response.raise_for_status()
+            task_run_data = response.json()
+            return TaskRunResponse(**task_run_data)
+
+        except ValidationError as e:
+            raise PlatformServiceError(message=f"API response validation error: {e}")
+        except httpx.HTTPStatusError as e:
+            raise PlatformServiceError(message=f"Failed to create orphan task run: {e}")
+
     async def _get_profile(self, profile_name: str) -> tuple[LLMProfileResponse, AgentProfile]:
         try:
             logger.info(f"Getting agent profile: {profile_name}")

{minitap_mobile_use-2.4.0 → minitap_mobile_use-2.5.0}/minitap/mobile_use/sdk/types/__init__.py

@@ -19,6 +19,7 @@ from minitap.mobile_use.sdk.types.exceptions import (
 )
 from minitap.mobile_use.sdk.types.task import (
     AgentProfile,
+    ManualTaskConfig,
     PlatformTaskRequest,
     Task,
     TaskRequest,
@@ -33,6 +34,7 @@ __all__ = [
     "AgentProfile",
     "ServerConfig",
     "TaskRequest",
+    "ManualTaskConfig",
     "PlatformTaskRequest",
     "TaskResult",
     "TaskRequestCommon",

{minitap_mobile_use-2.4.0 → minitap_mobile_use-2.5.0}/minitap/mobile_use/sdk/types/platform.py

@@ -1,8 +1,8 @@
+from datetime import datetime
 from typing import Annotated, Any, Literal
+
 from pydantic import BaseModel, ConfigDict, Field, PlainSerializer
 from pydantic.v1.utils import to_lower_camel
-from datetime import datetime
-
 
 TaskRunStatus = Literal["pending", "running", "completed", "failed", "cancelled"]
 
@@ -77,7 +77,9 @@ class TaskRunResponse(BaseApiModel):
     """Response model for a single task run."""
 
     id: str = Field(..., description="Unique identifier for the task run")
-    task: TaskResponse = Field(..., description="ID of the task this run is for")
+    task: TaskResponse | None = Field(
+        ..., description="ID of the task this run is for or None if manually created"
+    )
     llm_profile: LLMProfileResponse = Field(..., description="LLM profile ID used for this run")
     status: TaskRunStatus = Field(..., description="Current status of the task run")
     input_prompt: str = Field(..., description="Input prompt for this task run")

{minitap_mobile_use-2.4.0 → minitap_mobile_use-2.5.0}/minitap/mobile_use/sdk/types/task.py

@@ -105,18 +105,32 @@ class TaskRequest[TOutput](TaskRequestCommon):
     enable_remote_tracing: bool = False
 
 
+class ManualTaskConfig(BaseModel):
+    """
+    Configuration for manually creating a task without fetching from the platform.
+
+    Attributes:
+        goal: Natural language description of the goal to achieve
+        output_description: Optional natural language description of expected output format
+    """
+
+    goal: str
+    output_description: str | None = None
+
+
 class PlatformTaskRequest[TOutput](TaskRequestBase):
     """
     Minitap-specific task request for SDK usage via the gateway platform.
 
     Attributes:
-        task: Required task name specified by the user on the platform
+        task: Either a task name to fetch from the platform, or a
+              ManualTaskConfig to create manually
         profile: Optional profile name specified by the user on the platform
         api_key: Optional API key to authenticate with the platform
                  (overrides MINITAP_API_KEY env variable)
     """
 
-    task: str
+    task: str | ManualTaskConfig
     profile: str | None = None
     api_key: str | None = None
 
@@ -214,7 +228,11 @@ class Task(BaseModel):
 
     def get_name(self) -> str:
         if isinstance(self.request, PlatformTaskRequest):
-            return self.request.task
+            if isinstance(self.request.task, str):
+                return self.request.task
+            else:
+                # ManualTaskConfig - use first 50 chars of goal
+                return f"Manual: {self.request.task.goal[:50]}"
         return self.request.task_name or self.id
 
     async def set_status(

{minitap_mobile_use-2.4.0 → minitap_mobile_use-2.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "minitap-mobile-use"
-version = "2.4.0"
+version = "2.5.0"
 description = "AI-powered multi-agent system that automates real Android and iOS devices through low-level control using LangGraph."
 readme = "README.md"
 license = { file = "LICENSE" }