@automate.ax/api-contract 0.44.0 → 0.46.0

package/dist/runtime.js

@@ -7,7 +7,187 @@ const SIGNAL_FAILURE_SCHEMA = z.object({
     message: z.string(),
     name: z.string(),
 });
-const TERMINAL_ACTION_STATUS_SCHEMA = z.enum(["closed", "failed", "succeeded"]);
+const OUTCOME_SEQUENCE_SCHEMA = z.number().int().positive();
+const ACTION_INVOCATION_BASE_SCHEMA = z.object({
+    actionDependencyIds: z.string().array(),
+    description: z.string().nullable(),
+    eventDependencyIds: z.string().array(),
+    inputHash: z.string(),
+    name: z.string(),
+    signalDependencyIds: z.string().array(),
+    slot: z.number().int().nonnegative(),
+});
+const ACTION_INVOCATION_SCHEMA = z.union([
+    ACTION_INVOCATION_BASE_SCHEMA.extend({ status: z.literal("pending") }),
+    ACTION_INVOCATION_BASE_SCHEMA.extend({
+        reason: z.literal("closed-dependency"),
+        status: z.literal("skipped"),
+    }),
+    ACTION_INVOCATION_BASE_SCHEMA.extend({
+        failure: SIGNAL_FAILURE_SCHEMA,
+        reason: z.literal("failed-dependency"),
+        status: z.literal("skipped"),
+    }),
+]);
+const ACTION_RUN_INVOCATION_BASE_SCHEMA = ACTION_INVOCATION_BASE_SCHEMA.extend({
+    actionInvocationId: z.string(),
+});
+const ACTION_RUN_INVOCATION_SCHEMA = z.union([
+    ACTION_RUN_INVOCATION_BASE_SCHEMA.extend({ status: z.literal("pending") }),
+    ACTION_RUN_INVOCATION_BASE_SCHEMA.extend({
+        failure: SIGNAL_FAILURE_SCHEMA,
+        outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
+        status: z.literal("failed"),
+    }),
+    ACTION_RUN_INVOCATION_BASE_SCHEMA.extend({
+        outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
+        reason: z.literal("closed-dependency"),
+        status: z.literal("skipped"),
+    }),
+    ACTION_RUN_INVOCATION_BASE_SCHEMA.extend({
+        failure: SIGNAL_FAILURE_SCHEMA,
+        outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
+        reason: z.literal("failed-dependency"),
+        status: z.literal("skipped"),
+    }),
+    ACTION_RUN_INVOCATION_BASE_SCHEMA.extend({
+        outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
+        status: z.literal("succeeded"),
+    }),
+]);
+const SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA = z.object({
+    actionDependencyIds: z.string().array(),
+    eventDependencyIds: z.string().array(),
+    signalDependencyIds: z.string().array(),
+    slot: z.number().int().nonnegative(),
+});
+const CORRELATION_ENTRY_SCHEMA = SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
+    key: encodableSchema,
+    outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
+    streamName: z.string().min(1),
+    streamNames: z.string().min(1).array().min(2),
+    value: encodableSchema,
+});
+const SIGNAL_INVOCATION_SCHEMA = z.union([
+    SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
+        outcomeSeq: OUTCOME_SEQUENCE_SCHEMA.optional(),
+        status: z.literal("closed"),
+    }),
+    SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
+        failure: SIGNAL_FAILURE_SCHEMA,
+        status: z.literal("failed"),
+    }),
+    SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
+        outcomeSeq: OUTCOME_SEQUENCE_SCHEMA.optional(),
+        selectedIndex: z.number().int().nonnegative().optional(),
+        status: z.literal("open"),
+    }),
+]);
+const SIGNAL_BATCH_OUTCOME_BASE_SCHEMA = SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
+    outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
+    signalInvocationId: z.string(),
+});
+const SIGNAL_BATCH_OUTCOME_SCHEMA = z.union([
+    SIGNAL_BATCH_OUTCOME_BASE_SCHEMA.extend({
+        selectedIndex: z.number().int().nonnegative().optional(),
+        status: z.literal("open"),
+    }),
+    SIGNAL_BATCH_OUTCOME_BASE_SCHEMA.extend({ status: z.literal("closed") }),
+    SIGNAL_BATCH_OUTCOME_BASE_SCHEMA.extend({
+        failure: SIGNAL_FAILURE_SCHEMA,
+        status: z.literal("failed"),
+    }),
+    SIGNAL_BATCH_OUTCOME_BASE_SCHEMA.extend({ status: z.literal("succeeded") }),
+]);
+const ACTION_VALUE_OUTCOME_SCHEMA = z.union([
+    z.object({
+        actionInvocationId: z.string(),
+        outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
+        slot: z.number().int(),
+        status: z.literal("failed"),
+        failure: SIGNAL_FAILURE_SCHEMA,
+    }),
+    z.object({
+        actionInvocationId: z.string(),
+        outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
+        reason: z.literal("closed-dependency"),
+        slot: z.number().int(),
+        status: z.literal("skipped"),
+    }),
+    z.object({
+        actionInvocationId: z.string(),
+        failure: SIGNAL_FAILURE_SCHEMA,
+        outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
+        reason: z.literal("failed-dependency"),
+        slot: z.number().int(),
+        status: z.literal("skipped"),
+    }),
+    z.object({
+        actionInvocationId: z.string(),
+        outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
+        output: encodableSchema,
+        slot: z.number().int(),
+        status: z.literal("succeeded"),
+    }),
+]);
+const SIGNAL_VALUE_OUTCOME_BASE_SCHEMA = z.object({
+    outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
+    signalInvocationId: z.string(),
+    slot: z.number().int(),
+});
+const SIGNAL_VALUE_OUTCOME_SCHEMA = z.union([
+    SIGNAL_VALUE_OUTCOME_BASE_SCHEMA.extend({
+        selectedIndex: z.number().int().nonnegative().optional(),
+        status: z.literal("open"),
+    }),
+    SIGNAL_VALUE_OUTCOME_BASE_SCHEMA.extend({ status: z.literal("closed") }),
+    SIGNAL_VALUE_OUTCOME_BASE_SCHEMA.extend({
+        failure: SIGNAL_FAILURE_SCHEMA,
+        status: z.literal("failed"),
+    }),
+    SIGNAL_VALUE_OUTCOME_BASE_SCHEMA.extend({
+        output: encodableSchema,
+        status: z.literal("succeeded"),
+    }),
+]);
+const RUNTIME_VALUE_CONTEXT_SCHEMA = z.object({
+    actionOutputs: ACTION_VALUE_OUTCOME_SCHEMA.array(),
+    contextId: z.string(),
+    events: z
+        .object({
+        automationEventId: z.string(),
+        outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
+        payload: encodableSchema,
+        slot: z.number().int(),
+    })
+        .array(),
+    signalOutputs: SIGNAL_VALUE_OUTCOME_SCHEMA.array(),
+});
+const RUNTIME_RUN_CONTEXT_SCHEMA = z.object({
+    actions: ACTION_RUN_INVOCATION_SCHEMA.array(),
+    contextId: z.string(),
+    events: z
+        .object({
+        automationEventId: z.string(),
+        outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
+        slot: z.number().int(),
+    })
+        .array(),
+    signalOutputs: SIGNAL_BATCH_OUTCOME_SCHEMA.array(),
+});
+const TARGET_ACTION_SCHEMA = z.union([
+    z.object({
+        context: RUNTIME_VALUE_CONTEXT_SCHEMA,
+        id: z.string(),
+        slot: z.number().int(),
+        status: z.literal("pending"),
+    }),
+    z.object({
+        id: z.string(),
+        slot: z.number().int(),
+        status: z.enum(["failed", "skipped", "succeeded"]),
+    }),
+]);
 const GENERATION_WARNING_SCHEMA = z.discriminatedUnion("type", [
     z.object({
         details: z.string().optional(),
@@ -126,22 +306,23 @@ const RUNTIME_GENERATION_INPUT_SCHEMA = z.union([
 export const runtimeContract = {
     commit: oc
         .input(z.object({
-        actionInvocations: z
-            .object({
-            actionDependencyIds: z.string().array(),
-            description: z.string().nullable(),
-            eventDependencyIds: z.string().array(),
-            inputHash: z.string(),
-            name: z.string(),
-            slot: z.number().int().nonnegative(),
-        })
-            .array()
-            .default([]),
+        actionInvocations: ACTION_INVOCATION_SCHEMA.array().default([]),
+        correlationEntries: CORRELATION_ENTRY_SCHEMA.array().default([]),
+        settled: z.boolean().default(true),
+        signalInvocations: SIGNAL_INVOCATION_SCHEMA.array().default([]),
     }))
         .output(z.void()),
-    completeInvocation: oc
-        .input(z.discriminatedUnion("status", [
-        z.object({ status: z.literal("closed") }),
+    completeAction: oc
+        .input(z.union([
+        z.object({
+            reason: z.literal("closed-dependency"),
+            status: z.literal("skipped"),
+        }),
+        z.object({
+            failure: SIGNAL_FAILURE_SCHEMA,
+            reason: z.literal("failed-dependency"),
+            status: z.literal("skipped"),
+        }),
         z.object({
             failure: SIGNAL_FAILURE_SCHEMA,
             status: z.literal("failed"),
@@ -155,63 +336,14 @@ export const runtimeContract = {
     generate: oc
         .input(RUNTIME_GENERATION_INPUT_SCHEMA)
         .output(generationResultSchema),
-    loadInvocation: oc.output(z.object({
-        context: z.object({
-            actionOutputs: z
-                .discriminatedUnion("status", [
-                z.object({
-                    actionInvocationId: z.string(),
-                    slot: z.number().int(),
-                    status: z.literal("closed"),
-                }),
-                z.object({
-                    actionInvocationId: z.string(),
-                    failure: SIGNAL_FAILURE_SCHEMA,
-                    slot: z.number().int(),
-                    status: z.literal("failed"),
-                }),
-                z.object({
-                    actionInvocationId: z.string(),
-                    output: encodableSchema,
-                    slot: z.number().int(),
-                    status: z.literal("succeeded"),
-                }),
-            ])
-                .array(),
-            contextId: z.string(),
-            events: z
-                .object({
-                automationEventId: z.string(),
-                payload: encodableSchema,
-                slot: z.number().int(),
-            })
-                .array(),
-        }),
-        id: z.string(),
-        slot: z.number().int(),
-    })),
-    nextBatch: oc.output(z.object({
-        context: z.object({
-            actionOutputs: z
-                .object({
-                actionDependencyIds: z.string().array(),
-                actionInvocationId: z.string(),
-                eventDependencyIds: z.string().array(),
-                inputHash: z.string(),
-                name: z.string(),
-                slot: z.number().int(),
-                status: TERMINAL_ACTION_STATUS_SCHEMA,
-            })
-                .array(),
-            contextId: z.string(),
-            events: z
-                .object({
-                automationEventId: z.string(),
-                slot: z.number().int(),
-            })
-                .array(),
-        }),
+    load: oc.output(z.object({
+        context: RUNTIME_RUN_CONTEXT_SCHEMA,
+        finalAttempt: z.boolean(),
+        targetAction: TARGET_ACTION_SCHEMA.optional(),
     })),
+    loadValues: oc
+        .input(SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.omit({ slot: true }))
+        .output(RUNTIME_VALUE_CONTEXT_SCHEMA),
     resolveAccountInput: oc
         .input(z.strictObject({
         binding: z.string().min(1),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automate.ax/api-contract",
-  "version": "0.44.0",
+  "version": "0.46.0",
   "description": "Public oRPC contract for the Automate.ax API.",
   "license": "MIT",
   "repository": {
@@ -27,7 +27,7 @@
   },
   "dependencies": {
     "@ai-sdk/gateway": "^4.0.46",
-    "@automate.ax/codec": "0.44.0",
+    "@automate.ax/codec": "0.46.0",
     "@orpc/contract": "1.13.14",
     "zod": "^4.3.6"
   },

package/src/automation.ts

@@ -0,0 +1,108 @@
+import { encodableSchema } from "@automate.ax/codec"
+import { oc } from "@orpc/contract"
+import { z } from "zod"
+import { deploymentTriggerInfoSchema } from "./deployment"
+
+export const automationExecutionStatusSchema = z.enum([
+  "running",
+  "completed",
+  "failed",
+])
+
+const EXECUTION_FAILURE_SCHEMA = z.object({
+  message: z.string(),
+  name: z.string(),
+})
+
+const EXECUTION_SUMMARY_SCHEMA = z.object({
+  completedAt: z.date().nullable(),
+  createdAt: z.date(),
+  eventTypes: z.string().array(),
+  failure: EXECUTION_FAILURE_SCHEMA.nullable(),
+  id: z.string(),
+  status: automationExecutionStatusSchema,
+})
+
+export const automationContract = {
+  get: oc
+    .input(
+      z.object({
+        automationId: z.string(),
+        projectId: z.string(),
+      }),
+    )
+    .output(
+      z.object({
+        activeDeployment: z.object({
+          createdAt: z.date(),
+          git: z
+            .object({
+              commitSha: z.string(),
+              dirty: z.boolean(),
+              repositoryUrl: z.string(),
+            })
+            .nullable(),
+          id: z.string(),
+        }),
+        createdAt: z.date(),
+        description: z.string(),
+        id: z.string(),
+        identityKey: z.string(),
+        triggers: deploymentTriggerInfoSchema.array(),
+        updatedAt: z.date(),
+      }),
+    ),
+  getExecution: oc
+    .input(
+      z.object({
+        automationId: z.string(),
+        executionId: z.string(),
+        projectId: z.string(),
+      }),
+    )
+    .output(
+      EXECUTION_SUMMARY_SCHEMA.omit({ eventTypes: true }).extend({
+        actions: z
+          .object({
+            completedAt: z.date().nullable(),
+            createdAt: z.date(),
+            description: z.string().nullable(),
+            failure: EXECUTION_FAILURE_SCHEMA.nullable(),
+            hasOutput: z.boolean(),
+            id: z.string(),
+            name: z.string(),
+            output: encodableSchema,
+            slot: z.number().int().nonnegative(),
+            status: z.enum(["pending", "succeeded", "skipped", "failed"]),
+          })
+          .array(),
+        events: z
+          .object({
+            createdAt: z.date(),
+            id: z.string(),
+            payload: encodableSchema,
+            type: z.string(),
+          })
+          .array(),
+        outputs: z
+          .object({
+            actionInvocationId: z.string(),
+            createdAt: z.date(),
+            data: encodableSchema,
+            id: z.string(),
+            outputIndex: z.number().int().nonnegative(),
+            type: z.string(),
+          })
+          .array(),
+      }),
+    ),
+  listExecutions: oc
+    .input(
+      z.object({
+        automationId: z.string(),
+        limit: z.number().int().min(1).max(100).default(50),
+        projectId: z.string(),
+      }),
+    )
+    .output(EXECUTION_SUMMARY_SCHEMA.array()),
+}

package/src/deployment.ts

@@ -95,10 +95,12 @@ export const deploymentContract = {
         automations: z
           .object({
             description: z.string(),
+            id: z.string(),
             identityKey: z.string(),
             triggers: deploymentTriggerInfoSchema.array(),
           })
           .array(),
+        createdAt: z.date(),
         id: z.string(),
         git: GIT_SOURCE_SCHEMA.nullable(),
         job: z

package/src/index.ts

@@ -1,4 +1,5 @@
 import { accountContract } from "./account"
+import { automationContract } from "./automation"
 import { apiKeyContract } from "./api-key"
 import { authContract } from "./auth"
 import { authorizationContract } from "./authorization"
@@ -8,6 +9,7 @@ import { orgContract } from "./org"
 import { projectContract } from "./project"
 import { runtimeContract } from "./runtime"
 
+export { automationExecutionStatusSchema } from "./automation"
 export {
   AUTOMATION_SDK_VERSION,
   deploymentTriggerInfoSchema,
@@ -84,6 +86,7 @@ export const publicContract = {
 export const firstPartyContract = {
   ...publicContract,
   account: accountContract,
+  automation: automationContract,
   authorization: {
     beginConnection: authorizationContract.beginConnection,
     get: authorizationContract.get,

package/src/project.ts

@@ -3,6 +3,7 @@ import { z } from "zod"
 import { reasonableNameSchema } from "./schemas"
 
 export const projectOutputSchema = z.object({
+  activeDeploymentId: z.string().nullable(),
   id: z.string(),
   name: z.string(),
   organizationId: z.string(),
@@ -15,6 +16,7 @@ export const projectOutputSchema = z.object({
   activeAutomations: z
     .object({
       description: z.string(),
+      id: z.string(),
       identityKey: z.string(),
     })
     .array(),