@automate.ax/api-contract 0.45.0 → 0.47.0

package/dist/runtime.js

@@ -1,13 +1,194 @@
 import { encodableSchema } from "@automate.ax/codec";
 import { oc } from "@orpc/contract";
 import { z } from "zod";
+import { e164PhoneNumberSchema } from "./schemas.js";
 /** Default model used by the platform Vercel AI Gateway account. */
 export const DEFAULT_GATEWAY_MODEL_ID = "openai/gpt-4.1-nano";
 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 +307,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 +337,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),
@@ -240,4 +373,13 @@ export const runtimeContract = {
         .output(z.object({
         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/dist/schemas.d.ts

@@ -1,2 +1,4 @@
 import { z } from "zod";
 export declare const reasonableNameSchema: z.ZodString;
+/** Canonical E.164 phone number accepted by SMS boundaries. */
+export declare const e164PhoneNumberSchema: z.ZodString;

package/dist/schemas.js

@@ -1,2 +1,7 @@
 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.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automate.ax/api-contract",
-  "version": "0.45.0",
+  "version": "0.47.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.45.0",
+    "@automate.ax/codec": "0.47.0",
     "@orpc/contract": "1.13.14",
     "zod": "^4.3.6"
   },

package/src/automation.ts

@@ -73,7 +73,7 @@ export const automationContract = {
             name: z.string(),
             output: encodableSchema,
             slot: z.number().int().nonnegative(),
-            status: z.enum(["pending", "succeeded", "closed", "failed"]),
+            status: z.enum(["pending", "succeeded", "skipped", "failed"]),
           })
           .array(),
         events: z

package/src/index.ts

@@ -42,13 +42,14 @@ export {
   organizationDetailsOutputSchema,
   organizationInvitationOutputSchema,
   organizationMemberOutputSchema,
+  organizationPhoneNumberOutputSchema,
   organizationProjectOutputSchema,
   organizationRoleSchema,
   organizationSummaryOutputSchema,
   publicOrganizationOutputSchema,
 } from "./org"
 export { projectOutputSchema } from "./project"
-export { reasonableNameSchema } from "./schemas"
+export { e164PhoneNumberSchema, reasonableNameSchema } from "./schemas"
 export { userOutputSchema } from "./auth"
 export {
   managementPermissionStatement,
@@ -99,6 +100,9 @@ export const firstPartyContract = {
     canInvite: orgContract.canInvite,
     createBillingPortal: orgContract.createBillingPortal,
     createCheckout: orgContract.createCheckout,
+    removePhoneNumber: orgContract.removePhoneNumber,
+    requestPhoneNumberVerification: orgContract.requestPhoneNumberVerification,
+    verifyPhoneNumber: orgContract.verifyPhoneNumber,
   },
   project: {
     ...publicContract.project,

package/src/org.ts

@@ -1,6 +1,6 @@
 import { oc } from "@orpc/contract"
 import { z } from "zod"
-import { reasonableNameSchema } from "./schemas"
+import { e164PhoneNumberSchema, reasonableNameSchema } from "./schemas"
 
 export const organizationRoleSchema = z.enum(["member", "admin", "owner"])
 
@@ -34,13 +34,23 @@ export const organizationSummaryOutputSchema = z.object({
     emailRecipients: z.number(),
     projects: z.number(),
     seats: z.number(),
+    smsSegments: z.number(),
   }),
   usage: z.object({
     aiSpendUsd: z.number(),
     emailRecipients: z.number(),
+    smsSegments: z.number(),
   }),
 })
 
+export const organizationPhoneNumberOutputSchema = z.object({
+  id: z.string(),
+  phoneNumber: e164PhoneNumberSchema,
+  createdAt: z.date(),
+  verifiedAt: z.date().nullable(),
+  consentedAt: z.date().nullable(),
+})
+
 export const organizationMemberOutputSchema = z.object({
   id: z.string(),
   userId: z.string(),
@@ -70,6 +80,7 @@ export const organizationDetailsOutputSchema =
   organizationSummaryOutputSchema.extend({
     members: organizationMemberOutputSchema.array(),
     invitations: organizationInvitationOutputSchema.array(),
+    phoneNumbers: organizationPhoneNumberOutputSchema.array(),
     projects: organizationProjectOutputSchema.array(),
   })
 
@@ -197,6 +208,48 @@ export const orgContract = {
       }),
     )
     .output(z.void()),
+  removePhoneNumber: oc
+    .route({
+      method: "DELETE",
+      path: "/organizations/{organizationId}/phone-numbers/{phoneNumberId}",
+      operationId: "removeOrganizationPhoneNumber",
+      summary: "Remove organization phone number",
+      description:
+        "Removes an organization SMS destination and its verification and consent state.",
+      tags: ["Organizations"],
+      successStatus: 204,
+    })
+    .input(
+      z.object({
+        organizationId: z.string(),
+        phoneNumberId: z.string(),
+      }),
+    )
+    .output(z.void()),
+  requestPhoneNumberVerification: oc
+    .route({
+      method: "POST",
+      path: "/organizations/{organizationId}/phone-numbers/verifications",
+      operationId: "requestOrganizationPhoneNumberVerification",
+      summary: "Request organization phone verification",
+      description:
+        "Sends a verification code after the caller explicitly consents to organization automation SMS alerts.",
+      tags: ["Organizations"],
+      successStatus: 201,
+    })
+    .input(
+      z.object({
+        organizationId: z.string(),
+        phoneNumber: e164PhoneNumberSchema,
+        smsConsent: z.literal(true),
+      }),
+    )
+    .output(
+      z.object({
+        expiresAt: z.date(),
+        phoneNumberId: z.string(),
+      }),
+    ),
   update: oc
     .route({
       method: "PATCH",
@@ -214,4 +267,26 @@ export const orgContract = {
       }),
     )
     .output(z.void()),
+  verifyPhoneNumber: oc
+    .route({
+      method: "POST",
+      path: "/organizations/{organizationId}/phone-numbers/{phoneNumberId}/verification",
+      operationId: "verifyOrganizationPhoneNumber",
+      summary: "Verify organization phone number",
+      description:
+        "Verifies possession of an organization SMS destination and activates its recorded consent.",
+      tags: ["Organizations"],
+      successStatus: 204,
+    })
+    .input(
+      z.object({
+        organizationId: z.string(),
+        phoneNumberId: z.string(),
+        code: z
+          .string()
+          .trim()
+          .regex(/^\d{6}$/),
+      }),
+    )
+    .output(z.void()),
 }