@mobilerun/sdk 1.0.0

package/resources/tasks/tasks.d.mts

@@ -0,0 +1,973 @@
+import { APIResource } from "../../core/resource.mjs";
+import * as ScreenshotsAPI from "./screenshots.mjs";
+import { MediaResponse, ScreenshotListResponse, ScreenshotRetrieveParams, Screenshots } from "./screenshots.mjs";
+import * as UiStatesAPI from "./ui-states.mjs";
+import { UiStateListResponse, UiStateRetrieveParams, UiStates } from "./ui-states.mjs";
+import { APIPromise } from "../../core/api-promise.mjs";
+import { RequestOptions } from "../../internal/request-options.mjs";
+export declare class Tasks extends APIResource {
+    screenshots: ScreenshotsAPI.Screenshots;
+    uiStates: UiStatesAPI.UiStates;
+    /**
+     * Get Task
+     */
+    retrieve(taskID: string, options?: RequestOptions): APIPromise<TaskRetrieveResponse>;
+    /**
+     * List all tasks you've created so far
+     */
+    list(query?: TaskListParams | null | undefined, options?: RequestOptions): APIPromise<TaskListResponse>;
+    /**
+     * Attach Task
+     */
+    attach(taskID: string, options?: RequestOptions): APIPromise<void>;
+    /**
+     * Get the status of a task. If device is provided, return the status of the
+     * specific device. Otherwise, return the status of all devices.
+     */
+    getStatus(taskID: string, options?: RequestOptions): APIPromise<TaskGetStatusResponse>;
+    /**
+     * Get the trajectory of a task.
+     */
+    getTrajectory(taskID: string, options?: RequestOptions): APIPromise<TaskGetTrajectoryResponse>;
+    /**
+     * Run Task
+     */
+    run(body: TaskRunParams, options?: RequestOptions): APIPromise<TaskRunResponse>;
+    /**
+     * Run Streamed Task
+     */
+    runStreamed(body: TaskRunStreamedParams, options?: RequestOptions): APIPromise<void>;
+    /**
+     * Stop Task
+     */
+    stop(taskID: string, options?: RequestOptions): APIPromise<TaskStopResponse>;
+}
+export type LlmModel = 'openai/gpt-5' | 'google/gemini-2.5-flash' | 'google/gemini-2.5-pro' | 'google/gemini-3-pro-preview' | 'anthropic/claude-sonnet-4.5' | 'minimax/minimax-m2' | 'moonshotai/kimi-k2-thinking';
+export interface Task {
+    deviceId: string;
+    llmModel: LlmModel;
+    task: string;
+    userId: string;
+    id?: string;
+    apps?: Array<string>;
+    createdAt?: string;
+    credentials?: Array<Task.Credential>;
+    executionTimeout?: number;
+    files?: Array<string>;
+    finishedAt?: string | null;
+    maxSteps?: number;
+    output?: {
+        [key: string]: unknown;
+    } | null;
+    outputSchema?: {
+        [key: string]: unknown;
+    } | null;
+    reasoning?: boolean;
+    status?: TaskStatus;
+    steps?: number | null;
+    succeeded?: boolean | null;
+    temperature?: number;
+    trajectory?: Array<{
+        [key: string]: unknown;
+    }>;
+    updatedAt?: string;
+    vision?: boolean;
+    vpnCountry?: 'US' | 'BR' | 'FR' | 'DE' | 'IN' | 'JP' | 'KR' | 'ZA' | null;
+}
+export declare namespace Task {
+    interface Credential {
+        credentialNames: Array<string>;
+        packageName: string;
+    }
+}
+export interface TaskCreate {
+    llmModel: LlmModel;
+    task: string;
+    apps?: Array<string>;
+    credentials?: Array<TaskCreate.Credential>;
+    executionTimeout?: number;
+    files?: Array<string>;
+    maxSteps?: number;
+    outputSchema?: {
+        [key: string]: unknown;
+    } | null;
+    reasoning?: boolean;
+    temperature?: number;
+    vision?: boolean;
+    vpnCountry?: 'US' | 'BR' | 'FR' | 'DE' | 'IN' | 'JP' | 'KR' | 'ZA' | null;
+}
+export declare namespace TaskCreate {
+    interface Credential {
+        credentialNames: Array<string>;
+        packageName: string;
+    }
+}
+export type TaskStatus = 'created' | 'running' | 'paused' | 'completed' | 'failed' | 'cancelled';
+export interface TaskRetrieveResponse {
+    /**
+     * The task
+     */
+    task: Task;
+}
+export interface TaskListResponse {
+    /**
+     * The paginated items
+     */
+    items: Array<Task>;
+    /**
+     * Pagination metadata
+     */
+    pagination: TaskListResponse.Pagination;
+}
+export declare namespace TaskListResponse {
+    /**
+     * Pagination metadata
+     */
+    interface Pagination {
+        /**
+         * Whether there is a next page
+         */
+        hasNext: boolean;
+        /**
+         * Whether there is a previous page
+         */
+        hasPrev: boolean;
+        /**
+         * Current page number (1-based)
+         */
+        page: number;
+        /**
+         * Total number of pages
+         */
+        pages: number;
+        /**
+         * Number of items per page
+         */
+        pageSize: number;
+        /**
+         * Total number of items
+         */
+        total: number;
+    }
+}
+export interface TaskGetStatusResponse {
+    /**
+     * The status of the task
+     */
+    status: TaskStatus;
+}
+export interface TaskGetTrajectoryResponse {
+    /**
+     * The trajectory of the task
+     */
+    trajectory: Array<TaskGetTrajectoryResponse.TrajectoryCreatedEvent | TaskGetTrajectoryResponse.TrajectoryExceptionEvent | TaskGetTrajectoryResponse.TrajectoryCancelEvent | TaskGetTrajectoryResponse.TrajectoryScreenshotEvent | TaskGetTrajectoryResponse.TrajectoryStartEvent | TaskGetTrajectoryResponse.TrajectoryTaskRunnerEvent | TaskGetTrajectoryResponse.TrajectoryFinalizeEvent | TaskGetTrajectoryResponse.TrajectoryStopEvent | TaskGetTrajectoryResponse.TrajectoryResultEvent | TaskGetTrajectoryResponse.TrajectoryManagerInputEvent | TaskGetTrajectoryResponse.TrajectoryManagerPlanEvent | TaskGetTrajectoryResponse.TrajectoryExecutorInputEvent | TaskGetTrajectoryResponse.TrajectoryExecutorResultEvent | TaskGetTrajectoryResponse.TrajectoryScripterExecutorInputEvent | TaskGetTrajectoryResponse.TrajectoryScripterExecutorResultEvent | TaskGetTrajectoryResponse.TrajectoryPlanCreatedEvent | TaskGetTrajectoryResponse.TrajectoryPlanInputEvent | TaskGetTrajectoryResponse.TrajectoryPlanThinkingEvent | TaskGetTrajectoryResponse.TrajectoryTaskThinkingEvent | TaskGetTrajectoryResponse.TrajectoryTaskExecutionEvent | TaskGetTrajectoryResponse.TrajectoryTaskExecutionResultEvent | TaskGetTrajectoryResponse.TrajectoryTaskEndEvent | TaskGetTrajectoryResponse.TrajectoryCodeActExecuteEvent | TaskGetTrajectoryResponse.TrajectoryCodeActResultEvent | TaskGetTrajectoryResponse.TrajectoryTapActionEvent | TaskGetTrajectoryResponse.TrajectorySwipeActionEvent | TaskGetTrajectoryResponse.TrajectoryDragActionEvent | TaskGetTrajectoryResponse.TrajectoryInputTextActionEvent | TaskGetTrajectoryResponse.TrajectoryKeyPressActionEvent | TaskGetTrajectoryResponse.TrajectoryStartAppEvent | TaskGetTrajectoryResponse.TrajectoryRecordUiStateEvent | TaskGetTrajectoryResponse.TrajectoryWaitEvent | TaskGetTrajectoryResponse.TrajectoryManagerContextEvent | TaskGetTrajectoryResponse.TrajectoryManagerResponseEvent | TaskGetTrajectoryResponse.TrajectoryManagerPlanDetailsEvent | TaskGetTrajectoryResponse.TrajectoryExecutorContextEvent | TaskGetTrajectoryResponse.TrajectoryExecutorResponseEvent | TaskGetTrajectoryResponse.TrajectoryExecutorActionEvent | TaskGetTrajectoryResponse.TrajectoryExecutorActionResultEvent | TaskGetTrajectoryResponse.TrajectoryScripterInputEvent | TaskGetTrajectoryResponse.TrajectoryScripterThinkingEvent | TaskGetTrajectoryResponse.TrajectoryScripterExecutionEvent | TaskGetTrajectoryResponse.TrajectoryScripterExecutionResultEvent | TaskGetTrajectoryResponse.TrajectoryScripterEndEvent | TaskGetTrajectoryResponse.TrajectoryTextManipulatorInputEvent | TaskGetTrajectoryResponse.TrajectoryTextManipulatorResultEvent>;
+}
+export declare namespace TaskGetTrajectoryResponse {
+    interface TrajectoryCreatedEvent {
+        data: TrajectoryCreatedEvent.Data;
+        event: 'CreatedEvent';
+    }
+    namespace TrajectoryCreatedEvent {
+        interface Data {
+            id: string;
+            token: string;
+            streamUrl: string;
+        }
+    }
+    interface TrajectoryExceptionEvent {
+        data: TrajectoryExceptionEvent.Data;
+        event: 'ExceptionEvent';
+    }
+    namespace TrajectoryExceptionEvent {
+        interface Data {
+            exception: string;
+        }
+    }
+    interface TrajectoryCancelEvent {
+        data: TrajectoryCancelEvent.Data;
+        event: 'CancelEvent';
+    }
+    namespace TrajectoryCancelEvent {
+        interface Data {
+            reason: string;
+        }
+    }
+    interface TrajectoryScreenshotEvent {
+        data: TrajectoryScreenshotEvent.Data;
+        event: 'ScreenshotEvent';
+    }
+    namespace TrajectoryScreenshotEvent {
+        interface Data {
+            index: number;
+            url: string;
+        }
+    }
+    interface TrajectoryStartEvent {
+        /**
+         * Implicit entry event sent to kick off a `Workflow.run()`.
+         */
+        data: unknown;
+        event: 'StartEvent';
+    }
+    interface TrajectoryTaskRunnerEvent {
+        data: unknown;
+        event: 'TaskRunnerEvent';
+    }
+    interface TrajectoryFinalizeEvent {
+        data: TrajectoryFinalizeEvent.Data;
+        event: 'FinalizeEvent';
+    }
+    namespace TrajectoryFinalizeEvent {
+        interface Data {
+            reason: string;
+            success: boolean;
+        }
+    }
+    interface TrajectoryStopEvent {
+        /**
+         * Terminal event that signals the workflow has completed.
+         *
+         * The `result` property contains the return value of the workflow run. When a
+         * custom stop event subclass is used, the workflow result is that event instance
+         * itself.
+         *
+         * Examples:
+         * `python # default stop event: result holds the value return StopEvent(result={"answer": 42}) `
+         *
+         *     Subclassing to provide a custom result:
+         *
+         *     ```python
+         *     class MyStopEv(StopEvent):
+         *         pass
+         *
+         *     @step
+         *     async def my_step(self, ctx: Context, ev: StartEvent) -> MyStopEv:
+         *         return MyStopEv(result={"answer": 42})
+         */
+        data: unknown;
+        event: 'StopEvent';
+    }
+    interface TrajectoryResultEvent {
+        data: {
+            [key: string]: unknown;
+        };
+        event: 'ResultEvent';
+    }
+    interface TrajectoryManagerInputEvent {
+        /**
+         * Trigger Manager workflow for planning
+         */
+        data: unknown;
+        event: 'ManagerInputEvent';
+    }
+    interface TrajectoryManagerPlanEvent {
+        /**
+         * Coordination event from ManagerAgent to DroidAgent.
+         *
+         * Used for workflow step routing only (NOT streamed to frontend). For internal
+         * events with memory_update metadata, see ManagerPlanDetailsEvent.
+         */
+        data: TrajectoryManagerPlanEvent.Data;
+        event: 'ManagerPlanEvent';
+    }
+    namespace TrajectoryManagerPlanEvent {
+        /**
+         * Coordination event from ManagerAgent to DroidAgent.
+         *
+         * Used for workflow step routing only (NOT streamed to frontend). For internal
+         * events with memory_update metadata, see ManagerPlanDetailsEvent.
+         */
+        interface Data {
+            current_subgoal: string;
+            plan: string;
+            thought: string;
+            manager_answer?: string;
+            success?: boolean | null;
+        }
+    }
+    interface TrajectoryExecutorInputEvent {
+        /**
+         * Trigger Executor workflow for action execution
+         */
+        data: TrajectoryExecutorInputEvent.Data;
+        event: 'ExecutorInputEvent';
+    }
+    namespace TrajectoryExecutorInputEvent {
+        /**
+         * Trigger Executor workflow for action execution
+         */
+        interface Data {
+            current_subgoal: string;
+        }
+    }
+    interface TrajectoryExecutorResultEvent {
+        /**
+         * Coordination event from ExecutorAgent to DroidAgent.
+         *
+         * Used for workflow step routing only (NOT streamed to frontend). For internal
+         * events with thought/action_json metadata, see ExecutorActionResultEvent.
+         */
+        data: TrajectoryExecutorResultEvent.Data;
+        event: 'ExecutorResultEvent';
+    }
+    namespace TrajectoryExecutorResultEvent {
+        /**
+         * Coordination event from ExecutorAgent to DroidAgent.
+         *
+         * Used for workflow step routing only (NOT streamed to frontend). For internal
+         * events with thought/action_json metadata, see ExecutorActionResultEvent.
+         */
+        interface Data {
+            action: {
+                [key: string]: unknown;
+            };
+            error: string;
+            outcome: boolean;
+            summary: string;
+            full_response?: string;
+        }
+    }
+    interface TrajectoryScripterExecutorInputEvent {
+        /**
+         * Trigger ScripterAgent workflow for off-device operations
+         */
+        data: TrajectoryScripterExecutorInputEvent.Data;
+        event: 'ScripterExecutorInputEvent';
+    }
+    namespace TrajectoryScripterExecutorInputEvent {
+        /**
+         * Trigger ScripterAgent workflow for off-device operations
+         */
+        interface Data {
+            task: string;
+        }
+    }
+    interface TrajectoryScripterExecutorResultEvent {
+        /**
+         * Coordination event from ScripterAgent to DroidAgent.
+         *
+         * Used for workflow step routing only (NOT streamed to frontend).
+         */
+        data: TrajectoryScripterExecutorResultEvent.Data;
+        event: 'ScripterExecutorResultEvent';
+    }
+    namespace TrajectoryScripterExecutorResultEvent {
+        /**
+         * Coordination event from ScripterAgent to DroidAgent.
+         *
+         * Used for workflow step routing only (NOT streamed to frontend).
+         */
+        interface Data {
+            code_executions: number;
+            message: string;
+            success: boolean;
+            task: string;
+        }
+    }
+    interface TrajectoryPlanCreatedEvent {
+        data: {
+            [key: string]: unknown;
+        };
+        event: 'PlanCreatedEvent';
+    }
+    interface TrajectoryPlanInputEvent {
+        data: {
+            [key: string]: unknown;
+        };
+        event: 'PlanInputEvent';
+    }
+    interface TrajectoryPlanThinkingEvent {
+        data: {
+            [key: string]: unknown;
+        };
+        event: 'PlanThinkingEvent';
+    }
+    interface TrajectoryTaskThinkingEvent {
+        data: TrajectoryTaskThinkingEvent.Data;
+        event: 'TaskThinkingEvent';
+    }
+    namespace TrajectoryTaskThinkingEvent {
+        interface Data {
+            code?: string | null;
+            thoughts?: string | null;
+            usage?: Data.Usage | null;
+        }
+        namespace Data {
+            interface Usage {
+                request_tokens: number;
+                requests: number;
+                response_tokens: number;
+                total_tokens: number;
+            }
+        }
+    }
+    interface TrajectoryTaskExecutionEvent {
+        data: TrajectoryTaskExecutionEvent.Data;
+        event: 'TaskExecutionEvent';
+    }
+    namespace TrajectoryTaskExecutionEvent {
+        interface Data {
+            code: string;
+            globals?: {
+                [key: string]: string;
+            };
+            locals?: {
+                [key: string]: string;
+            };
+        }
+    }
+    interface TrajectoryTaskExecutionResultEvent {
+        data: TrajectoryTaskExecutionResultEvent.Data;
+        event: 'TaskExecutionResultEvent';
+    }
+    namespace TrajectoryTaskExecutionResultEvent {
+        interface Data {
+            output: string;
+        }
+    }
+    interface TrajectoryTaskEndEvent {
+        data: TrajectoryTaskEndEvent.Data;
+        event: 'TaskEndEvent';
+    }
+    namespace TrajectoryTaskEndEvent {
+        interface Data {
+            reason: string;
+            success: boolean;
+        }
+    }
+    interface TrajectoryCodeActExecuteEvent {
+        data: TrajectoryCodeActExecuteEvent.Data;
+        event: 'CodeActExecuteEvent';
+    }
+    namespace TrajectoryCodeActExecuteEvent {
+        interface Data {
+            instruction: string;
+        }
+    }
+    interface TrajectoryCodeActResultEvent {
+        data: TrajectoryCodeActResultEvent.Data;
+        event: 'CodeActResultEvent';
+    }
+    namespace TrajectoryCodeActResultEvent {
+        interface Data {
+            instruction: string;
+            reason: string;
+            success: boolean;
+        }
+    }
+    interface TrajectoryTapActionEvent {
+        /**
+         * Event for tap actions with coordinates
+         */
+        data: TrajectoryTapActionEvent.Data;
+        event: 'TapActionEvent';
+    }
+    namespace TrajectoryTapActionEvent {
+        /**
+         * Event for tap actions with coordinates
+         */
+        interface Data {
+            action_type: string;
+            description: string;
+            x: number;
+            y: number;
+            element_bounds?: string;
+            element_index?: number;
+            element_text?: string;
+        }
+    }
+    interface TrajectorySwipeActionEvent {
+        /**
+         * Event for swipe actions with coordinates
+         */
+        data: TrajectorySwipeActionEvent.Data;
+        event: 'SwipeActionEvent';
+    }
+    namespace TrajectorySwipeActionEvent {
+        /**
+         * Event for swipe actions with coordinates
+         */
+        interface Data {
+            action_type: string;
+            description: string;
+            duration_ms: number;
+            end_x: number;
+            end_y: number;
+            start_x: number;
+            start_y: number;
+        }
+    }
+    interface TrajectoryDragActionEvent {
+        /**
+         * Event for drag actions with coordinates
+         */
+        data: TrajectoryDragActionEvent.Data;
+        event: 'DragActionEvent';
+    }
+    namespace TrajectoryDragActionEvent {
+        /**
+         * Event for drag actions with coordinates
+         */
+        interface Data {
+            action_type: string;
+            description: string;
+            duration_ms: number;
+            end_x: number;
+            end_y: number;
+            start_x: number;
+            start_y: number;
+        }
+    }
+    interface TrajectoryInputTextActionEvent {
+        /**
+         * Event for text input actions
+         */
+        data: TrajectoryInputTextActionEvent.Data;
+        event: 'InputTextActionEvent';
+    }
+    namespace TrajectoryInputTextActionEvent {
+        /**
+         * Event for text input actions
+         */
+        interface Data {
+            action_type: string;
+            description: string;
+            text: string;
+        }
+    }
+    interface TrajectoryKeyPressActionEvent {
+        /**
+         * Event for key press actions
+         */
+        data: TrajectoryKeyPressActionEvent.Data;
+        event: 'KeyPressActionEvent';
+    }
+    namespace TrajectoryKeyPressActionEvent {
+        /**
+         * Event for key press actions
+         */
+        interface Data {
+            action_type: string;
+            description: string;
+            keycode: number;
+            key_name?: string;
+        }
+    }
+    interface TrajectoryStartAppEvent {
+        /**
+         * "Event for starting an app
+         */
+        data: TrajectoryStartAppEvent.Data;
+        event: 'StartAppEvent';
+    }
+    namespace TrajectoryStartAppEvent {
+        /**
+         * "Event for starting an app
+         */
+        interface Data {
+            action_type: string;
+            description: string;
+            package: string;
+            activity?: string;
+        }
+    }
+    interface TrajectoryRecordUiStateEvent {
+        data: TrajectoryRecordUiStateEvent.Data;
+        event: 'RecordUIStateEvent';
+    }
+    namespace TrajectoryRecordUiStateEvent {
+        interface Data {
+            index: number;
+            url: string;
+        }
+    }
+    interface TrajectoryWaitEvent {
+        /**
+         * Event for wait/sleep actions
+         */
+        data: TrajectoryWaitEvent.Data;
+        event: 'WaitEvent';
+    }
+    namespace TrajectoryWaitEvent {
+        /**
+         * Event for wait/sleep actions
+         */
+        interface Data {
+            action_type: string;
+            description: string;
+            duration: number;
+        }
+    }
+    interface TrajectoryManagerContextEvent {
+        /**
+         * Manager context prepared, ready for LLM call
+         */
+        data: unknown;
+        event: 'ManagerContextEvent';
+    }
+    interface TrajectoryManagerResponseEvent {
+        /**
+         * Manager has received LLM response, ready for parsing.
+         *
+         * This event carries the raw validated LLM output before parsing.
+         */
+        data: TrajectoryManagerResponseEvent.Data;
+        event: 'ManagerResponseEvent';
+    }
+    namespace TrajectoryManagerResponseEvent {
+        /**
+         * Manager has received LLM response, ready for parsing.
+         *
+         * This event carries the raw validated LLM output before parsing.
+         */
+        interface Data {
+            output_planning: string;
+            usage?: Data.Usage | null;
+        }
+        namespace Data {
+            interface Usage {
+                request_tokens: number;
+                requests: number;
+                response_tokens: number;
+                total_tokens: number;
+            }
+        }
+    }
+    interface TrajectoryManagerPlanDetailsEvent {
+        /**
+         * Manager planning event with full state and metadata.
+         *
+         * This event is streamed to frontend/logging but NOT used for workflow
+         * coordination between ManagerAgent and DroidAgent.
+         *
+         * For workflow coordination, see ManagerPlanEvent in droid/events.py
+         */
+        data: TrajectoryManagerPlanDetailsEvent.Data;
+        event: 'ManagerPlanDetailsEvent';
+    }
+    namespace TrajectoryManagerPlanDetailsEvent {
+        /**
+         * Manager planning event with full state and metadata.
+         *
+         * This event is streamed to frontend/logging but NOT used for workflow
+         * coordination between ManagerAgent and DroidAgent.
+         *
+         * For workflow coordination, see ManagerPlanEvent in droid/events.py
+         */
+        interface Data {
+            current_subgoal: string;
+            plan: string;
+            thought: string;
+            full_response?: string;
+            manager_answer?: string;
+            memory_update?: string;
+            success?: boolean | null;
+        }
+    }
+    interface TrajectoryExecutorContextEvent {
+        /**
+         * Executor context prepared, ready for LLM call
+         */
+        data: TrajectoryExecutorContextEvent.Data;
+        event: 'ExecutorContextEvent';
+    }
+    namespace TrajectoryExecutorContextEvent {
+        /**
+         * Executor context prepared, ready for LLM call
+         */
+        interface Data {
+            messages: Array<unknown>;
+            subgoal: string;
+        }
+    }
+    interface TrajectoryExecutorResponseEvent {
+        /**
+         * Executor has received LLM response, ready for parsing.
+         *
+         * This event carries the raw LLM output before parsing.
+         */
+        data: TrajectoryExecutorResponseEvent.Data;
+        event: 'ExecutorResponseEvent';
+    }
+    namespace TrajectoryExecutorResponseEvent {
+        /**
+         * Executor has received LLM response, ready for parsing.
+         *
+         * This event carries the raw LLM output before parsing.
+         */
+        interface Data {
+            response_text: string;
+            usage?: Data.Usage | null;
+        }
+        namespace Data {
+            interface Usage {
+                request_tokens: number;
+                requests: number;
+                response_tokens: number;
+                total_tokens: number;
+            }
+        }
+    }
+    interface TrajectoryExecutorActionEvent {
+        /**
+         * Executor action selection event with thought process.
+         *
+         * This event is streamed to frontend/logging but NOT used for workflow
+         * coordination between ExecutorAgent and DroidAgent.
+         *
+         * For workflow coordination, see ExecutorInputEvent in droid/events.py
+         */
+        data: TrajectoryExecutorActionEvent.Data;
+        event: 'ExecutorActionEvent';
+    }
+    namespace TrajectoryExecutorActionEvent {
+        /**
+         * Executor action selection event with thought process.
+         *
+         * This event is streamed to frontend/logging but NOT used for workflow
+         * coordination between ExecutorAgent and DroidAgent.
+         *
+         * For workflow coordination, see ExecutorInputEvent in droid/events.py
+         */
+        interface Data {
+            action_json: string;
+            description: string;
+            thought: string;
+            full_response?: string;
+        }
+    }
+    interface TrajectoryExecutorActionResultEvent {
+        /**
+         * Executor action result event with full debug information.
+         *
+         * This event is streamed to frontend/logging but NOT used for workflow
+         * coordination between ExecutorAgent and DroidAgent.
+         *
+         * For workflow coordination, see ExecutorResultEvent in droid/events.py
+         */
+        data: TrajectoryExecutorActionResultEvent.Data;
+        event: 'ExecutorActionResultEvent';
+    }
+    namespace TrajectoryExecutorActionResultEvent {
+        /**
+         * Executor action result event with full debug information.
+         *
+         * This event is streamed to frontend/logging but NOT used for workflow
+         * coordination between ExecutorAgent and DroidAgent.
+         *
+         * For workflow coordination, see ExecutorResultEvent in droid/events.py
+         */
+        interface Data {
+            action: {
+                [key: string]: unknown;
+            };
+            error: string;
+            outcome: boolean;
+            summary: string;
+            action_json?: string;
+            full_response?: string;
+            thought?: string;
+        }
+    }
+    interface TrajectoryScripterInputEvent {
+        /**
+         * Input to LLM (chat history).
+         */
+        data: TrajectoryScripterInputEvent.Data;
+        event: 'ScripterInputEvent';
+    }
+    namespace TrajectoryScripterInputEvent {
+        /**
+         * Input to LLM (chat history).
+         */
+        interface Data {
+            input: Array<unknown>;
+        }
+    }
+    interface TrajectoryScripterThinkingEvent {
+        /**
+         * LLM generated thought + code.
+         */
+        data: TrajectoryScripterThinkingEvent.Data;
+        event: 'ScripterThinkingEvent';
+    }
+    namespace TrajectoryScripterThinkingEvent {
+        /**
+         * LLM generated thought + code.
+         */
+        interface Data {
+            thoughts: string;
+            code?: string | null;
+            full_response?: string;
+            usage?: Data.Usage | null;
+        }
+        namespace Data {
+            interface Usage {
+                request_tokens: number;
+                requests: number;
+                response_tokens: number;
+                total_tokens: number;
+            }
+        }
+    }
+    interface TrajectoryScripterExecutionEvent {
+        /**
+         * Trigger code execution.
+         */
+        data: TrajectoryScripterExecutionEvent.Data;
+        event: 'ScripterExecutionEvent';
+    }
+    namespace TrajectoryScripterExecutionEvent {
+        /**
+         * Trigger code execution.
+         */
+        interface Data {
+            code: string;
+        }
+    }
+    interface TrajectoryScripterExecutionResultEvent {
+        /**
+         * Code execution result.
+         */
+        data: TrajectoryScripterExecutionResultEvent.Data;
+        event: 'ScripterExecutionResultEvent';
+    }
+    namespace TrajectoryScripterExecutionResultEvent {
+        /**
+         * Code execution result.
+         */
+        interface Data {
+            output: string;
+        }
+    }
+    interface TrajectoryScripterEndEvent {
+        /**
+         * Script agent finished.
+         */
+        data: TrajectoryScripterEndEvent.Data;
+        event: 'ScripterEndEvent';
+    }
+    namespace TrajectoryScripterEndEvent {
+        /**
+         * Script agent finished.
+         */
+        interface Data {
+            message: string;
+            success: boolean;
+            code_executions?: number;
+        }
+    }
+    interface TrajectoryTextManipulatorInputEvent {
+        /**
+         * Trigger TextManipulatorAgent workflow for text manipulation
+         */
+        data: TrajectoryTextManipulatorInputEvent.Data;
+        event: 'TextManipulatorInputEvent';
+    }
+    namespace TrajectoryTextManipulatorInputEvent {
+        /**
+         * Trigger TextManipulatorAgent workflow for text manipulation
+         */
+        interface Data {
+            task: string;
+        }
+    }
+    interface TrajectoryTextManipulatorResultEvent {
+        data: TrajectoryTextManipulatorResultEvent.Data;
+        event: 'TextManipulatorResultEvent';
+    }
+    namespace TrajectoryTextManipulatorResultEvent {
+        interface Data {
+            code_ran: string;
+            task: string;
+            text_to_type: string;
+        }
+    }
+}
+export interface TaskRunResponse {
+    /**
+     * The ID of the task
+     */
+    id: string;
+    /**
+     * The token of the stream
+     */
+    token: string;
+    /**
+     * The URL of the stream
+     */
+    streamUrl: string;
+}
+export interface TaskStopResponse {
+    /**
+     * Whether the task was cancelled
+     */
+    cancelled: boolean;
+}
+export interface TaskListParams {
+    orderBy?: 'id' | 'createdAt' | 'finishedAt' | 'status' | null;
+    orderByDirection?: 'asc' | 'desc';
+    /**
+     * Page number (1-based). If provided, returns paginated results.
+     */
+    page?: number | null;
+    /**
+     * Number of items per page
+     */
+    pageSize?: number;
+    /**
+     * Search in task description.
+     */
+    query?: string | null;
+    status?: TaskStatus | null;
+}
+export interface TaskRunParams {
+    llmModel: LlmModel;
+    task: string;
+    apps?: Array<string>;
+    credentials?: Array<TaskRunParams.Credential>;
+    executionTimeout?: number;
+    files?: Array<string>;
+    maxSteps?: number;
+    outputSchema?: {
+        [key: string]: unknown;
+    } | null;
+    reasoning?: boolean;
+    temperature?: number;
+    vision?: boolean;
+    vpnCountry?: 'US' | 'BR' | 'FR' | 'DE' | 'IN' | 'JP' | 'KR' | 'ZA' | null;
+}
+export declare namespace TaskRunParams {
+    interface Credential {
+        credentialNames: Array<string>;
+        packageName: string;
+    }
+}
+export interface TaskRunStreamedParams {
+    llmModel: LlmModel;
+    task: string;
+    apps?: Array<string>;
+    credentials?: Array<TaskRunStreamedParams.Credential>;
+    executionTimeout?: number;
+    files?: Array<string>;
+    maxSteps?: number;
+    outputSchema?: {
+        [key: string]: unknown;
+    } | null;
+    reasoning?: boolean;
+    temperature?: number;
+    vision?: boolean;
+    vpnCountry?: 'US' | 'BR' | 'FR' | 'DE' | 'IN' | 'JP' | 'KR' | 'ZA' | null;
+}
+export declare namespace TaskRunStreamedParams {
+    interface Credential {
+        credentialNames: Array<string>;
+        packageName: string;
+    }
+}
+export declare namespace Tasks {
+    export { type LlmModel as LlmModel, type Task as Task, type TaskCreate as TaskCreate, type TaskStatus as TaskStatus, type TaskRetrieveResponse as TaskRetrieveResponse, type TaskListResponse as TaskListResponse, type TaskGetStatusResponse as TaskGetStatusResponse, type TaskGetTrajectoryResponse as TaskGetTrajectoryResponse, type TaskRunResponse as TaskRunResponse, type TaskStopResponse as TaskStopResponse, type TaskListParams as TaskListParams, type TaskRunParams as TaskRunParams, type TaskRunStreamedParams as TaskRunStreamedParams, };
+    export { Screenshots as Screenshots, type MediaResponse as MediaResponse, type ScreenshotListResponse as ScreenshotListResponse, type ScreenshotRetrieveParams as ScreenshotRetrieveParams, };
+    export { UiStates as UiStates, type UiStateListResponse as UiStateListResponse, type UiStateRetrieveParams as UiStateRetrieveParams, };
+}
+//# sourceMappingURL=tasks.d.mts.map