@mobilerun/sdk 5.1.0 → 5.2.1

package/src/resources/workflows/events.ts

@@ -1,3 +1,228 @@
 // 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;
+
+        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

@@ -8,14 +8,17 @@ import { path } from '../../internal/utils/path';
 
 export class Executions extends APIResource {
   /**
-   * Get execution details
+   * Fetch a single flow execution by its ID, including its status, kind, result or
+   * error, and start/finish timestamps. Returns 404 if no execution matches.
    */
   retrieve(executionID: string, options?: RequestOptions): APIPromise<ExecutionRetrieveResponse> {
     return this._client.get(path`/executions/${executionID}`, options);
   }
 
   /**
-   * List flow executions
+   * Return a paginated history of flow executions. Supports filtering by `flowId`,
+   * `triggerId`, `status`, and a `from`/`to` time range, plus free-text `search` and
+   * ordering by startedAt, finishedAt, or status.
    */
   list(
     query: ExecutionListParams | null | undefined = {},
@@ -25,7 +28,17 @@ export class Executions extends APIResource {
   }
 
   /**
-   * Get execution metrics
+   * 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`,
+   * and a `from`/`to` time range.
    */
   getMetrics(
     query: ExecutionGetMetricsParams | null | undefined = {},
@@ -35,42 +48,151 @@ 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;
+    startedAt: string | null;
 
-  result?: unknown;
-}
+    status: 'pending' | 'running' | 'success' | 'failed' | 'cancelled' | 'skipped' | 'invalid' | null;
 
-export interface ExecutionRetrieveResponse {
-  data: FlowExecution;
+    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 namespace Data {
+    export interface File {
+      fileId: string;
+
+      filename: string;
+
+      mimeType: string;
+
+      sizeBytes: number;
+    }
+  }
 }
 
 export interface ExecutionListResponse {
-  items: Array<FlowExecution>;
+  items: Array<ExecutionListResponse.Item>;
 
   pagination: Shared.Pagination;
 }
 
+export namespace ExecutionListResponse {
+  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';
+
+    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';
+
+    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 ExecutionGetMetricsResponse {
   data: ExecutionGetMetricsResponse.Data;
 }
@@ -139,9 +261,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,28 +1,32 @@
 // 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';
 
 export class Actions extends APIResource {
   /**
-   * List actions for a flow
+   * Return the ordered list of actions attached to a flow, including any nested
+   * child actions. Returns 404 if the flow does not exist.
    */
   list(flowID: string, options?: RequestOptions): APIPromise<ActionListResponse> {
     return this._client.get(path`/flows/${flowID}/actions`, options);
   }
 
   /**
-   * Add an action to a flow
+   * Append a single action to a flow at the given `position`, optionally nesting it
+   * under a `parentFlowActionId` or supplying its own `children`. Supports a
+   * `nameOverride`, param `overrides`, and `continueOnError`. Returns 404 if the
+   * flow does not exist.
    */
   add(flowID: string, body: ActionAddParams, options?: RequestOptions): APIPromise<ActionAddResponse> {
     return this._client.post(path`/flows/${flowID}/actions`, { body, ...options });
   }
 
   /**
-   * Remove an action from a flow
+   * Remove a single action from a flow by its `flowActionId`. Returns 404 if the
+   * flow or flow action does not exist.
    */
   remove(
     flowActionID: string,
@@ -34,7 +38,10 @@ export class Actions extends APIResource {
   }
 
   /**
-   * Replace all actions for a flow
+   * Replace a flow's entire action list with the supplied set (at least one
+   * required). Each action references an `actionId` and a unique `position`, and may
+   * include nested `children`, a `nameOverride`, param `overrides`, and a
+   * `continueOnError` flag. Returns 404 if the flow does not exist.
    */
   replace(
     flowID: string,
@@ -45,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 {
@@ -84,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 {
@@ -92,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;
 }
@@ -117,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,