@automate.ax/api-contract 0.87.0 → 0.87.2

package/dist/runtime.js

@@ -1,4 +1,5 @@
 import { encodableSchema, isSensitivityMask, } from "@automate.ax/codec";
+import { codecEnvelopeSchema } from "@automate.ax/codec/rpc";
 import { oc } from "@orpc/contract";
 import stableStringify from "fast-json-stable-stringify";
 import * as z from "zod";
@@ -16,30 +17,11 @@ export const AUTOMATION_LOG_MAX_ENTRIES = 1_000;
 export const AUTOMATION_TRACE_MAX_SPANS = 250;
 export const AUTOMATION_OBSERVABILITY_MAX_FIELDS = 64;
 export const AUTOMATION_OBSERVABILITY_MAX_ENCODED_BYTES = 64 * 1_024;
-const RUNTIME_BLOB_JSON_SERIALIZER_TYPE = 8;
-/** Blob wrappers that should use oRPC's native multipart serialization. */
-const runtimeBlobTransportValues = new WeakSet();
-/** Preserves Blob media types while oRPC carries the bytes as multipart data. */
-export const runtimeBlobJsonSerializer = {
-    type: RUNTIME_BLOB_JSON_SERIALIZER_TYPE,
-    condition: (value) => value instanceof Blob && !runtimeBlobTransportValues.has(value),
-    serialize(value) {
-        const transportValue = new Blob([value]);
-        runtimeBlobTransportValues.add(transportValue);
-        return { transportValue, type: value.type };
-    },
-    deserialize(value) {
-        const { transportValue, type } = z
-            .object({ transportValue: z.instanceof(Blob), type: z.string() })
-            .parse(value);
-        return new Blob([transportValue], { type });
-    },
-};
 export const AUTOMATION_LOG_MAX_MESSAGE_LENGTH = 16_384;
 export const AUTOMATION_TRACE_MAX_NAME_LENGTH = 256;
 const OUTCOME_SEQUENCE_SCHEMA = z.number().int().positive();
 const HOOK_SCOPE_PATH_SCHEMA = z.number().int().nonnegative().array();
-const OBSERVABILITY_FIELDS_SCHEMA = z
+export const runtimeObservabilityFieldsSchema = z
     .record(z.string().min(1).max(128), encodableSchema)
     .refine((fields) => Object.keys(fields).length <= AUTOMATION_OBSERVABILITY_MAX_FIELDS, `Observability fields may contain at most ${AUTOMATION_OBSERVABILITY_MAX_FIELDS} entries.`);
 const LOG_INDEX_SCHEMA = z
@@ -99,15 +81,13 @@ export const automationInvocationOutputSchema = z.object({
     id: z.string(),
     runAt: z.date(),
 });
-export const automationInvocationInputSchema = z
-    .object({
+const AUTOMATION_INVOCATION_BASE_SCHEMA = z.object({
     entrypoint: z
         .string()
         .min(1)
         .default(AUTOMATION_INVOCATION_DEFAULT_ENTRYPOINT),
-    payload: encodableSchema,
-})
-    .and(z.union([
+});
+const AUTOMATION_INVOCATION_TARGET_SCHEMA = z.union([
     z.object({
         automationId: z.string().min(1),
         automationName: z.never().optional(),
@@ -116,7 +96,14 @@ export const automationInvocationInputSchema = z
         automationId: z.never().optional(),
         automationName: z.string().min(1),
     }),
-]))
+]);
+export const automationInvocationInputSchema = AUTOMATION_INVOCATION_BASE_SCHEMA.extend({ payload: encodableSchema })
+    .and(AUTOMATION_INVOCATION_TARGET_SCHEMA)
+    .and(automationInvocationScheduleSchema);
+const AUTOMATION_INVOCATION_TRANSPORT_INPUT_SCHEMA = AUTOMATION_INVOCATION_BASE_SCHEMA.extend({
+    payload: codecEnvelopeSchema,
+})
+    .and(AUTOMATION_INVOCATION_TARGET_SCHEMA)
     .and(automationInvocationScheduleSchema);
 const SIGNAL_DERIVATION_NODE_SCHEMA = z.discriminatedUnion("type", [
     z.object({
@@ -237,8 +224,8 @@ const CORRELATION_STREAM_ORIGINS_SCHEMA = z
     .min(1)
     .array()
     .min(2);
-const CORRELATION_OFFER_SCHEMA = SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
-    key: encodableSchema,
+const createCorrelationOfferSchema = (keySchema) => SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
+    key: keySchema,
     ordered: z.boolean(),
     outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
     policy: z.literal("correlate"),
@@ -254,9 +241,9 @@ const CORRELATION_OFFER_SCHEMA = SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
         });
     }
 });
