@automate.ax/api-contract 0.45.0 → 0.47.0

package/src/runtime.ts

@@ -2,6 +2,7 @@ import { encodableSchema } from "@automate.ax/codec"
 import type { GatewayModelId } from "@ai-sdk/gateway"
 import { oc } from "@orpc/contract"
 import { z } from "zod"
+import { e164PhoneNumberSchema } from "./schemas"
 
 /** Default model used by the platform Vercel AI Gateway account. */
 export const DEFAULT_GATEWAY_MODEL_ID =
@@ -12,7 +13,203 @@ const SIGNAL_FAILURE_SCHEMA = z.object({
   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({
@@ -153,24 +350,25 @@ 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
+  completeAction: oc
     .input(
-      z.discriminatedUnion("status", [
-        z.object({ status: z.literal("closed") }),
+      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"),
@@ -185,67 +383,16 @@ export const runtimeContract = {
   generate: oc
     .input(RUNTIME_GENERATION_INPUT_SCHEMA)
     .output(generationResultSchema),
-  loadInvocation: oc.output(
+  load: 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(),
-      }),
+      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({
@@ -284,4 +431,17 @@ export const runtimeContract = {
         id: z.string().nullable(),
       }),
     ),
+  sendSms: oc
+    .input(
+      z.object({
+        deliveryIndex: z.number().int().nonnegative().default(0),
+        text: z.string().trim().min(1).max(1_000),
+        to: z.union([e164PhoneNumberSchema, z.literal("*")]).default("*"),
+      }),
+    )
+    .output(
+      z.object({
+        ids: z.string().array(),
+      }),
+    ),
 }

package/src/schemas.ts

@@ -1,3 +1,9 @@
 import { z } from "zod"
 
 export const reasonableNameSchema = z.string().min(1).max(255).trim()
+
+/** Canonical E.164 phone number accepted by SMS boundaries. */
+export const e164PhoneNumberSchema = z
+  .string()
+  .trim()
+  .regex(/^\+[1-9]\d{1,14}$/, "Use an E.164 phone number such as +12065550123.")