@automate.ax/api-contract 0.87.0 → 0.87.2

package/src/runtime.ts

@@ -3,6 +3,7 @@ import {
   isSensitivityMask,
   type SensitivityMask,
 } from "@automate.ax/codec"
+import { codecEnvelopeSchema } from "@automate.ax/codec/rpc"
 import type { GatewayImageModelId, GatewayModelId } from "@ai-sdk/gateway"
 import { oc } from "@orpc/contract"
 import stableStringify from "fast-json-stable-stringify"
@@ -30,34 +31,12 @@ 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<Blob>()
-
-/** Preserves Blob media types while oRPC carries the bytes as multipart data. */
-export const runtimeBlobJsonSerializer = {
-  type: RUNTIME_BLOB_JSON_SERIALIZER_TYPE,
-  condition: (value: unknown) =>
-    value instanceof Blob && !runtimeBlobTransportValues.has(value),
-  serialize(value: Blob) {
-    const transportValue = new Blob([value])
-    runtimeBlobTransportValues.add(transportValue)
-    return { transportValue, type: value.type }
-  },
-  deserialize(value: unknown) {
-    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) =>
@@ -129,27 +108,34 @@ export const automationInvocationOutputSchema = z.object({
   runAt: z.date(),
 })
 
-export const automationInvocationInputSchema = z
-  .object({
-    entrypoint: z
-      .string()
-      .min(1)
-      .default(AUTOMATION_INVOCATION_DEFAULT_ENTRYPOINT),
-    payload: encodableSchema,
+const AUTOMATION_INVOCATION_BASE_SCHEMA = z.object({
+  entrypoint: z
+    .string()
+    .min(1)
+    .default(AUTOMATION_INVOCATION_DEFAULT_ENTRYPOINT),
+})
+const AUTOMATION_INVOCATION_TARGET_SCHEMA = z.union([
+  z.object({
+    automationId: z.string().min(1),
+    automationName: z.never().optional(),
+  }),
+  z.object({
+    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(
-    z.union([
-      z.object({
-        automationId: z.string().min(1),
-        automationName: z.never().optional(),
-      }),
-      z.object({
-        automationId: z.never().optional(),
-        automationName: z.string().min(1),
-      }),
-    ]),
-  )
-  .and(automationInvocationScheduleSchema)
+    .and(AUTOMATION_INVOCATION_TARGET_SCHEMA)
+    .and(automationInvocationScheduleSchema)
 
 const SIGNAL_DERIVATION_NODE_SCHEMA = z.discriminatedUnion("type", [
   z.object({
@@ -283,33 +269,39 @@ const CORRELATION_STREAM_ORIGINS_SCHEMA = z
   .array()
   .min(2)
 
-const CORRELATION_OFFER_SCHEMA = SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
-  key: encodableSchema,
-  ordered: z.boolean(),
-  outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
-  policy: z.literal("correlate"),
-  streamIndex: z.number().int().nonnegative(),
-  streamOrigins: CORRELATION_STREAM_ORIGINS_SCHEMA,
-  ttl: z.union([z.string().min(1), z.number().nonnegative()]).optional(),
-}).superRefine((entry, context) => {
-  if (entry.streamIndex >= entry.streamOrigins.length) {
-    context.addIssue({
-      code: "custom",
-      message: "Correlation stream index must identify an input stream.",
-      path: ["streamIndex"],
-    })
-  }
-})
+const createCorrelationOfferSchema = <TKeySchema extends z.ZodType>(
+  keySchema: TKeySchema,
+) =>
+  SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
+    key: keySchema,
+    ordered: z.boolean(),
+    outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
+    policy: z.literal("correlate"),
+    streamIndex: z.number().int().nonnegative(),
+    streamOrigins: CORRELATION_STREAM_ORIGINS_SCHEMA,
+    ttl: z.union([z.string().min(1), z.number().nonnegative()]).optional(),
+  }).superRefine((entry, context) => {
+    if (entry.streamIndex >= entry.streamOrigins.length) {
+      context.addIssue({
+        code: "custom",
+        message: "Correlation stream index must identify an input stream.",
+        path: ["streamIndex"],
+      })
+    }
+  })
 
-const COLLECTION_OFFER_SCHEMA = SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
-  count: z.number().int().positive(),
-  key: encodableSchema,
-  outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
-  policy: z.literal("collect"),
-  position: z.number().int().nonnegative().optional(),
-  primaryPosition: COORDINATION_PRIMARY_POSITION_SCHEMA,
-  ttl: z.union([z.string().min(1), z.number().nonnegative()]).optional(),
-})
+const createCollectionOfferSchema = <TKeySchema extends z.ZodType>(
+  keySchema: TKeySchema,
+) =>
+  SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
+    count: z.number().int().positive(),
+    key: keySchema,
+    outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
+    policy: z.literal("collect"),
+    position: z.number().int().nonnegative().optional(),
+    primaryPosition: COORDINATION_PRIMARY_POSITION_SCHEMA,
+    ttl: z.union([z.string().min(1), z.number().nonnegative()]).optional(),
+  })
 
 const FANOUT_OFFER_SCHEMA = SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
   count: z.number().int().nonnegative(),
@@ -317,67 +309,77 @@ const FANOUT_OFFER_SCHEMA = SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
   policy: z.literal("fanout"),
 })
 
-const FUNNEL_OFFER_SCHEMA = SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
-  key: encodableSchema,
-  maxBurstDuration: COORDINATION_DURATION_SCHEMA.optional(),
-  minGap: COORDINATION_DURATION_SCHEMA.optional(),
-  minQuietPeriod: COORDINATION_DURATION_SCHEMA.optional(),
-  outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
-  policy: z.literal("funnel"),
-  primaryPosition: COORDINATION_PRIMARY_POSITION_SCHEMA,
-  selection: z.enum(["all", "first", "last"]),
-  triggerAt: z.enum(["start", "end", "both"]),
-  ttl: COORDINATION_DURATION_SCHEMA.optional(),
-  until: z.date().optional(),
-}).superRefine((offer, context) => {
-  if (
-    offer.maxBurstDuration === undefined &&
-    offer.minGap === undefined &&
-    offer.minQuietPeriod === undefined &&
-    offer.until === undefined
-  ) {
-    context.addIssue({
-      code: "custom",
-      message: "A funnel requires at least one timing control.",
-    })
-  }
-  if (
-    offer.triggerAt === "end" &&
-    offer.minGap !== undefined &&
-    offer.minQuietPeriod === undefined &&
-    offer.maxBurstDuration === undefined &&
-    offer.until === undefined
-  ) {
-    context.addIssue({
-      code: "custom",
-      message:
-        "A trailing funnel with minGap also requires minQuietPeriod, maxBurstDuration, or until.",
-      path: ["minGap"],
-    })
-  }
-  if (offer.maxBurstDuration !== undefined && offer.until !== undefined) {
-    context.addIssue({
-      code: "custom",
-      message: "A funnel cannot use maxBurstDuration and until together.",
-      path: ["until"],
-    })
-  }
-  if (offer.selection !== "all" && offer.selection !== offer.primaryPosition) {
-    context.addIssue({
-      code: "custom",
-      message:
-        "A selecting funnel must inherit conflicting values from its selected occurrence.",
-      path: ["primaryPosition"],
-    })
-  }
-  if (offer.triggerAt === "start" && offer.selection !== "first") {
-    context.addIssue({
-      code: "custom",
-      message: "A start-only funnel can only select its first occurrence.",
-      path: ["selection"],
-    })
-  }
-})
+const createFunnelOfferSchema = <TKeySchema extends z.ZodType>(
+  keySchema: TKeySchema,
+) =>
+  SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
+    key: keySchema,
+    maxBurstDuration: COORDINATION_DURATION_SCHEMA.optional(),
+    minGap: COORDINATION_DURATION_SCHEMA.optional(),
+    minQuietPeriod: COORDINATION_DURATION_SCHEMA.optional(),
+    outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
+    policy: z.literal("funnel"),
+    primaryPosition: COORDINATION_PRIMARY_POSITION_SCHEMA,
+    selection: z.enum(["all", "first", "last"]),
+    triggerAt: z.enum(["start", "end", "both"]),
+    ttl: COORDINATION_DURATION_SCHEMA.optional(),
+    until: z.date().optional(),
+  }).superRefine((offer, context) => {
+    if (
+      offer.maxBurstDuration === undefined &&
+      offer.minGap === undefined &&
+      offer.minQuietPeriod === undefined &&
+      offer.until === undefined
+    ) {
+      context.addIssue({
+        code: "custom",
+        message: "A funnel requires at least one timing control.",
+      })
+    }
+    if (
+      offer.triggerAt === "end" &&
+      offer.minGap !== undefined &&
+      offer.minQuietPeriod === undefined &&
+      offer.maxBurstDuration === undefined &&
+      offer.until === undefined
+    ) {
+      context.addIssue({
+        code: "custom",
+        message:
+          "A trailing funnel with minGap also requires minQuietPeriod, maxBurstDuration, or until.",
+        path: ["minGap"],
+      })
+    }
+    if (offer.maxBurstDuration !== undefined && offer.until !== undefined) {
+      context.addIssue({
+        code: "custom",
+        message: "A funnel cannot use maxBurstDuration and until together.",
+        path: ["until"],
+      })
+    }
+    if (
+      offer.selection !== "all" &&
+      offer.selection !== offer.primaryPosition
+    ) {
+      context.addIssue({
+        code: "custom",
+        message:
+          "A selecting funnel must inherit conflicting values from its selected occurrence.",
+        path: ["primaryPosition"],
+      })
+    }
+    if (offer.triggerAt === "start" && offer.selection !== "first") {
+      context.addIssue({
+        code: "custom",
+        message: "A start-only funnel can only select its first occurrence.",
+        path: ["selection"],
+      })
+    }
+  })
+
+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(),
@@ -413,6 +415,14 @@ const COORDINATION_OFFER_SCHEMA = z.union([
   RACE_OFFER_SCHEMA,
 ])
 