-const COLLECTION_OFFER_SCHEMA = SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
+const createCollectionOfferSchema = (keySchema) => SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
     count: z.number().int().positive(),
-    key: encodableSchema,
+    key: keySchema,
     outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
     policy: z.literal("collect"),
     position: z.number().int().nonnegative().optional(),
@@ -268,8 +255,8 @@ const FANOUT_OFFER_SCHEMA = SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
     outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
     policy: z.literal("fanout"),
 });
-const FUNNEL_OFFER_SCHEMA = SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
-    key: encodableSchema,
+const createFunnelOfferSchema = (keySchema) => SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
+    key: keySchema,
     maxBurstDuration: COORDINATION_DURATION_SCHEMA.optional(),
     minGap: COORDINATION_DURATION_SCHEMA.optional(),
     minQuietPeriod: COORDINATION_DURATION_SCHEMA.optional(),
@@ -308,7 +295,8 @@ const FUNNEL_OFFER_SCHEMA = SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
             path: ["until"],
         });
     }
-    if (offer.selection !== "all" && offer.selection !== offer.primaryPosition) {
+    if (offer.selection !== "all" &&
+        offer.selection !== offer.primaryPosition) {
         context.addIssue({
             code: "custom",
             message: "A selecting funnel must inherit conflicting values from its selected occurrence.",
@@ -323,6 +311,9 @@ const FUNNEL_OFFER_SCHEMA = SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
         });
     }
 });
+const COLLECTION_OFFER_SCHEMA = createCollectionOfferSchema(encodableSchema);
+const CORRELATION_OFFER_SCHEMA = createCorrelationOfferSchema(encodableSchema);
+const FUNNEL_OFFER_SCHEMA = createFunnelOfferSchema(encodableSchema);
 const RACE_OFFER_BASE_SCHEMA = SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
     cohortActionDependencyIds: z.string().array(),
     cohortEventDependencyIds: z.string().array(),
@@ -354,6 +345,13 @@ const COORDINATION_OFFER_SCHEMA = z.union([
     FUNNEL_OFFER_SCHEMA,
     RACE_OFFER_SCHEMA,
 ]);
+const COORDINATION_OFFER_TRANSPORT_SCHEMA = z.union([
+    createCollectionOfferSchema(codecEnvelopeSchema),
+    createCorrelationOfferSchema(codecEnvelopeSchema),
+    FANOUT_OFFER_SCHEMA,
+    createFunnelOfferSchema(codecEnvelopeSchema),
+    RACE_OFFER_SCHEMA,
+]);
 const SIGNAL_INVOCATION_SCHEMA = z.union([
     SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
         outcomeSeq: OUTCOME_SEQUENCE_SCHEMA.optional(),
@@ -420,6 +418,27 @@ const ACTION_VALUE_OUTCOME_SCHEMA = z.union([
         status: z.literal("succeeded"),
     }),
 ]);
+const ACTION_VALUE_TRANSPORT_OUTCOME_SCHEMA = z.union([
+    ACTION_VALUE_OUTCOME_BASE_SCHEMA.extend({
+        outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
+        status: z.literal("failed"),
+        failure: automationErrorSchema,
+    }),
+    ACTION_VALUE_OUTCOME_BASE_SCHEMA.extend({
+        reason: z.literal("closed-dependency"),
+        status: z.literal("skipped"),
+    }),
+    ACTION_VALUE_OUTCOME_BASE_SCHEMA.extend({
+        failure: automationErrorSchema,
+        reason: z.literal("failed-dependency"),
+        status: z.literal("skipped"),
+    }),
+    ACTION_VALUE_OUTCOME_BASE_SCHEMA.extend({
+        output: codecEnvelopeSchema,
+        outputSensitivity: sensitivityMaskSchema.nullable().optional(),
+        status: z.literal("succeeded"),
+    }),
+]);
 const SIGNAL_VALUE_OUTCOME_BASE_SCHEMA = z.object({
     contextId: z.string(),
     outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
@@ -456,6 +475,19 @@ const SIGNAL_VALUE_OUTCOME_SCHEMA = z.union([
         status: z.literal("succeeded"),
     }),
 ]);
