@midscene/core 1.9.8 → 1.10.0

package/dist/types/ai-model/models/auto-glm/planning.d.ts

@@ -1,4 +1,5 @@
-import { type TUserPrompt } from '../../../common';
-import type { PlanningAIResponse } from '../../../types';
-import type { PlanOptions } from '../../workflows/planning/types';
-export declare function autoGlmPlanning(userInstruction: TUserPrompt, options: PlanOptions, getSystemPrompt: () => string): Promise<PlanningAIResponse>;
+import type { CustomPlanningDefinition } from '../../model-adapter/custom-planning-types';
+import { parseAutoGLMPlanningResponse } from './parser';
+type AutoGLMParsedResponse = ReturnType<typeof parseAutoGLMPlanningResponse>;
+export declare function createAutoGlmPlanner(isMultilingual: boolean): CustomPlanningDefinition<AutoGLMParsedResponse>;
+export {};

package/dist/types/ai-model/models/default.d.ts

@@ -1,2 +1,2 @@
-import type { ModelAdapterDefinition } from './types';
+import type { ModelAdapterDefinition } from '../model-adapter/types';
 export declare const defaultOpenAICompatibleAdapterConfig: ModelAdapterDefinition;

package/dist/types/ai-model/models/doubao.d.ts

@@ -1,5 +1,5 @@
+import type { JsonParserContext, JsonParserSource, ModelAdapterDefinition } from '../model-adapter/types';
 import { type LocateResultValue } from '../shared/model-locate-result';
-import type { JsonParserContext, JsonParserSource, ModelAdapterDefinition } from './types';
 export declare function normalizeDoubaoJsonObject(obj: any, context?: Pick<JsonParserContext, 'preserveStringValueKeys'>): any;
 export declare function shouldRepairDoubaoLocateJson(source: JsonParserSource): source is "planning-action-param" | "locate" | "section-locator";
 export declare function preprocessDoubaoLocateJson(input: string): string;

package/dist/types/ai-model/models/gemini.d.ts

@@ -1,5 +1,5 @@
 import type OpenAI from 'openai';
