@mobilerun/sdk 5.2.0 → 5.3.0

package/src/resources/workflows/events.ts

@@ -1,3 +1,230 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-export * from './events/index';
+import { APIResource } from '../../core/resource';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+
+export class Events extends APIResource {
+  /**
+   * Simulate an event against all configured flows. Returns which flows would match
+   * and what actions would run, without storing the event or enqueuing jobs.
+   */
+  dryRun(body: EventDryRunParams, options?: RequestOptions): APIPromise<EventDryRunResponse> {
+    return this._client.post('/events/dry-run', { body, ...options });
+  }
+
+  /**
+   * Ingest an event for trigger evaluation. Returns immediately with 202 Accepted.
+   */
+  ingest(body: EventIngestParams, options?: RequestOptions): APIPromise<EventIngestResponse> {
+    return this._client.post('/events/ingest', { body, ...options });
+  }
+}
+
+export interface EventDryRunResponse {
+  data: EventDryRunResponse.Data;
+}
+
+export namespace EventDryRunResponse {
+  export interface Data {
+    matchedFlows: Array<Data.MatchedFlow>;
+
+    validation: Data.Validation;
+  }
+
+  export namespace Data {
+    export interface MatchedFlow {
+      actions: Array<MatchedFlow.Action>;
+
+      flow: MatchedFlow.Flow;
+
+      gates: MatchedFlow.Gates;
+
+      trigger: MatchedFlow.Trigger;
+
+      wouldFire: boolean;
+    }
+
+    export namespace MatchedFlow {
+      export interface Action {
+        continueOnError: boolean;
+
+        method: string;
+
+        name: string;
+
+        service: 'tasks_api' | 'devices_api' | 'agents_api' | 'webhooks';
+
+        /**
+         * Nested child actions (loop/branch bodies), each the same shape as a
+         * ResolvedAction.
+         */
+        children?: Array<unknown>;
+
+        params?: { [key: string]: unknown };
+      }
+
+      export interface Flow {
+        id: string;
+
+        blockedAt: string | null;
+
+        consecutiveFailures: number;
+
+        cooldownScope: 'flow' | 'device';
+
+        cooldownSeconds: number | null;
+
+        createdAt: string | null;
+
+        createdBy: string | null;
+
+        description: string | null;
+
+        deviceIds: Array<string>;
+
+        enabled: boolean;
+
+        healthMonitoringEnabled: boolean;
+
+        lastFailureAt: string | null;
+
+        lastFailureCode:
+          | 'device_not_found'
+          | 'permission_denied'
+          | 'client_error'
+          | 'transient'
+          | 'logic'
+          | 'invalid_config'
+          | null;
+
+        lastTriggeredAt: string | null;
+
+        name: string;
+
+        notifyOnFailure: boolean;
+
+        notifyOnSuccess: boolean;
+
+        notifyWebhookId: string | null;
+
+        ownerId: string;
+
+        recordingEnabled: boolean;
+
+        selfHealingEnabled: boolean;
+
+        selfHealingMaxAttempts: number;
+
+        status: 'healthy' | 'failing' | 'blocked';
+
+        /**
+         * Template-resolver semantics this flow runs under (MVA-23). 1 = legacy
+         * (missing/forbidden/null all resolve to ''). 2 = typed (missing/forbidden throw,
+         * a whole-token null stays JSON null). Existing flows stay 1; new flows default
+         * to 2.
+         */
+        templateResolutionVersion: number;
+
+        triggerId: string;
+
+        updatedAt: string | null;
+
+        /**
+         * @deprecated Deprecated: use ownerId (tenancy) / createdBy (actor).
+         */
+        userId: string;
+      }
+
+      export interface Gates {
+        blocked: boolean;
+
+        cooldownActive: boolean | null;
+
+        deviceAttached: boolean;
+
+        deviceIds: Array<string>;
+
+        enabled: boolean;
+      }
+
+      export interface Trigger {
+        id: string;
+
+        activation: 'event' | 'schedule' | 'custom';
+
+        createdAt: string | null;
+
+        createdBy: string | null;
+
+        customPayloadSchema: { [key: string]: unknown } | null;
+
+        description: string | null;
+
+        eventType: string | null;
+
+        name: string;
+
+        ownerId: string;
+
+        scheduleRule: unknown;
+
+        timezone: string | null;
+
+        updatedAt: string | null;
+
+        /**
+         * @deprecated Deprecated: use ownerId (tenancy) / createdBy (actor).
+         */
+        userId: string;
+
+        conditions?: unknown;
+
+        nextFireTime?: string | null;
+      }
+    }
+
+    export interface Validation {
+      valid: boolean;
+
+      errors?: Array<Validation.Error>;
+    }
+
+    export namespace Validation {
+      export interface Error {
+        field: string;
+
+        message: string;
+      }
+    }
+  }
+}
+
+export interface EventIngestResponse {
+  eventId: string;
+}
+
+export interface EventDryRunParams {
+  eventType: string;
+
+  deviceId?: string;
+
+  payload?: { [key: string]: unknown };
+}
+
+export interface EventIngestParams {
+  eventType: string;
+
+  deviceId?: string;
+
+  payload?: { [key: string]: unknown };
+}
+
+export declare namespace Events {
+  export {
+    type EventDryRunResponse as EventDryRunResponse,
+    type EventIngestResponse as EventIngestResponse,
+    type EventDryRunParams as EventDryRunParams,
+    type EventIngestParams as EventIngestParams,
+  };
+}