+const SIGNAL_VALUE_TRANSPORT_OUTCOME_SCHEMA = z.union([
+    SIGNAL_VALUE_OUTCOME_BASE_SCHEMA.extend({ status: z.literal("open") }),
+    SIGNAL_VALUE_OUTCOME_BASE_SCHEMA.extend({ status: z.literal("closed") }),
+    SIGNAL_VALUE_OUTCOME_BASE_SCHEMA.extend({
+        failure: automationErrorSchema,
+        status: z.literal("failed"),
+    }),
+    SIGNAL_VALUE_OUTCOME_BASE_SCHEMA.extend({
+        output: codecEnvelopeSchema.optional(),
+        selectedIndex: z.number().int().nonnegative().optional(),
+        status: z.literal("succeeded"),
+    }),
+]);
 const RUNTIME_VALUE_CONTEXT_SCHEMA = z.object({
     actionOutputs: ACTION_VALUE_OUTCOME_SCHEMA.array(),
     coordinationSelections: COORDINATION_SELECTION_SCHEMA.array(),
@@ -474,6 +506,24 @@ const RUNTIME_VALUE_CONTEXT_SCHEMA = z.object({
         .array(),
     signalOutputs: SIGNAL_VALUE_OUTCOME_SCHEMA.array(),
 });
+const RUNTIME_VALUE_TRANSPORT_CONTEXT_SCHEMA = z.object({
+    actionOutputs: ACTION_VALUE_TRANSPORT_OUTCOME_SCHEMA.array(),
+    coordinationSelections: COORDINATION_SELECTION_SCHEMA.array(),
+    contextId: z.string(),
+    contextParents: RUNTIME_CONTEXT_PARENT_SCHEMA.array(),
+    events: z
+        .object({
+        automationEventId: z.string(),
+        contextId: z.string(),
+        outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
+        payload: codecEnvelopeSchema,
+        scopePath: HOOK_SCOPE_PATH_SCHEMA,
+        slot: z.number().int(),
+        timestamp: z.date(),
+    })
+        .array(),
+    signalOutputs: SIGNAL_VALUE_TRANSPORT_OUTCOME_SCHEMA.array(),
+});
 const RUNTIME_RUN_CONTEXT_SCHEMA = z.object({
     actions: ACTION_RUN_INVOCATION_SCHEMA.array(),
     contextId: z.string(),
@@ -504,6 +554,21 @@ const TARGET_ACTION_SCHEMA = z.union([
         status: z.enum(["failed", "skipped", "succeeded"]),
     }),
 ]);
+const TARGET_ACTION_TRANSPORT_SCHEMA = z.union([
+    z.object({
+        context: RUNTIME_VALUE_TRANSPORT_CONTEXT_SCHEMA,
+        id: z.string(),
+        scopePath: HOOK_SCOPE_PATH_SCHEMA,
+        slot: z.number().int(),
+        status: z.literal("pending"),
+    }),
+    z.object({
+        id: z.string(),
+        scopePath: HOOK_SCOPE_PATH_SCHEMA,
+        slot: z.number().int(),
+        status: z.enum(["failed", "skipped", "succeeded"]),
+    }),
+]);
 const AI_WARNING_SCHEMA = z.discriminatedUnion("type", [
     z.object({
         details: z.string().optional(),
@@ -604,6 +669,15 @@ export const generationResultSchema = z.object({
     usage: GENERATION_USAGE_SCHEMA,
     warnings: AI_WARNING_SCHEMA.array().optional(),
 });
+const RUNTIME_GENERATION_RESULT_SCHEMA = generationResultSchema
+    .omit({ output: true, providerMetadata: true, usage: true })
+    .extend({
+    output: codecEnvelopeSchema,
+    providerMetadata: codecEnvelopeSchema,
+    usage: GENERATION_USAGE_SCHEMA.omit({ raw: true }).extend({
+        raw: codecEnvelopeSchema,
+    }),
+});
 const RUNTIME_GENERATION_OUTPUT_SCHEMA = z
     .object({
     description: z.string().optional(),
@@ -697,6 +771,37 @@ export const platformImageGenerationInputSchema = imageGenerationInputSchema.ext
 export const platformImageGenerationStartSchema = z.object({
     key: z.string().min(1),
 });
+const PLATFORM_IMAGE_GENERATION_TRANSPORT_INPUT_SCHEMA = platformImageGenerationInputSchema.omit({ prompt: true }).extend({
+    prompt: codecEnvelopeSchema,
+});
+const ACTION_COMPLETION_SCHEMA = z.union([
+    z.object({
+        reason: z.literal("closed-dependency"),
+        status: z.literal("skipped"),
+    }),
+    z.object({
+        failure: automationErrorSchema,
+        reason: z.literal("failed-dependency"),
+        status: z.literal("skipped"),
+    }),
+    z.object({
+        failure: automationErrorSchema,
+        status: z.literal("failed"),
+    }),
+    z.object({
+        output: encodableSchema,
+        status: z.literal("succeeded"),
+    }),
+]);
+const ACTION_COMPLETION_TRANSPORT_SCHEMA = z.union([
+    ACTION_COMPLETION_SCHEMA.options[0],
+    ACTION_COMPLETION_SCHEMA.options[1],
+    ACTION_COMPLETION_SCHEMA.options[2],
+    z.object({
+        output: codecEnvelopeSchema,
+        status: z.literal("succeeded"),
+    }),
+]);
 /**
  * Hashes one coordinator definition exactly as the runtime stores it.
  *
@@ -724,32 +829,12 @@ export const runtimeContract = {
     commit: oc
         .input(z.object({
         actionInvocations: ACTION_INVOCATION_SCHEMA.array(),
-        coordinationOffers: COORDINATION_OFFER_SCHEMA.array(),
+        coordinationOffers: COORDINATION_OFFER_TRANSPORT_SCHEMA.array(),
         settled: z.boolean(),
         signalInvocations: SIGNAL_INVOCATION_SCHEMA.array(),
     }))
         .output(z.void()),
-    completeAction: oc
-        .input(z.union([
-        z.object({
-            reason: z.literal("closed-dependency"),
-            status: z.literal("skipped"),
-        }),
-        z.object({
-            failure: automationErrorSchema,
-            reason: z.literal("failed-dependency"),
-            status: z.literal("skipped"),
-        }),
-        z.object({
-            failure: automationErrorSchema,
-            status: z.literal("failed"),
-        }),
-        z.object({
-            output: encodableSchema,
-            status: z.literal("succeeded"),
-        }),
-    ]))
-        .output(z.void()),
+    completeAction: oc.input(ACTION_COMPLETION_TRANSPORT_SCHEMA).output(z.void()),
     completeTraceSpan: oc
         .input(z
         .object({
@@ -766,27 +851,27 @@ export const runtimeContract = {
         .output(z.void()),
     generate: oc
         .input(RUNTIME_GENERATION_INPUT_SCHEMA)
-        .output(generationResultSchema),
+        .output(RUNTIME_GENERATION_RESULT_SCHEMA),
     startImageGeneration: oc
-        .input(platformImageGenerationInputSchema)
+        .input(PLATFORM_IMAGE_GENERATION_TRANSPORT_INPUT_SCHEMA)
         .output(platformImageGenerationStartSchema),
     createCallbackToken: oc
         .input(z.object({ endpointKey: z.string().min(1) }))
         .output(z.string()),
     invokeAutomation: oc
-        .input(automationInvocationInputSchema)
+        .input(AUTOMATION_INVOCATION_TRANSPORT_INPUT_SCHEMA)
         .output(automationInvocationOutputSchema),
     load: oc.output(z.object({
         context: RUNTIME_RUN_CONTEXT_SCHEMA,
         finalAttempt: z.boolean(),
-        targetAction: TARGET_ACTION_SCHEMA.optional(),
+        targetAction: TARGET_ACTION_TRANSPORT_SCHEMA.optional(),
     })),
     loadValues: oc
         .input(SIGNAL_DEPENDENCIES_SCHEMA.omit({
         scopePath: true,
         slot: true,
     }))
-        .output(RUNTIME_VALUE_CONTEXT_SCHEMA),
+        .output(RUNTIME_VALUE_TRANSPORT_CONTEXT_SCHEMA),
     resolveAccountInput: oc
         .input(z.strictObject({
         binding: z.string().min(1),
@@ -800,7 +885,7 @@ export const runtimeContract = {
     sendOutput: oc
         .input(z.object({
         output: z.object({
-            data: encodableSchema,
+            data: codecEnvelopeSchema,
             type: z.string().min(1),
         }),
         outputIndex: z.number().int().nonnegative(),
@@ -809,7 +894,7 @@ export const runtimeContract = {
         .output(z.void()),
     sendLog: oc
         .input(z.object({
-        fields: OBSERVABILITY_FIELDS_SCHEMA.optional(),
+        fields: codecEnvelopeSchema.optional(),
         level: z.enum(["debug", "info", "warn", "error"]),
         logIndex: LOG_INDEX_SCHEMA,
         message: z.string().min(1).max(AUTOMATION_LOG_MAX_MESSAGE_LENGTH),
@@ -820,7 +905,7 @@ export const runtimeContract = {
         .output(z.void()),
     startTraceSpan: oc
         .input(z.object({
-        attributes: OBSERVABILITY_FIELDS_SCHEMA.optional(),
+        attributes: codecEnvelopeSchema.optional(),
         name: z.string().min(1).max(AUTOMATION_TRACE_MAX_NAME_LENGTH),
         sensitivity: sensitivityMaskSchema.optional(),
         parentSpanIndex: TRACE_SPAN_INDEX_SCHEMA.optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automate.ax/api-contract",
-  "version": "0.87.0",
+  "version": "0.87.2",
   "description": "Public oRPC contract for the Automate.ax API.",
   "license": "MIT",
   "repository": {
@@ -31,8 +31,8 @@
   },
   "dependencies": {
     "@ai-sdk/gateway": "4.0.46",
-    "@automate.ax/codec": "0.87.0",
-    "@automate.ax/integration-contracts": "0.87.0",
+    "@automate.ax/codec": "0.87.2",
+    "@automate.ax/integration-contracts": "0.87.2",
     "@orpc/contract": "1.15.0",
     "fast-json-stable-stringify": "^2.1.0",
     "zod": "^4.3.6"

package/src/automation.ts

@@ -1,4 +1,4 @@
-import { encodableSchema } from "@automate.ax/codec"
+import { codecEnvelopeSchema } from "@automate.ax/codec/rpc"
 import { sensitivityMaskSchema } from "./runtime"
 import { oc } from "@orpc/contract"
 import * as z from "zod"
@@ -95,7 +95,7 @@ export const automationContract = {
             hasOutput: z.boolean(),
             id: z.string(),
             name: z.string(),
-            output: encodableSchema,
+            output: codecEnvelopeSchema.optional(),
             outputSensitivity: sensitivityMaskSchema.nullable().optional(),
             slot: z.number().int().nonnegative(),
             status: z.enum(["pending", "succeeded", "skipped", "failed"]),
@@ -105,7 +105,7 @@ export const automationContract = {
           .object({
             createdAt: z.date(),
             id: z.string(),
-            payload: encodableSchema,
+            payload: codecEnvelopeSchema,
             type: z.string(),
           })
           .array(),
@@ -113,7 +113,7 @@ export const automationContract = {
           .object({
             actionInvocationId: z.string(),
             createdAt: z.date(),
-            data: encodableSchema,
+            data: codecEnvelopeSchema,
             id: z.string(),
             sensitivity: sensitivityMaskSchema.nullable().optional(),
             outputIndex: z.number().int().nonnegative(),

package/src/runtime-protocol.ts

@@ -1,2 +1,2 @@
 /** Runtime protocol required by newly built automation bundles. */
-export const AUTOMATION_RUNTIME_PROTOCOL_VERSION = 1
+export const AUTOMATION_RUNTIME_PROTOCOL_VERSION = 2