-import type { ChatCompletionCallContext, ChatCompletionContentSource, ChatCompletionParamsResult, ContentAndReasoning } from './types';
+import type { ChatCompletionCallContext, ChatCompletionContentSource, ChatCompletionParamsResult, ContentAndReasoning } from '../model-adapter/types';
 type GeminiContentPart = Record<string, unknown> & {
     text?: string;
     thought?: boolean;

package/dist/types/ai-model/models/glm.d.ts

@@ -1,4 +1,4 @@
-import type { ChatCompletionCallContext, ChatCompletionParamsResult } from './types';
+import type { ChatCompletionCallContext, ChatCompletionParamsResult } from '../model-adapter/types';
 export declare const glmAdapters: {
     'glm-v': {
         chatCompletion: {

package/dist/types/ai-model/models/gpt.d.ts

@@ -1,4 +1,4 @@
-import type { ChatCompletionCallContext, ChatCompletionParamsResult, ImageDetail } from './types';
+import type { ChatCompletionCallContext, ChatCompletionParamsResult, ImageDetail } from '../model-adapter/types';
 export declare const gptAdapters: {
     'gpt-5': {
         chatCompletion: {

package/dist/types/ai-model/models/index.d.ts

@@ -1,2 +1,2 @@
 export { getModelAdapter, getModelRuntime, } from './registry';
-export type { ModelRuntime } from './types';
+export type { ModelRuntime } from '../model-adapter/types';

package/dist/types/ai-model/models/kimi.d.ts

@@ -1,4 +1,4 @@
-import type { ChatCompletionCallContext, ChatCompletionParamsResult } from './types';
+import type { ChatCompletionCallContext, ChatCompletionParamsResult } from '../model-adapter/types';
 export declare const kimiAdapters: {
     kimi: {
         chatCompletion: {

package/dist/types/ai-model/models/mimo.d.ts

@@ -1,4 +1,4 @@
-import type { ChatCompletionCallContext, ChatCompletionParamsResult } from './types';
+import type { ChatCompletionCallContext, ChatCompletionParamsResult } from '../model-adapter/types';
 export declare const mimoAdapters: {
     'xiaomi-mimo': {
         chatCompletion: {

package/dist/types/ai-model/models/qwen.d.ts

@@ -1,5 +1,5 @@
+import type { ChatCompletionCallContext, ChatCompletionParamsResult, ModelAdapterDefinition } from '../model-adapter/types';
 import { type LocateResultValue, type PixelBbox } from '../shared/model-locate-result';
-import type { ChatCompletionCallContext, ChatCompletionParamsResult, ModelAdapterDefinition } from './types';
 declare function parseQwen25RawLocateValue(input: unknown): LocateResultValue;
 declare function normalizeQwen25ResultToPixelBbox(result: LocateResultValue): PixelBbox;
 export declare const qwenAdapters: {

package/dist/types/ai-model/models/registry.d.ts

@@ -1,16 +1,16 @@
 import type { IModelConfig, TModelFamily } from '@midscene/shared/env';
-import type { ModelAdapter, ModelAdapterDefinition, ModelRuntime } from './types';
+import type { ModelAdapter, ModelAdapterDefinition, ModelRuntime } from '../model-adapter/types';
 export declare const MODEL_ADAPTER_CONFIGS: {
     'xiaomi-mimo': {
         chatCompletion: {
             unsupportedUserConfig: ("reasoningEffort" | "reasoningBudget")[];
-            buildChatCompletionParams: (input: import("./types").ChatCompletionCallContext) => import("./types").ChatCompletionParamsResult;
+            buildChatCompletionParams: (input: import("../model-adapter/types").ChatCompletionCallContext) => import("../model-adapter/types").ChatCompletionParamsResult;
         };
     };
     kimi: {
         chatCompletion: {
             unsupportedUserConfig: ("reasoningEffort" | "reasoningBudget")[];
-            buildChatCompletionParams: (input: import("./types").ChatCompletionCallContext) => import("./types").ChatCompletionParamsResult;
+            buildChatCompletionParams: (input: import("../model-adapter/types").ChatCompletionCallContext) => import("../model-adapter/types").ChatCompletionParamsResult;
         };
         locate: {
             resultAdapter: {
@@ -25,8 +25,8 @@ export declare const MODEL_ADAPTER_CONFIGS: {
     'gpt-5': {
         chatCompletion: {
             unsupportedUserConfig: "reasoningBudget"[];
-            buildChatCompletionParams: (input: import("./types").ChatCompletionCallContext) => import("./types").ChatCompletionParamsResult;
-            resolveImageDetail: (input: import("./types").ChatCompletionCallContext) => import("./types").ImageDetail | undefined;
+            buildChatCompletionParams: (input: import("../model-adapter/types").ChatCompletionCallContext) => import("../model-adapter/types").ChatCompletionParamsResult;
+            resolveImageDetail: (input: import("../model-adapter/types").ChatCompletionCallContext) => import("../model-adapter/types").ImageDetail | undefined;
         };
         locate: {
             resultAdapter: {
@@ -42,7 +42,7 @@ export declare const MODEL_ADAPTER_CONFIGS: {
     'glm-v': {
         chatCompletion: {
             unsupportedUserConfig: ("reasoningEffort" | "reasoningBudget")[];
-            buildChatCompletionParams: (input: import("./types").ChatCompletionCallContext) => import("./types").ChatCompletionParamsResult;
+            buildChatCompletionParams: (input: import("../model-adapter/types").ChatCompletionCallContext) => import("../model-adapter/types").ChatCompletionParamsResult;
         };
         locate: {
             resultAdapter: {
@@ -60,8 +60,8 @@ export declare const MODEL_ADAPTER_CONFIGS: {
     gemini: {
         chatCompletion: {
             unsupportedUserConfig: ("reasoningEnabled" | "reasoningBudget")[];
-            buildChatCompletionParams: (input: import("./types").ChatCompletionCallContext) => import("./types").ChatCompletionParamsResult;
-            extractContentAndReasoning: (message: (import("./types").ChatCompletionContentSource | (Omit<import("openai/resources/index.mjs").ChatCompletionMessage, "content"> & {
+            buildChatCompletionParams: (input: import("../model-adapter/types").ChatCompletionCallContext) => import("../model-adapter/types").ChatCompletionParamsResult;
+            extractContentAndReasoning: (message: (import("../model-adapter/types").ChatCompletionContentSource | (Omit<import("openai/resources/index.mjs").ChatCompletionMessage, "content"> & {
                 content: string | null | (Record<string, unknown> & {
                     text?: string;
                     thought?: boolean;
@@ -75,7 +75,7 @@ export declare const MODEL_ADAPTER_CONFIGS: {
                 })[];
                 reasoning_content?: string;
                 extra_content?: unknown;
-            })) | undefined) => import("./types").ContentAndReasoning;
+            })) | undefined) => import("../model-adapter/types").ContentAndReasoning;
         };
         locate: {
             resultAdapter: {
@@ -92,7 +92,7 @@ export declare const MODEL_ADAPTER_CONFIGS: {
     'qwen2.5-vl': {
         chatCompletion: {
             unsupportedUserConfig: ("reasoningEnabled" | "reasoningEffort" | "reasoningBudget")[];
-            buildChatCompletionParams: (input: import("./types").ChatCompletionCallContext) => import("./types").ChatCompletionParamsResult;
+            buildChatCompletionParams: (input: import("../model-adapter/types").ChatCompletionCallContext) => import("../model-adapter/types").ChatCompletionParamsResult;
         };
         imagePreprocess: {
             padBlockSize: number;

package/dist/types/ai-model/models/ui-tars/actions.d.ts

@@ -0,0 +1,3 @@
+import type { PlanningAction } from '../../../types';
+import type { UiTarsParsedPlanningResponse } from './parser';
+export declare function transformUiTarsActions(parsedPlanningResponse: UiTarsParsedPlanningResponse): PlanningAction[];

package/dist/types/ai-model/models/ui-tars/adapter.d.ts

@@ -1,4 +1,4 @@
-import type { ModelAdapterDefinition } from '../types';
+import type { ModelAdapterDefinition } from '../../model-adapter/types';
 export declare const uiTarsAdapters: {
     'vlm-ui-tars': ModelAdapterDefinition;
     'vlm-ui-tars-doubao': ModelAdapterDefinition;

package/dist/types/ai-model/models/ui-tars/parser.d.ts

@@ -0,0 +1,72 @@
+import type { Size } from '../../../types';
+import type { UITarsModelVersion } from '@midscene/shared/env';
+import { actionParser } from '@ui-tars/action-parser';
+type ActionType = 'click' | 'left_double' | 'right_single' | 'drag' | 'type' | 'hotkey' | 'finished' | 'scroll' | 'wait';
+export interface UiTarsParsedPlanningResponse {
+    rawResponse: string;
+    actions: ReturnType<typeof actionParser>['parsed'];
+}
+export declare function parseUiTarsPlanningResponse(rawResponse: string, shotSize: Size, uiTarsModelVersion: UITarsModelVersion): UiTarsParsedPlanningResponse;
+interface BaseAction {
+    action_type: ActionType;
+    action_inputs: Record<string, any>;
+    reflection: string | null;
+    thought: string | null;
+}
+interface ClickAction extends BaseAction {
+    action_type: 'click';
+    action_inputs: {
+        start_box: string;
+    };
+}
+interface DragAction extends BaseAction {
+    action_type: 'drag';
+    action_inputs: {
+        start_box: string;
+        end_box: string;
+    };
+}
+interface WaitAction extends BaseAction {
+    action_type: 'wait';
+    action_inputs: {
+        time: string;
+    };
+}
+interface LeftDoubleAction extends BaseAction {
+    action_type: 'left_double';
+    action_inputs: {
+        start_box: string;
+    };
+}
+interface RightSingleAction extends BaseAction {
+    action_type: 'right_single';
+    action_inputs: {
+        start_box: string;
+    };
+}
+interface TypeAction extends BaseAction {
+    action_type: 'type';
+    action_inputs: {
+        content: string;
+    };
+}
+interface HotkeyAction extends BaseAction {
+    action_type: 'hotkey';
+    action_inputs: {
+        key: string;
+    };
+}
+interface ScrollAction extends BaseAction {
+    action_type: 'scroll';
+    action_inputs: {
+        direction: 'up' | 'down';
+    };
+}
+interface FinishedAction extends BaseAction {
+    action_type: 'finished';
+    action_inputs: {
+        content?: string;
+    };
+}
+export type Action = ClickAction | LeftDoubleAction | RightSingleAction | DragAction | TypeAction | HotkeyAction | ScrollAction | FinishedAction | WaitAction;
+export {};

package/dist/types/ai-model/models/ui-tars/planning.d.ts

@@ -1,69 +1,4 @@
-import { type TUserPrompt } from '../../../common';
-import type { PlanningAIResponse } from '../../../types';
 import type { UITarsModelVersion } from '@midscene/shared/env';
-import type { PlanOptions } from '../../workflows/planning/types';
-type ActionType = 'click' | 'left_double' | 'right_single' | 'drag' | 'type' | 'hotkey' | 'finished' | 'scroll' | 'wait';
-export declare function uiTarsPlanning(userInstruction: TUserPrompt, options: PlanOptions, uiTarsModelVersion: UITarsModelVersion): Promise<PlanningAIResponse>;
-interface BaseAction {
-    action_type: ActionType;
-    action_inputs: Record<string, any>;
-    reflection: string | null;
-    thought: string | null;
-}
-interface ClickAction extends BaseAction {
-    action_type: 'click';
-    action_inputs: {
-        start_box: string;
-    };
-}
-interface DragAction extends BaseAction {
-    action_type: 'drag';
-    action_inputs: {
-        start_box: string;
-        end_box: string;
-    };
-}
-interface WaitAction extends BaseAction {
-    action_type: 'wait';
-    action_inputs: {
-        time: string;
-    };
-}
-interface LeftDoubleAction extends BaseAction {
-    action_type: 'left_double';
-    action_inputs: {
-        start_box: string;
-    };
-}
-interface RightSingleAction extends BaseAction {
-    action_type: 'right_single';
-    action_inputs: {
-        start_box: string;
-    };
-}
-interface TypeAction extends BaseAction {
-    action_type: 'type';
-    action_inputs: {
-        content: string;
-    };
-}
-interface HotkeyAction extends BaseAction {
-    action_type: 'hotkey';
-    action_inputs: {
-        key: string;
-    };
-}
-interface ScrollAction extends BaseAction {
-    action_type: 'scroll';
-    action_inputs: {
-        direction: 'up' | 'down';
-    };
-}
-interface FinishedAction extends BaseAction {
-    action_type: 'finished';
-    action_inputs: {
-        content?: string;
-    };
-}
-export type Action = ClickAction | LeftDoubleAction | RightSingleAction | DragAction | TypeAction | HotkeyAction | ScrollAction | FinishedAction | WaitAction;
-export {};
+import type { CustomPlanningDefinition } from '../../model-adapter/custom-planning-types';
+import { type UiTarsParsedPlanningResponse } from './parser';
+export declare function createUiTarsPlanner(uiTarsModelVersion: UITarsModelVersion): CustomPlanningDefinition<UiTarsParsedPlanningResponse>;

package/dist/types/ai-model/service-caller/index.d.ts

@@ -26,12 +26,13 @@ export declare function createChatClient({ modelConfig, }: {
     modelDescription: string;
     modelFamily: TModelFamily | undefined;
 }>;
-export declare function callAI(messages: ChatCompletionMessageParam[], modelRuntime: ModelRuntime, options?: {
+interface CallAIOptions {
     stream?: boolean;
     onChunk?: StreamingCallback;
     abortSignal?: AbortSignal;
     requiresOriginalImageDetail?: boolean;
-}): Promise<{
+}
+export declare function callAI(messages: ChatCompletionMessageParam[], modelRuntime: ModelRuntime, options?: CallAIOptions): Promise<{
     content: string;
     reasoning_content?: string;
     rawChoiceMessage?: unknown;
@@ -48,9 +49,7 @@ export declare function callAIWithObjectResponse<T>(messages: ChatCompletionMess
     reasoning_content?: string;
     rawChoiceMessage?: unknown;
 }>;
-export declare function callAIWithStringResponse(msgs: AIArgs, modelRuntime: ModelRuntime, options?: {
-    abortSignal?: AbortSignal;
-}): Promise<{
+export declare function callAIWithStringResponse(msgs: AIArgs, modelRuntime: ModelRuntime, options?: Pick<CallAIOptions, 'abortSignal' | 'requiresOriginalImageDetail'>): Promise<{
     content: string;
     usage?: AIUsageInfo;
     rawChoiceMessage?: unknown;

package/dist/types/ai-model/shared/model-locate-result/coordinate-distance.d.ts

@@ -0,0 +1,4 @@
+import type { Size } from '../../../types';
+import type { ResolvedLocateResultCoordinates } from './types';
+export type CoordinateDistanceAxis = 'x' | 'y';
+export declare function createCoordinateDistanceToPixels(size: Size, coordinateSystem: ResolvedLocateResultCoordinates): (delta: number, axis: CoordinateDistanceAxis) => number;

package/dist/types/ai-model/shared/model-locate-result/factory.d.ts

@@ -1,2 +1,3 @@
-import type { LocateResultAdapter, LocateResultAdapterDefinition } from './types';
+import type { LocateResultAdapter, LocateResultAdapterDefinition, LocateResultCoordinates, ResolvedLocateResultCoordinates } from './types';
+export declare function resolveLocateResultCoordinates(coordinates: LocateResultCoordinates): ResolvedLocateResultCoordinates;
 export declare function createLocateResultAdapter(config: LocateResultAdapterDefinition): LocateResultAdapter;

package/dist/types/ai-model/shared/model-locate-result/index.d.ts

@@ -1,3 +1,5 @@
-export { createLocateResultAdapter } from './factory';
+export { createLocateResultAdapter, resolveLocateResultCoordinates, } from './factory';
+export { createCoordinateDistanceToPixels } from './coordinate-distance';
+export type { CoordinateDistanceAxis } from './coordinate-distance';
 export { unwrapCoordinateListLikeInput } from './parse';
-export type { LocateResultBbox, PixelBbox, RawLocateValue, SectionLocatePixelBboxGroup, CustomLocateResultAdapterDefinition, LocateResultAdapter, LocateResultAdapterDefinition, LocateResultCoordinates, LocateResultContext, LocateResultShape, LocateResultPromptSpec, LocateResultValue, NonEmptyArray, StandardLocateResultAdapterDefinition, } from './types';
+export type { LocateResultBbox, PixelBbox, RawLocateValue, SectionLocatePixelBboxGroup, CustomLocateResultAdapterDefinition, LocateResultAdapter, LocateResultAdapterDefinition, LocateResultCoordinates, LocateResultContext, LocateResultShape, LocateResultPromptSpec, LocateResultValue, NonEmptyArray, ResolvedLocateResultCoordinates, StandardLocateResultAdapterDefinition, } from './types';

package/dist/types/ai-model/shared/model-locate-result/types.d.ts

@@ -35,7 +35,6 @@ export interface SectionLocatePixelBboxGroup {
     references?: PixelBbox[];
 }
 export interface LocateResultAdapter {
-    kind: 'standard' | 'custom';
     promptSpec: LocateResultPromptSpec;
     /**
      * Converts a locate payload to a pixel bbox. This adapter intentionally does

package/dist/types/ai-model/shared/planning-action.d.ts

@@ -0,0 +1,20 @@
+import type { PixelBbox, PlanningAction, PlanningLocateParam } from '../../types';
+export type LocateActionParam = {
+    locate: PlanningLocateParam;
+};
+export type LocatePlanningAction<TType extends string> = PlanningAction<LocateActionParam> & {
+    type: TType;
+};
+export type ScrollPlanningAction = PlanningAction<LocateActionParam & {
+    distance: number;
+    direction: 'up' | 'down' | 'left' | 'right';
+}> & {
+    type: 'Scroll';
+};
+export type DragAndDropPlanningAction = PlanningAction<{
+    from: PlanningLocateParam;
+    to: PlanningLocateParam;
+}> & {
+    type: 'DragAndDrop';
+};
+export declare function getTapLocatedPixelBbox(actions: PlanningAction[]): PixelBbox | undefined;

package/dist/types/ai-model/workflows/inspect/planning-action-locate.d.ts

@@ -0,0 +1,4 @@
+import type { ResolvedCustomPlanningDefinition } from '../../model-adapter/custom-planning-types';
+import type { PlanningTapLocatorDefinition } from '../../model-adapter/types';
+import type { LocateFn } from './types';
+export declare function resolvePlanningTapLocator<TParsed>(definition: PlanningTapLocatorDefinition, planner: ResolvedCustomPlanningDefinition<TParsed>): LocateFn;

package/dist/types/ai-model/workflows/inspect/types.d.ts

@@ -1,5 +1,6 @@
-import type { AIUsageInfo, Rect, UIContext } from '../../../types';
+import type { AIUsageInfo, PixelBbox, Rect, UIContext } from '../../../types';
 import type { LocateResultElement } from '@midscene/shared/types';
+import type { ChatCompletionUserMessageParam } from 'openai/resources/index';
 import type { TUserPrompt } from '../../../common';
 import type { ModelRuntime } from '../../models';
 export interface SearchAreaImageMapping {
@@ -24,6 +25,16 @@ export interface LocateOptions {
     modelRuntime: ModelRuntime;
     abortSignal?: AbortSignal;
 }
+export interface LocateRequestContext {
+    elementDescriptionText: string;
+    locateImage: {
+        imageBase64: string;
+        width: number;
+        height: number;
+    };
+    referenceImageMessages?: ChatCompletionUserMessageParam[];
+    options: LocateOptions;
+}
 export interface LocateResult {
     parseResult: {
         element?: LocateResultElement;
@@ -35,4 +46,12 @@ export interface LocateResult {
     usage?: AIUsageInfo;
     reasoning_content?: string;
 }
-export type LocateFn = (elementDescription: TUserPrompt, options: LocateOptions) => Promise<LocateResult>;
+export interface LocateModelResponse {
+    locatedPixelBbox?: PixelBbox;
+    rawResponse: string;
+    rawChoiceMessage?: unknown;
+    usage?: AIUsageInfo;
+    reasoningContent?: string;
+    errors?: string[];
+}
+export type LocateFn = (elementDescription: TUserPrompt, options: LocateOptions, locateRequest: LocateRequestContext) => Promise<LocateModelResponse>;

package/dist/types/ai-model/workflows/planning/custom-planning.d.ts

@@ -0,0 +1,7 @@
+import { type TUserPrompt } from '../../../common';
+import type { PlanningAIResponse } from '../../../types';
+import type { ChatCompletionMessageParam } from 'openai/resources/index';
+import type { CustomPlanningInput, CustomPlanningMessageConfig, ResolvedCustomPlanningDefinition } from '../../model-adapter/custom-planning-types';
+import type { PlanOptions } from './types';
+export declare function buildCustomPlanningMessages<TParsed>(input: CustomPlanningInput, config: CustomPlanningMessageConfig<TParsed>): ChatCompletionMessageParam[];
+export declare function runCustomPlanning<TParsed>(userInstruction: TUserPrompt, options: PlanOptions, config: ResolvedCustomPlanningDefinition<TParsed>): Promise<PlanningAIResponse>;

package/dist/types/ai-model/workflows/planning/locate-normalization.d.ts

@@ -0,0 +1,9 @@
+import type { DeviceAction } from '../../../device';
+import type { PlanningAction } from '../../../types';
+import type { LocateResultAdapter, LocateResultContext } from '../../shared/model-locate-result/types';
+export declare function normalizePlanningActionLocateFields(actions: PlanningAction[], { actionSpace, includeLocateInPlanning, locateResultAdapter, locateResultContext, }: {
+    actionSpace: DeviceAction[];
+    includeLocateInPlanning: boolean;
+    locateResultAdapter?: LocateResultAdapter;
+    locateResultContext: LocateResultContext;
+}): void;

package/dist/types/common.d.ts

@@ -14,6 +14,7 @@ import { z } from 'zod';
  */
 export declare function expandSearchArea(rect: Rect, screenSize: Size): Rect;
 export declare function markupImageForLLM(screenshotBase64: string, tree: ElementTreeNode<BaseElement>, size: Size): Promise<string>;
+export declare function findActionInActionSpaceOrThrow(planType: string, actionSpace: DeviceAction<any>[]): DeviceAction<any>;
 export declare function buildYamlFlowFromPlans(plans: PlanningAction[], actionSpace: DeviceAction<any>[]): MidsceneYamlFlowItem[];
 export declare const PointSchema: z.ZodObject<{
     left: z.ZodNumber;

package/dist/types/device/index.d.ts

@@ -302,8 +302,8 @@ export declare const actionTapParamSchema: z.ZodObject<{
             }[] | undefined;
             convertHttpImage2Base64?: boolean | undefined;
         });
-        deepThink?: boolean | undefined;
         deepLocate?: boolean | undefined;
+        deepThink?: boolean | undefined;
         cacheable?: boolean | undefined;
         xpath?: string | boolean | undefined;
     } & {
@@ -320,8 +320,8 @@ export declare const actionTapParamSchema: z.ZodObject<{
             }[] | undefined;
             convertHttpImage2Base64?: boolean | undefined;
         });
-        deepThink?: boolean | undefined;
         deepLocate?: boolean | undefined;
+        deepThink?: boolean | undefined;
         cacheable?: boolean | undefined;
         xpath?: string | boolean | undefined;
     } & {
@@ -453,8 +453,8 @@ export declare const actionRightClickParamSchema: z.ZodObject<{
             }[] | undefined;
             convertHttpImage2Base64?: boolean | undefined;
         });
-        deepThink?: boolean | undefined;
         deepLocate?: boolean | undefined;
+        deepThink?: boolean | undefined;
         cacheable?: boolean | undefined;
         xpath?: string | boolean | undefined;
     } & {
@@ -471,8 +471,8 @@ export declare const actionRightClickParamSchema: z.ZodObject<{
             }[] | undefined;
             convertHttpImage2Base64?: boolean | undefined;
         });
-        deepThink?: boolean | undefined;
         deepLocate?: boolean | undefined;
+        deepThink?: boolean | undefined;
         cacheable?: boolean | undefined;
         xpath?: string | boolean | undefined;
     } & {
@@ -604,8 +604,8 @@ export declare const actionDoubleClickParamSchema: z.ZodObject<{
             }[] | undefined;
             convertHttpImage2Base64?: boolean | undefined;
         });
-        deepThink?: boolean | undefined;
         deepLocate?: boolean | undefined;
+        deepThink?: boolean | undefined;
         cacheable?: boolean | undefined;
         xpath?: string | boolean | undefined;
     } & {
@@ -622,8 +622,8 @@ export declare const actionDoubleClickParamSchema: z.ZodObject<{
             }[] | undefined;
             convertHttpImage2Base64?: boolean | undefined;
         });
-        deepThink?: boolean | undefined;
         deepLocate?: boolean | undefined;
+        deepThink?: boolean | undefined;
         cacheable?: boolean | undefined;
         xpath?: string | boolean | undefined;
     } & {
@@ -755,8 +755,8 @@ export declare const actionHoverParamSchema: z.ZodObject<{
             }[] | undefined;
             convertHttpImage2Base64?: boolean | undefined;
         });
-        deepThink?: boolean | undefined;
         deepLocate?: boolean | undefined;
+        deepThink?: boolean | undefined;
         cacheable?: boolean | undefined;
         xpath?: string | boolean | undefined;
     } & {
@@ -773,8 +773,8 @@ export declare const actionHoverParamSchema: z.ZodObject<{
             }[] | undefined;
             convertHttpImage2Base64?: boolean | undefined;
         });
-        deepThink?: boolean | undefined;
         deepLocate?: boolean | undefined;
+        deepThink?: boolean | undefined;
         cacheable?: boolean | undefined;
         xpath?: string | boolean | undefined;
     } & {
@@ -1375,9 +1375,9 @@ export declare const actionScrollParamSchema: z.ZodObject<{
         cacheable: z.ZodOptional<z.ZodBoolean>;
         xpath: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
+    distance?: number | null | undefined;
     direction?: "left" | "right" | "up" | "down" | undefined;
     scrollType?: "singleAction" | "scrollToBottom" | "scrollToTop" | "scrollToRight" | "scrollToLeft" | undefined;
-    distance?: number | null | undefined;
 }>;
 export declare const defineActionScroll: (scroll: ScrollInputPrimitives["scroll"]) => DeviceAction<ActionScrollParam>;
 export declare const actionDragAndDropParamSchema: z.ZodObject<{
@@ -1610,8 +1610,8 @@ export declare const actionDragAndDropParamSchema: z.ZodObject<{
             }[] | undefined;
             convertHttpImage2Base64?: boolean | undefined;
         });
-        deepThink?: boolean | undefined;
         deepLocate?: boolean | undefined;
+        deepThink?: boolean | undefined;
         cacheable?: boolean | undefined;
         xpath?: string | boolean | undefined;
     } & {
@@ -1627,8 +1627,8 @@ export declare const actionDragAndDropParamSchema: z.ZodObject<{
             }[] | undefined;
             convertHttpImage2Base64?: boolean | undefined;
         });
-        deepThink?: boolean | undefined;
         deepLocate?: boolean | undefined;
+        deepThink?: boolean | undefined;
         cacheable?: boolean | undefined;
         xpath?: string | boolean | undefined;
     } & {
@@ -1645,8 +1645,8 @@ export declare const actionDragAndDropParamSchema: z.ZodObject<{
             }[] | undefined;
             convertHttpImage2Base64?: boolean | undefined;
         });
-        deepThink?: boolean | undefined;
         deepLocate?: boolean | undefined;
+        deepThink?: boolean | undefined;
         cacheable?: boolean | undefined;
         xpath?: string | boolean | undefined;
     } & {
@@ -1662,8 +1662,8 @@ export declare const actionDragAndDropParamSchema: z.ZodObject<{
             }[] | undefined;
             convertHttpImage2Base64?: boolean | undefined;
         });
-        deepThink?: boolean | undefined;
         deepLocate?: boolean | undefined;
+        deepThink?: boolean | undefined;
         cacheable?: boolean | undefined;
         xpath?: string | boolean | undefined;
     } & {
@@ -1797,8 +1797,8 @@ export declare const ActionLongPressParamSchema: z.ZodObject<{
             }[] | undefined;
             convertHttpImage2Base64?: boolean | undefined;
         });
-        deepThink?: boolean | undefined;
         deepLocate?: boolean | undefined;
+        deepThink?: boolean | undefined;
         cacheable?: boolean | undefined;
         xpath?: string | boolean | undefined;
     } & {
@@ -1816,8 +1816,8 @@ export declare const ActionLongPressParamSchema: z.ZodObject<{
             }[] | undefined;
             convertHttpImage2Base64?: boolean | undefined;
         });
-        deepThink?: boolean | undefined;
         deepLocate?: boolean | undefined;
+        deepThink?: boolean | undefined;
         cacheable?: boolean | undefined;
         xpath?: string | boolean | undefined;
     } & {
@@ -2056,8 +2056,8 @@ export declare const ActionSwipeParamSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     duration: number;
     repeat?: number | undefined;
-    direction?: "left" | "right" | "up" | "down" | undefined;
     distance?: number | undefined;
+    direction?: "left" | "right" | "up" | "down" | undefined;
     start?: z.objectOutputType<{
         prompt: z.ZodUnion<[z.ZodString, z.ZodIntersection<z.ZodObject<{
             prompt: z.ZodString;
@@ -2134,8 +2134,8 @@ export declare const ActionSwipeParamSchema: z.ZodObject<{
     }, z.ZodTypeAny, "passthrough"> | undefined;
 }, {
     repeat?: number | undefined;
-    direction?: "left" | "right" | "up" | "down" | undefined;
     distance?: number | undefined;
+    direction?: "left" | "right" | "up" | "down" | undefined;
     duration?: number | undefined;
     start?: z.objectInputType<{
         prompt: z.ZodUnion<[z.ZodString, z.ZodIntersection<z.ZodObject<{