+const COORDINATION_OFFER_TRANSPORT_SCHEMA = z.union([
+  createCollectionOfferSchema(codecEnvelopeSchema),
+  createCorrelationOfferSchema(codecEnvelopeSchema),
+  FANOUT_OFFER_SCHEMA,
+  createFunnelOfferSchema(codecEnvelopeSchema),
+  RACE_OFFER_SCHEMA,
+])
+
 /** One validated durable coordination offer sent by the automation runtime. */
 export type RuntimeCoordinationOffer = z.output<
   typeof COORDINATION_OFFER_SCHEMA
@@ -490,6 +500,28 @@ const ACTION_VALUE_OUTCOME_SCHEMA = z.union([
   }),
 ])
 
+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,
@@ -530,6 +562,20 @@ const SIGNAL_VALUE_OUTCOME_SCHEMA = z.union([
   }),
 ])
 
+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(),
@@ -549,6 +595,28 @@ const RUNTIME_VALUE_CONTEXT_SCHEMA = z.object({
   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(),
+})
+
+/** Durable values resolved by one runtime traversal. */
+export type RuntimeValueContext = z.output<typeof RUNTIME_VALUE_CONTEXT_SCHEMA>
+
 const RUNTIME_RUN_CONTEXT_SCHEMA = z.object({
   actions: ACTION_RUN_INVOCATION_SCHEMA.array(),
   contextId: z.string(),
@@ -565,6 +633,9 @@ const RUNTIME_RUN_CONTEXT_SCHEMA = z.object({
   signalOutputs: SIGNAL_BATCH_OUTCOME_SCHEMA.array(),
 })
 
+/** Durable frontier and declarations loaded for one runtime traversal. */
+export type RuntimeRunContext = z.output<typeof RUNTIME_RUN_CONTEXT_SCHEMA>
+
 const TARGET_ACTION_SCHEMA = z.union([
   z.object({
     context: RUNTIME_VALUE_CONTEXT_SCHEMA,
@@ -581,6 +652,25 @@ const TARGET_ACTION_SCHEMA = z.union([
   }),
 ])
 
+/** Optional action targeted by one runtime execution. */
+export type RuntimeTargetAction = z.output<typeof TARGET_ACTION_SCHEMA>
+
+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(),
@@ -692,6 +782,16 @@ export const generationResultSchema = z.object({
   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,
+    }),
+  })
+
 export type GenerationInput = z.output<typeof generationInputSchema>
 export type GenerationResult = z.output<typeof generationResultSchema>
 
@@ -816,6 +916,44 @@ export type PlatformImageGenerationInput = z.output<
   typeof platformImageGenerationInputSchema
 >
 
+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"),
+  }),
+])
+
+/** Terminal action result produced inside an automation runtime. */
+export type RuntimeActionCompletion = z.output<typeof ACTION_COMPLETION_SCHEMA>
+
+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.
  *
@@ -857,35 +995,13 @@ export const runtimeContract = {
     .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
@@ -906,21 +1022,21 @@ 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
@@ -930,7 +1046,7 @@ export const runtimeContract = {
         slot: true,
       }),
     )
-    .output(RUNTIME_VALUE_CONTEXT_SCHEMA),
+    .output(RUNTIME_VALUE_TRANSPORT_CONTEXT_SCHEMA),
   resolveAccountInput: oc
     .input(
       z.strictObject({
@@ -949,7 +1065,7 @@ export const runtimeContract = {
     .input(
       z.object({
         output: z.object({
-          data: encodableSchema,
+          data: codecEnvelopeSchema,
           type: z.string().min(1),
         }),
         outputIndex: z.number().int().nonnegative(),
@@ -960,7 +1076,7 @@ export const runtimeContract = {
   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),
@@ -973,7 +1089,7 @@ export const runtimeContract = {
   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(),