package/src/resources/workflows/executions.ts

@@ -1,7 +1,6 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import { APIResource } from '../../core/resource';
-import * as ExecutionsAPI from './executions';
 import * as Shared from '../shared';
 import { APIPromise } from '../../core/api-promise';
 import { RequestOptions } from '../../internal/request-options';
@@ -28,6 +27,14 @@ export class Executions extends APIResource {
     return this._client.get('/executions', { query, ...options });
   }
 
+  /**
+   * Signals the worker to stop the execution between steps and marks it cancelled.
+   * Idempotent-ish: already-terminal executions return 409.
+   */
+  abort(executionID: string, options?: RequestOptions): APIPromise<ExecutionAbortResponse> {
+    return this._client.post(path`/executions/${executionID}/abort`, options);
+  }
+
   /**
    * Return aggregate execution metrics — total count, counts by status, average
    * duration, and the last execution time. Can be scoped by `flowId`, `triggerId`,
@@ -41,54 +48,61 @@ export class Executions extends APIResource {
   }
 }
 
-export interface FlowExecution {
-  id: string;
+export interface ExecutionRetrieveResponse {
+  data: ExecutionRetrieveResponse.Data;
+}
 
-  error: string | null;
+export namespace ExecutionRetrieveResponse {
+  export interface Data {
+    id: string;
 
-  eventId: string | null;
+    createdBy: string | null;
 
-  finishedAt: string | null;
+    error: string | null;
 
-  flowId: string;
+    eventId: string | null;
 
-  flowName: string | null;
+    /**
+     * Files produced by files.upload steps, plus files an agent.run step reported on
+     * its terminal response (agent-created output or a workflow upload minted during
+     * the turn); derived server-side at read time.
+     */
+    files: Array<Data.File>;
 
-  kind: 'live' | 'dry_run';
+    finishedAt: string | null;
 
-  startedAt: string | null;
+    flowId: string;
 
-  status: 'pending' | 'running' | 'success' | 'failed' | 'cancelled' | 'skipped' | 'invalid' | null;
+    flowName: string | null;
 
-  triggerId: string;
+    kind: 'live' | 'dry_run';
 
-  triggerName: string | null;
+    recordingDeviceId: string | null;
 
-  /**
-   * Opaque per-step result blob ({ steps: [...] }). Each step additionally carries a
-   * `verdict` field ({ outcome, summary, reason? } | null) when it is an agent.run
-   * step that opted into a verdict — null otherwise. Table-backed steps (current
-   * executions) also carry a `status` string (e.g. success/failed/stopped, see
-   * deriveStepStatus); it is optional and absent on legacy blob-only executions, so
-   * clients must not assume its presence.
-   */
-  result?: unknown;
-}
+    /**
+     * Device-recording id (devices-api) for this execution, set once the worker starts
+     * a recording. Null when the flow has recording disabled, no device is bound, or
+     * the recording failed to start.
+     */
+    recordingId: string | null;
 
-export interface ExecutionRetrieveResponse {
-  data: ExecutionRetrieveResponse.Data;
-}
+    startedAt: string | null;
 
