@automate.ax/api-contract 0.12.0 → 0.14.0

package/dist/events/index.d.ts

@@ -1,4 +1,9 @@
 export declare const eventsContract: {
+    slackEvent: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        type: import("zod").ZodString;
+    }, import("zod/v4/core").$loose>, import("zod").ZodObject<{
+        challenge: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
     gmailPush: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
         message: import("zod").ZodObject<{
             data: import("zod").ZodString;

package/dist/events/index.js

@@ -1,8 +1,10 @@
 import { googleCalendarEventsContract } from "./google-calendar.js";
 import { googleFormsEventsContract } from "./google-forms.js";
 import { gmailEventsContract } from "./gmail.js";
+import { slackEventsContract } from "./slack.js";
 export const eventsContract = {
     ...googleCalendarEventsContract,
     ...googleFormsEventsContract,
     ...gmailEventsContract,
+    ...slackEventsContract,
 };

package/dist/events/slack.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const slackEventsContract: {
+    slackEvent: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        type: z.ZodString;
+    }, z.core.$loose>, z.ZodObject<{
+        challenge: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, Record<never, never>, Record<never, never>>;
+};

package/dist/events/slack.js

@@ -0,0 +1,22 @@
+import { oc } from "@orpc/contract";
+import { z } from "zod";
+export const slackEventsContract = {
+    slackEvent: oc
+        .route({
+        method: "POST",
+        path: "/events/slack",
+        operationId: "receiveSlackEvent",
+        summary: "Receive a Slack event",
+        description: "Receives and authenticates callbacks delivered by the Slack Events API.",
+        tags: ["Events"],
+        successStatus: 200,
+    })
+        .input(z.looseObject({
+        /** Slack callback category. */
+        type: z.string(),
+    }))
+        .output(z.object({
+        /** Request URL verification challenge, when Slack is configuring it. */
+        challenge: z.string().optional(),
+    })),
+};

package/dist/index.d.ts

@@ -742,6 +742,11 @@ export declare const contract: {
         }, import("zod/v4/core").$strip>, import("zod").ZodVoid, Record<never, never>, Record<never, never>>;
     };
     events: {
+        slackEvent: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+            type: import("zod").ZodString;
+        }, import("zod/v4/core").$loose>, import("zod").ZodObject<{
+            challenge: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
         gmailPush: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
             message: import("zod").ZodObject<{
                 data: import("zod").ZodString;
@@ -777,16 +782,38 @@ export declare const contract: {
                 slot: import("zod").ZodNumber;
             }, import("zod/v4/core").$strip>>>;
         }, import("zod/v4/core").$strip>, import("zod").ZodVoid, Record<never, never>, Record<never, never>>;
-        completeInvocation: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        completeInvocation: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            status: import("zod").ZodLiteral<"closed">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            failure: import("zod").ZodObject<{
+                message: import("zod").ZodString;
+                name: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+            status: import("zod").ZodLiteral<"failed">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
             output: import("zod").ZodOptional<import("zod").ZodCustom<import("@automate.ax/codec").Encodable, import("@automate.ax/codec").Encodable>>;
-        }, import("zod/v4/core").$strip>, import("zod").ZodVoid, Record<never, never>, Record<never, never>>;
+            status: import("zod").ZodLiteral<"succeeded">;
+        }, import("zod/v4/core").$strip>], "status">, import("zod").ZodVoid, Record<never, never>, Record<never, never>>;
         loadInvocation: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
             context: import("zod").ZodObject<{
-                actionOutputs: import("zod").ZodArray<import("zod").ZodObject<{
+                actionOutputs: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    actionInvocationId: import("zod").ZodString;
+                    slot: import("zod").ZodNumber;
+                    status: import("zod").ZodLiteral<"closed">;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    actionInvocationId: import("zod").ZodString;
+                    failure: import("zod").ZodObject<{
+                        message: import("zod").ZodString;
+                        name: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                    slot: import("zod").ZodNumber;
+                    status: import("zod").ZodLiteral<"failed">;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
                     actionInvocationId: import("zod").ZodString;
                     output: import("zod").ZodOptional<import("zod").ZodCustom<import("@automate.ax/codec").Encodable, import("@automate.ax/codec").Encodable>>;
                     slot: import("zod").ZodNumber;
-                }, import("zod/v4/core").$strip>>;
+                    status: import("zod").ZodLiteral<"succeeded">;
+                }, import("zod/v4/core").$strip>], "status">>;
                 contextId: import("zod").ZodString;
                 events: import("zod").ZodArray<import("zod").ZodObject<{
                     automationEventId: import("zod").ZodString;
@@ -806,6 +833,11 @@ export declare const contract: {
                     inputHash: import("zod").ZodString;
                     name: import("zod").ZodString;
                     slot: import("zod").ZodNumber;
+                    status: import("zod").ZodEnum<{
+                        succeeded: "succeeded";
+                        failed: "failed";
+                        closed: "closed";
+                    }>;
                 }, import("zod/v4/core").$strip>>;
                 contextId: import("zod").ZodString;
                 events: import("zod").ZodArray<import("zod").ZodObject<{

package/dist/runtime.d.ts

@@ -10,16 +10,38 @@ export declare const runtimeContract: {
             slot: z.ZodNumber;
         }, z.core.$strip>>>;
     }, z.core.$strip>, z.ZodVoid, Record<never, never>, Record<never, never>>;
-    completeInvocation: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    completeInvocation: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"closed">;
+    }, z.core.$strip>, z.ZodObject<{
+        failure: z.ZodObject<{
+            message: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>;
+        status: z.ZodLiteral<"failed">;
+    }, z.core.$strip>, z.ZodObject<{
         output: z.ZodOptional<z.ZodCustom<import("@automate.ax/codec").Encodable, import("@automate.ax/codec").Encodable>>;
-    }, z.core.$strip>, z.ZodVoid, Record<never, never>, Record<never, never>>;
+        status: z.ZodLiteral<"succeeded">;
+    }, z.core.$strip>], "status">, z.ZodVoid, Record<never, never>, Record<never, never>>;
     loadInvocation: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodObject<{
         context: z.ZodObject<{
-            actionOutputs: z.ZodArray<z.ZodObject<{
+            actionOutputs: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                actionInvocationId: z.ZodString;
+                slot: z.ZodNumber;
+                status: z.ZodLiteral<"closed">;
+            }, z.core.$strip>, z.ZodObject<{
+                actionInvocationId: z.ZodString;
+                failure: z.ZodObject<{
+                    message: z.ZodString;
+                    name: z.ZodString;
+                }, z.core.$strip>;
+                slot: z.ZodNumber;
+                status: z.ZodLiteral<"failed">;
+            }, z.core.$strip>, z.ZodObject<{
                 actionInvocationId: z.ZodString;
                 output: z.ZodOptional<z.ZodCustom<import("@automate.ax/codec").Encodable, import("@automate.ax/codec").Encodable>>;
                 slot: z.ZodNumber;
-            }, z.core.$strip>>;
+                status: z.ZodLiteral<"succeeded">;
+            }, z.core.$strip>], "status">>;
             contextId: z.ZodString;
             events: z.ZodArray<z.ZodObject<{
                 automationEventId: z.ZodString;
@@ -39,6 +61,11 @@ export declare const runtimeContract: {
                 inputHash: z.ZodString;
                 name: z.ZodString;
                 slot: z.ZodNumber;
+                status: z.ZodEnum<{
+                    succeeded: "succeeded";
+                    failed: "failed";
+                    closed: "closed";
+                }>;
             }, z.core.$strip>>;
             contextId: z.ZodString;
             events: z.ZodArray<z.ZodObject<{

package/dist/runtime.js

@@ -1,6 +1,11 @@
 import { encodableSchema } from "@automate.ax/codec";
 import { oc } from "@orpc/contract";
 import { z } from "zod";
+const SIGNAL_FAILURE_SCHEMA = z.object({
+    message: z.string(),
+    name: z.string(),
+});
+const TERMINAL_ACTION_STATUS_SCHEMA = z.enum(["closed", "failed", "succeeded"]);
 export const runtimeContract = {
     commit: oc
         .input(z.object({
@@ -18,18 +23,40 @@ export const runtimeContract = {
     }))
         .output(z.void()),
     completeInvocation: oc
-        .input(z.object({
-        output: encodableSchema,
-    }))
+        .input(z.discriminatedUnion("status", [
+        z.object({ status: z.literal("closed") }),
+        z.object({
+            failure: SIGNAL_FAILURE_SCHEMA,
+            status: z.literal("failed"),
+        }),
+        z.object({
+            output: encodableSchema,
+            status: z.literal("succeeded"),
+        }),
+    ]))
         .output(z.void()),
     loadInvocation: oc.output(z.object({
         context: z.object({
             actionOutputs: z
-                .object({
-                actionInvocationId: z.string(),
-                output: encodableSchema,
-                slot: z.number().int(),
-            })
+                .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
@@ -53,6 +80,7 @@ export const runtimeContract = {
                 inputHash: z.string(),
                 name: z.string(),
                 slot: z.number().int(),
+                status: TERMINAL_ACTION_STATUS_SCHEMA,
             })
                 .array(),
             contextId: z.string(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automate.ax/api-contract",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "Public oRPC contract for the Automate.ax API.",
   "license": "MIT",
   "repository": {
@@ -26,7 +26,7 @@
     }
   },
   "dependencies": {
-    "@automate.ax/codec": "0.12.0",
+    "@automate.ax/codec": "0.14.0",
     "@orpc/contract": "1.13.14",
     "zod": "^4.3.6"
   },

package/src/events/index.ts

@@ -1,9 +1,11 @@
 import { googleCalendarEventsContract } from "./google-calendar"
 import { googleFormsEventsContract } from "./google-forms"
 import { gmailEventsContract } from "./gmail"
+import { slackEventsContract } from "./slack"
 
 export const eventsContract = {
   ...googleCalendarEventsContract,
   ...googleFormsEventsContract,
   ...gmailEventsContract,
+  ...slackEventsContract,
 }

package/src/events/slack.ts

@@ -0,0 +1,28 @@
+import { oc } from "@orpc/contract"
+import { z } from "zod"
+
+export const slackEventsContract = {
+  slackEvent: oc
+    .route({
+      method: "POST",
+      path: "/events/slack",
+      operationId: "receiveSlackEvent",
+      summary: "Receive a Slack event",
+      description:
+        "Receives and authenticates callbacks delivered by the Slack Events API.",
+      tags: ["Events"],
+      successStatus: 200,
+    })
+    .input(
+      z.looseObject({
+        /** Slack callback category. */
+        type: z.string(),
+      }),
+    )
+    .output(
+      z.object({
+        /** Request URL verification challenge, when Slack is configuring it. */
+        challenge: z.string().optional(),
+      }),
+    ),
+}

package/src/runtime.ts

@@ -2,6 +2,13 @@ import { encodableSchema } from "@automate.ax/codec"
 import { oc } from "@orpc/contract"
 import { z } from "zod"
 
+const SIGNAL_FAILURE_SCHEMA = z.object({
+  message: z.string(),
+  name: z.string(),
+})
+
+const TERMINAL_ACTION_STATUS_SCHEMA = z.enum(["closed", "failed", "succeeded"])
+
 export const runtimeContract = {
   commit: oc
     .input(
@@ -22,20 +29,42 @@ export const runtimeContract = {
     .output(z.void()),
   completeInvocation: oc
     .input(
-      z.object({
-        output: encodableSchema,
-      }),
+      z.discriminatedUnion("status", [
+        z.object({ status: z.literal("closed") }),
+        z.object({
+          failure: SIGNAL_FAILURE_SCHEMA,
+          status: z.literal("failed"),
+        }),
+        z.object({
+          output: encodableSchema,
+          status: z.literal("succeeded"),
+        }),
+      ]),
     )
     .output(z.void()),
   loadInvocation: oc.output(
     z.object({
       context: z.object({
         actionOutputs: z
-          .object({
-            actionInvocationId: z.string(),
-            output: encodableSchema,
-            slot: z.number().int(),
-          })
+          .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
@@ -61,6 +90,7 @@ export const runtimeContract = {
             inputHash: z.string(),
             name: z.string(),
             slot: z.number().int(),
+            status: TERMINAL_ACTION_STATUS_SCHEMA,
           })
           .array(),
         contextId: z.string(),