-export namespace ExecutionRetrieveResponse {
-  export interface Data extends ExecutionsAPI.FlowExecution {
-    createdBy: string | null;
+    status: 'pending' | 'running' | 'success' | 'failed' | 'cancelled' | 'skipped' | 'invalid' | null;
+
+    triggerId: string;
+
+    triggerName: string | null;
 
     /**
-     * Files produced by files.upload steps, plus files an agent.run step reported on
-     * its terminal response (agent-created output or a workflow upload minted during
-     * the turn); derived server-side at read time.
+     * Opaque per-step result blob ({ steps: [...] }). Each step additionally carries a
+     * `verdict` field ({ outcome, summary, reason? } | null) when it is an agent.run
+     * step that opted into a verdict — null otherwise. Table-backed steps (current
+     * executions) also carry a `status` string (e.g. success/failed/stopped, see
+     * deriveStepStatus); it is optional and absent on legacy blob-only executions, so
+     * clients must not assume its presence.
      */
-    files: Array<Data.File>;
+    result?: unknown;
   }
 
   export namespace Data {
@@ -111,8 +125,98 @@ export interface ExecutionListResponse {
 }
 
 export namespace ExecutionListResponse {
-  export interface Item extends ExecutionsAPI.FlowExecution {
+  export interface Item {
+    id: string;
+
     createdBy: string | null;
+
+    error: string | null;
+
+    eventId: string | null;
+
+    finishedAt: string | null;
+
+    flowId: string;
+
+    flowName: string | null;
+
+    kind: 'live' | 'dry_run';
+
+    recordingDeviceId: string | null;
+
+    /**
+     * Device-recording id (devices-api) for this execution, set once the worker starts
+     * a recording. Null when the flow has recording disabled, no device is bound, or
+     * the recording failed to start.
+     */
+    recordingId: string | null;
+
+    startedAt: string | null;
+
+    status: 'pending' | 'running' | 'success' | 'failed' | 'cancelled' | 'skipped' | 'invalid' | null;
+
+    triggerId: string;
+
+    triggerName: string | null;
+
+    /**
+     * Opaque per-step result blob ({ steps: [...] }). Each step additionally carries a
+     * `verdict` field ({ outcome, summary, reason? } | null) when it is an agent.run
+     * step that opted into a verdict — null otherwise. Table-backed steps (current
+     * executions) also carry a `status` string (e.g. success/failed/stopped, see
+     * deriveStepStatus); it is optional and absent on legacy blob-only executions, so
+     * clients must not assume its presence.
+     */
+    result?: unknown;
+  }
+}
+
+export interface ExecutionAbortResponse {
+  data: ExecutionAbortResponse.Data;
+}
+
+export namespace ExecutionAbortResponse {
+  export interface Data {
+    id: string;
+
+    error: string | null;
+
+    eventId: string | null;
+
+    finishedAt: string | null;
+
+    flowId: string;
+
+    flowName: string | null;
+
+    kind: 'live' | 'dry_run';
+
+    recordingDeviceId: string | null;
+
+    /**
+     * Device-recording id (devices-api) for this execution, set once the worker starts
+     * a recording. Null when the flow has recording disabled, no device is bound, or
+     * the recording failed to start.
+     */
+    recordingId: string | null;
+
+    startedAt: string | null;
+
+    status: 'pending' | 'running' | 'success' | 'failed' | 'cancelled' | 'skipped' | 'invalid' | null;
+
+    triggerId: string;
+
+    triggerName: string | null;
+
+    /**
+     * Opaque per-step result blob ({ steps: [...] }). Each step additionally carries a
+     * `verdict` field ({ outcome, summary, reason? } | null) when it is an agent.run
+     * step that opted into a verdict — null otherwise. Table-backed steps (current
+     * executions) also carry a `status` string (e.g. success/failed/stopped, see
+     * deriveStepStatus); it is optional and absent on legacy blob-only executions, so
+     * clients must not assume its presence.
+     */
+    result?: unknown;
   }
 }
 
@@ -184,9 +288,9 @@ export interface ExecutionGetMetricsParams {
 
 export declare namespace Executions {
   export {
-    type FlowExecution as FlowExecution,
     type ExecutionRetrieveResponse as ExecutionRetrieveResponse,
     type ExecutionListResponse as ExecutionListResponse,
+    type ExecutionAbortResponse as ExecutionAbortResponse,
     type ExecutionGetMetricsResponse as ExecutionGetMetricsResponse,
     type ExecutionListParams as ExecutionListParams,
     type ExecutionGetMetricsParams as ExecutionGetMetricsParams,

package/src/resources/workflows/flows/actions.ts

@@ -1,7 +1,6 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import { APIResource } from '../../../core/resource';
-import * as FlowsAPI from './flows';
 import { APIPromise } from '../../../core/api-promise';
 import { RequestOptions } from '../../../internal/request-options';
 import { path } from '../../../internal/utils/path';
@@ -53,38 +52,68 @@ export class Actions extends APIResource {
   }
 }
 
-export interface FlowAction {
-  id: string;
+export interface ActionListResponse {
+  data: Array<ActionListResponse.Data>;
+}
 
-  actionId: string;
+export namespace ActionListResponse {
+  export interface Data {
+    id: string;
 
-  continueOnError: boolean;
+    actionId: string;
 
-  createdAt: string | null;
+    continueOnError: boolean;
 
-  flowId: string;
+    createdAt: string | null;
 
-  nameOverride: string | null;
+    flowId: string;
 
-  overrides: FlowAction.Overrides | null;
+    nameOverride: string | null;
 
-  parentFlowActionId: string | null;
+    overrides: Data.Overrides | null;
 
-  position: number;
-}
+    parentFlowActionId: string | null;
 
-export namespace FlowAction {
-  export interface Overrides {
-    params?: { [key: string]: unknown };
+    position: number;
   }
-}
 
-export interface ActionListResponse {
-  data: Array<FlowAction>;
+  export namespace Data {
+    export interface Overrides {
+      params?: { [key: string]: unknown };
+    }
+  }
 }
 
 export interface ActionAddResponse {
-  data: FlowAction;
+  data: ActionAddResponse.Data;
+}
+
+export namespace ActionAddResponse {
+  export interface Data {
+    id: string;
+
+    actionId: string;
+
+    continueOnError: boolean;
+
+    createdAt: string | null;
+
+    flowId: string;
+
+    nameOverride: string | null;
+
+    overrides: Data.Overrides | null;
+
+    parentFlowActionId: string | null;
+
+    position: number;
+  }
+
+  export namespace Data {
+    export interface Overrides {
+      params?: { [key: string]: unknown };
+    }
+  }
 }
 
 export interface ActionRemoveResponse {
@@ -92,7 +121,35 @@ export interface ActionRemoveResponse {
 }
 
 export interface ActionReplaceResponse {
-  data: Array<FlowAction>;
+  data: Array<ActionReplaceResponse.Data>;
+}
+
+export namespace ActionReplaceResponse {
+  export interface Data {
+    id: string;
+
+    actionId: string;
+
+    continueOnError: boolean;
+
+    createdAt: string | null;
+
+    flowId: string;
+
+    nameOverride: string | null;
+
+    overrides: Data.Overrides | null;
+
+    parentFlowActionId: string | null;
+
+    position: number;
+  }
+
+  export namespace Data {
+    export interface Overrides {
+      params?: { [key: string]: unknown };
+    }
+  }
 }
 
 export interface ActionAddParams {
@@ -100,17 +157,41 @@ export interface ActionAddParams {
 
   position: number;
 
-  children?: Array<FlowsAPI.FlowChildActionInput>;
+  children?: Array<ActionAddParams.Child>;
 
   continueOnError?: boolean;
 
   nameOverride?: string;
 
-  overrides?: FlowsAPI.FlowActionOverrides | null;
+  overrides?: ActionAddParams.Overrides | null;
 
   parentFlowActionId?: string | null;
 }
 
+export namespace ActionAddParams {
+  export interface Child {
+    actionId: string;
+
+    position: number;
+
+    continueOnError?: boolean;
+
+    nameOverride?: string;
+
+    overrides?: Child.Overrides | null;
+  }
+
+  export namespace Child {
+    export interface Overrides {
+      params?: { [key: string]: unknown };
+    }
+  }
+
+  export interface Overrides {
+    params?: { [key: string]: unknown };
+  }
+}
+
 export interface ActionRemoveParams {
   flowId: string;
 }
@@ -125,19 +206,42 @@ export namespace ActionReplaceParams {
 
     position: number;
 
-    children?: Array<FlowsAPI.FlowChildActionInput>;
+    children?: Array<Action.Child>;
 
     continueOnError?: boolean;
 
     nameOverride?: string;
 
-    overrides?: FlowsAPI.FlowActionOverrides | null;
+    overrides?: Action.Overrides | null;
+  }
+
+  export namespace Action {
+    export interface Child {
+      actionId: string;
+
+      position: number;
+
+      continueOnError?: boolean;
+
+      nameOverride?: string;
+
+      overrides?: Child.Overrides | null;
+    }
+
+    export namespace Child {
+      export interface Overrides {
+        params?: { [key: string]: unknown };
+      }
+    }
+
+    export interface Overrides {
+      params?: { [key: string]: unknown };
+    }
   }
 }
 
 export declare namespace Actions {
   export {
-    type FlowAction as FlowAction,
     type ActionListResponse as ActionListResponse,
     type ActionAddResponse as ActionAddResponse,
     type ActionRemoveResponse as ActionRemoveResponse,