@automate.ax/api-contract 0.137.0 → 0.139.0

package/dist/runtime-protocol.d.ts

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

package/dist/runtime-protocol.js

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

package/dist/runtime.d.ts

@@ -142,6 +142,16 @@ declare const COORDINATION_OFFER_SCHEMA: z.ZodUnion<readonly [z.ZodObject<{
         roots: z.ZodArray<z.ZodNumber>;
     }, z.core.$strip>>;
     key: z.ZodOptional<z.ZodCustom<import("@automate.ax/codec").Encodable, import("@automate.ax/codec").Encodable>>;
+    inputPolicies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        consumption: z.ZodEnum<{
+            consume: "consume";
+            retain: "retain";
+        }>;
+        selection: z.ZodEnum<{
+            oldest: "oldest";
+            latest: "latest";
+        }>;
+    }, z.core.$strip>>>;
     occurrenceTtl: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
     ordered: z.ZodBoolean;
     outcomeSeq: z.ZodNumber;
@@ -149,6 +159,38 @@ declare const COORDINATION_OFFER_SCHEMA: z.ZodUnion<readonly [z.ZodObject<{
     streamIndex: z.ZodNumber;
     streamOrigins: z.ZodArray<z.ZodArray<z.ZodString>>;
     ttl: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+}, z.core.$strip>, z.ZodObject<{
+    actionDependencyIds: z.ZodArray<z.ZodString>;
+    eventDependencyIds: z.ZodArray<z.ZodString>;
+    scopePath: z.ZodArray<z.ZodNumber>;
+    signalDependencyIds: z.ZodArray<z.ZodString>;
+    slot: z.ZodNumber;
+    derivation: z.ZodNullable<z.ZodObject<{
+        nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            id: z.ZodString;
+            source: z.ZodEnum<{
+                action: "action";
+                event: "event";
+                signal: "signal";
+            }>;
+            type: z.ZodLiteral<"source">;
+        }, z.core.$strip>, z.ZodObject<{
+            inputs: z.ZodArray<z.ZodNumber>;
+            property: z.ZodString;
+            type: z.ZodLiteral<"property">;
+        }, z.core.$strip>, z.ZodObject<{
+            inputs: z.ZodArray<z.ZodNumber>;
+            type: z.ZodLiteral<"transform">;
+        }, z.core.$strip>], "type">>;
+        roots: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>>;
+    key: z.ZodOptional<z.ZodCustom<import("@automate.ax/codec").Encodable, import("@automate.ax/codec").Encodable>>;
+    limit: z.ZodNumber;
+    outcomeSeq: z.ZodNumber;
+    policy: z.ZodLiteral<"concurrent">;
+    releaseScopePath: z.ZodArray<z.ZodNumber>;
+    releaseSlot: z.ZodNumber;
+    sourceOrigins: z.ZodArray<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     actionDependencyIds: z.ZodArray<z.ZodString>;
     eventDependencyIds: z.ZodArray<z.ZodString>;
@@ -253,6 +295,40 @@ declare const COORDINATION_OFFER_SCHEMA: z.ZodUnion<readonly [z.ZodObject<{
     outcomeSeq: z.ZodNumber;
     policy: z.ZodLiteral<"merge">;
     selectedIndex: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    actionDependencyIds: z.ZodArray<z.ZodString>;
+    eventDependencyIds: z.ZodArray<z.ZodString>;
+    scopePath: z.ZodArray<z.ZodNumber>;
+    signalDependencyIds: z.ZodArray<z.ZodString>;
+    slot: z.ZodNumber;
+    derivation: z.ZodNullable<z.ZodObject<{
+        nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            id: z.ZodString;
+            source: z.ZodEnum<{
+                action: "action";
+                event: "event";
+                signal: "signal";
+            }>;
+            type: z.ZodLiteral<"source">;
+        }, z.core.$strip>, z.ZodObject<{
+            inputs: z.ZodArray<z.ZodNumber>;
+            property: z.ZodString;
+            type: z.ZodLiteral<"property">;
+        }, z.core.$strip>, z.ZodObject<{
+            inputs: z.ZodArray<z.ZodNumber>;
+            type: z.ZodLiteral<"transform">;
+        }, z.core.$strip>], "type">>;
+        roots: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>>;
+    interval: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    key: z.ZodOptional<z.ZodCustom<import("@automate.ax/codec").Encodable, import("@automate.ax/codec").Encodable>>;
+    limit: z.ZodNumber;
+    outcomeSeq: z.ZodNumber;
+    overflow: z.ZodEnum<{
+        drop: "drop";
+        wait: "wait";
+    }>;
+    policy: z.ZodLiteral<"rateLimit">;
 }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
     actionDependencyIds: z.ZodArray<z.ZodString>;
     eventDependencyIds: z.ZodArray<z.ZodString>;
@@ -390,6 +466,36 @@ declare const COORDINATION_OFFER_SCHEMA: z.ZodUnion<readonly [z.ZodObject<{
     releaseScopePath: z.ZodArray<z.ZodNumber>;
     releaseSlot: z.ZodNumber;
     sourceOrigins: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    actionDependencyIds: z.ZodArray<z.ZodString>;
+    eventDependencyIds: z.ZodArray<z.ZodString>;
+    scopePath: z.ZodArray<z.ZodNumber>;
+    signalDependencyIds: z.ZodArray<z.ZodString>;
+    slot: z.ZodNumber;
+    derivation: z.ZodNullable<z.ZodObject<{
+        nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            id: z.ZodString;
+            source: z.ZodEnum<{
+                action: "action";
+                event: "event";
+                signal: "signal";
+            }>;
+            type: z.ZodLiteral<"source">;
+        }, z.core.$strip>, z.ZodObject<{
+            inputs: z.ZodArray<z.ZodNumber>;
+            property: z.ZodString;
+            type: z.ZodLiteral<"property">;
+        }, z.core.$strip>, z.ZodObject<{
+            inputs: z.ZodArray<z.ZodNumber>;
+            type: z.ZodLiteral<"transform">;
+        }, z.core.$strip>], "type">>;
+        roots: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>>;
+    count: z.ZodNumber;
+    key: z.ZodOptional<z.ZodCustom<import("@automate.ax/codec").Encodable, import("@automate.ax/codec").Encodable>>;
+    outcomeSeq: z.ZodNumber;
+    policy: z.ZodLiteral<"take">;
+    ttl: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
 }, z.core.$strip>]>;
 /** One validated durable coordination offer sent by the automation runtime. */
 export type RuntimeCoordinationOffer = z.output<typeof COORDINATION_OFFER_SCHEMA>;
@@ -1440,6 +1546,16 @@ export declare const runtimeContract: {
                 roots: z.ZodArray<z.ZodNumber>;
             }, z.core.$strip>>;
             key: z.ZodCustom<import("@automate.ax/codec/rpc").CodecEnvelope, import("@automate.ax/codec/rpc").CodecEnvelope>;
+            inputPolicies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                consumption: z.ZodEnum<{
+                    consume: "consume";
+                    retain: "retain";
+                }>;
+                selection: z.ZodEnum<{
+                    oldest: "oldest";
+                    latest: "latest";
+                }>;
+            }, z.core.$strip>>>;
             occurrenceTtl: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
             ordered: z.ZodBoolean;
             outcomeSeq: z.ZodNumber;
@@ -1447,6 +1563,38 @@ export declare const runtimeContract: {
             streamIndex: z.ZodNumber;
             streamOrigins: z.ZodArray<z.ZodArray<z.ZodString>>;
             ttl: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        }, z.core.$strip>, z.ZodObject<{
+            actionDependencyIds: z.ZodArray<z.ZodString>;
+            eventDependencyIds: z.ZodArray<z.ZodString>;
+            scopePath: z.ZodArray<z.ZodNumber>;
+            signalDependencyIds: z.ZodArray<z.ZodString>;
+            slot: z.ZodNumber;
+            derivation: z.ZodNullable<z.ZodObject<{
+                nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    id: z.ZodString;
+                    source: z.ZodEnum<{
+                        action: "action";
+                        event: "event";
+                        signal: "signal";
+                    }>;
+                    type: z.ZodLiteral<"source">;
+                }, z.core.$strip>, z.ZodObject<{
+                    inputs: z.ZodArray<z.ZodNumber>;
+                    property: z.ZodString;
+                    type: z.ZodLiteral<"property">;
+                }, z.core.$strip>, z.ZodObject<{
+                    inputs: z.ZodArray<z.ZodNumber>;
+                    type: z.ZodLiteral<"transform">;
+                }, z.core.$strip>], "type">>;
+                roots: z.ZodArray<z.ZodNumber>;
+            }, z.core.$strip>>;
+            key: z.ZodCustom<import("@automate.ax/codec/rpc").CodecEnvelope, import("@automate.ax/codec/rpc").CodecEnvelope>;
+            limit: z.ZodNumber;
+            outcomeSeq: z.ZodNumber;
+            policy: z.ZodLiteral<"concurrent">;
+            releaseScopePath: z.ZodArray<z.ZodNumber>;
+            releaseSlot: z.ZodNumber;
+            sourceOrigins: z.ZodArray<z.ZodString>;
         }, z.core.$strip>, z.ZodObject<{
             actionDependencyIds: z.ZodArray<z.ZodString>;
             eventDependencyIds: z.ZodArray<z.ZodString>;
@@ -1551,6 +1699,40 @@ export declare const runtimeContract: {
             outcomeSeq: z.ZodNumber;
             policy: z.ZodLiteral<"merge">;
             selectedIndex: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            actionDependencyIds: z.ZodArray<z.ZodString>;
+            eventDependencyIds: z.ZodArray<z.ZodString>;
+            scopePath: z.ZodArray<z.ZodNumber>;
+            signalDependencyIds: z.ZodArray<z.ZodString>;
+            slot: z.ZodNumber;
+            derivation: z.ZodNullable<z.ZodObject<{
+                nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    id: z.ZodString;
+                    source: z.ZodEnum<{
+                        action: "action";
+                        event: "event";
+                        signal: "signal";
+                    }>;
+                    type: z.ZodLiteral<"source">;
+                }, z.core.$strip>, z.ZodObject<{
+                    inputs: z.ZodArray<z.ZodNumber>;
+                    property: z.ZodString;
+                    type: z.ZodLiteral<"property">;
+                }, z.core.$strip>, z.ZodObject<{
+                    inputs: z.ZodArray<z.ZodNumber>;
+                    type: z.ZodLiteral<"transform">;
+                }, z.core.$strip>], "type">>;
+                roots: z.ZodArray<z.ZodNumber>;
+            }, z.core.$strip>>;
+            interval: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+            key: z.ZodCustom<import("@automate.ax/codec/rpc").CodecEnvelope, import("@automate.ax/codec/rpc").CodecEnvelope>;
+            limit: z.ZodNumber;
+            outcomeSeq: z.ZodNumber;
+            overflow: z.ZodEnum<{
+                drop: "drop";
+                wait: "wait";
+            }>;
+            policy: z.ZodLiteral<"rateLimit">;
         }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
             actionDependencyIds: z.ZodArray<z.ZodString>;
             eventDependencyIds: z.ZodArray<z.ZodString>;
@@ -1688,6 +1870,36 @@ export declare const runtimeContract: {
             releaseScopePath: z.ZodArray<z.ZodNumber>;
             releaseSlot: z.ZodNumber;
             sourceOrigins: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            actionDependencyIds: z.ZodArray<z.ZodString>;
+            eventDependencyIds: z.ZodArray<z.ZodString>;
+            scopePath: z.ZodArray<z.ZodNumber>;
+            signalDependencyIds: z.ZodArray<z.ZodString>;
+            slot: z.ZodNumber;
+            derivation: z.ZodNullable<z.ZodObject<{
+                nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    id: z.ZodString;
+                    source: z.ZodEnum<{
+                        action: "action";
+                        event: "event";
+                        signal: "signal";
+                    }>;
+                    type: z.ZodLiteral<"source">;
+                }, z.core.$strip>, z.ZodObject<{
+                    inputs: z.ZodArray<z.ZodNumber>;
+                    property: z.ZodString;
+                    type: z.ZodLiteral<"property">;
+                }, z.core.$strip>, z.ZodObject<{
+                    inputs: z.ZodArray<z.ZodNumber>;
+                    type: z.ZodLiteral<"transform">;
+                }, z.core.$strip>], "type">>;
+                roots: z.ZodArray<z.ZodNumber>;
+            }, z.core.$strip>>;
+            count: z.ZodNumber;
+            key: z.ZodCustom<import("@automate.ax/codec/rpc").CodecEnvelope, import("@automate.ax/codec/rpc").CodecEnvelope>;
+            outcomeSeq: z.ZodNumber;
+            policy: z.ZodLiteral<"take">;
+            ttl: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
         }, z.core.$strip>]>>;
         observedFrontier: z.ZodOptional<z.ZodObject<{
             boundaryCount: z.ZodNumber;

package/dist/runtime.js

@@ -222,6 +222,10 @@ const CORRELATION_STREAM_ORIGINS_SCHEMA = z
     .min(1)
     .array()
     .min(2);
+const CORRELATION_INPUT_POLICY_SCHEMA = z.object({
+    consumption: z.enum(["consume", "retain"]),
+    selection: z.enum(["oldest", "latest"]),
+});
 const MERGE_INPUT_ORIGINS_SCHEMA = z
     .string()
     .min(1)
@@ -231,6 +235,7 @@ const MERGE_INPUT_ORIGINS_SCHEMA = z
     .min(2);
 const createCorrelationOfferSchema = (keySchema) => SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
     key: keySchema,
+    inputPolicies: CORRELATION_INPUT_POLICY_SCHEMA.array().min(2).optional(),
     occurrenceTtl: COORDINATION_DURATION_SCHEMA.optional(),
     ordered: z.boolean(),
     outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
@@ -247,6 +252,29 @@ const createCorrelationOfferSchema = (keySchema) => SIGNAL_INVOCATION_DEPENDENCI
             path: ["streamIndex"],
         });
     }
+    if (entry.inputPolicies &&
+        entry.inputPolicies.length !== entry.streamOrigins.length) {
+        context.addIssue({
+            code: "custom",
+            message: "Correlation input policies must match the input streams.",
+            path: ["inputPolicies"],
+        });
+    }
+});
+const createTakeOfferSchema = (keySchema) => SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
+    count: z.number().int().positive(),
+    key: keySchema,
+    outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
+    policy: z.literal("take"),
+    ttl: COORDINATION_DURATION_SCHEMA.optional(),
+});
+const createRateLimitOfferSchema = (keySchema) => SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
+    interval: COORDINATION_DURATION_SCHEMA,
+    key: keySchema,
+    limit: z.number().int().positive(),
+    outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
+    overflow: z.enum(["drop", "wait"]),
+    policy: z.literal("rateLimit"),
 });
 const MERGE_OFFER_SCHEMA = SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
     inputOrigins: MERGE_INPUT_ORIGINS_SCHEMA,
@@ -265,6 +293,15 @@ const createSerializationOfferSchema = (keySchema) => SIGNAL_INVOCATION_DEPENDEN
     releaseSlot: z.number().int().nonnegative(),
     sourceOrigins: z.string().min(1).array(),
 });
+const createConcurrencyOfferSchema = (keySchema) => SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
+    key: keySchema,
+    limit: z.number().int().positive(),
+    outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
+    policy: z.literal("concurrent"),
+    releaseScopePath: HOOK_SCOPE_PATH_SCHEMA,
+    releaseSlot: z.number().int().nonnegative(),
+    sourceOrigins: z.string().min(1).array(),
+});
 const createCollectionOfferSchema = (keySchema) => SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
     count: z.number().int().positive(),
     key: keySchema,
@@ -342,6 +379,9 @@ const COLLECTION_OFFER_SCHEMA = createCollectionOfferSchema(encodableSchema);
 const CORRELATION_OFFER_SCHEMA = createCorrelationOfferSchema(encodableSchema);
 const FUNNEL_OFFER_SCHEMA = createFunnelOfferSchema(encodableSchema);
 const SERIALIZATION_OFFER_SCHEMA = createSerializationOfferSchema(encodableSchema);
+const CONCURRENCY_OFFER_SCHEMA = createConcurrencyOfferSchema(encodableSchema);
+const RATE_LIMIT_OFFER_SCHEMA = createRateLimitOfferSchema(encodableSchema);
+const TAKE_OFFER_SCHEMA = createTakeOfferSchema(encodableSchema);
 const RACE_OFFER_BASE_SCHEMA = SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
     cohortActionDependencyIds: z.string().array(),
     cohortEventDependencyIds: z.string().array(),
@@ -369,20 +409,26 @@ const RACE_OFFER_SCHEMA = z
 const COORDINATION_OFFER_SCHEMA = z.union([
     COLLECTION_OFFER_SCHEMA,
     CORRELATION_OFFER_SCHEMA,
+    CONCURRENCY_OFFER_SCHEMA,
     FANOUT_OFFER_SCHEMA,
     FUNNEL_OFFER_SCHEMA,
     MERGE_OFFER_SCHEMA,
+    RATE_LIMIT_OFFER_SCHEMA,
     RACE_OFFER_SCHEMA,
     SERIALIZATION_OFFER_SCHEMA,
+    TAKE_OFFER_SCHEMA,
 ]);
 const COORDINATION_OFFER_TRANSPORT_SCHEMA = z.union([
     createCollectionOfferSchema(codecEnvelopeSchema),
     createCorrelationOfferSchema(codecEnvelopeSchema),
+    createConcurrencyOfferSchema(codecEnvelopeSchema),
     FANOUT_OFFER_SCHEMA,
     createFunnelOfferSchema(codecEnvelopeSchema),
     MERGE_OFFER_SCHEMA,
+    createRateLimitOfferSchema(codecEnvelopeSchema),
     RACE_OFFER_SCHEMA,
     createSerializationOfferSchema(codecEnvelopeSchema),
+    createTakeOfferSchema(codecEnvelopeSchema),
 ]);
 const SIGNAL_INVOCATION_SCHEMA = z.union([
     SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automate.ax/api-contract",
-  "version": "0.137.0",
+  "version": "0.139.0",
   "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.137.0",
-    "@automate.ax/integration-contracts": "0.137.0",
+    "@automate.ax/codec": "0.139.0",
+    "@automate.ax/integration-contracts": "0.139.0",
     "@orpc/contract": "1.15.0",
     "fast-json-stable-stringify": "^2.1.0",
     "zod": "^4.3.6"

package/src/events/anthropic.ts

@@ -0,0 +1,18 @@
+import { oc } from "@orpc/contract"
+import * as z from "zod"
+
+export const anthropicEventsContract = {
+  anthropicEvent: oc
+    .route({
+      description:
+        "Receives signed lifecycle callbacks from Anthropic Claude Managed Agents.",
+      method: "POST",
+      operationId: "receiveAnthropicEvent",
+      path: "/events/anthropic",
+      successStatus: 200,
+      summary: "Receive an Anthropic Managed Agents event",
+      tags: ["Events"],
+    })
+    .input(z.unknown())
+    .output(z.void()),
+}

package/src/events/index.ts

@@ -1,5 +1,6 @@
 import { airtableEventsContract } from "./airtable"
 import { apifyEventsContract } from "./apify"
+import { anthropicEventsContract } from "./anthropic"
 import { axiomEventsContract } from "./axiom"
 import { asanaEventsContract } from "./asana"
 import { brevoEventsContract } from "./brevo"
@@ -27,6 +28,7 @@ import { webflowEventsContract } from "./webflow"
 import { whatsappEventsContract } from "./whatsapp"
 
 export const eventsContract = {
+  ...anthropicEventsContract,
   ...airtableEventsContract,
   ...apifyEventsContract,
   ...axiomEventsContract,

package/src/runtime-protocol.ts

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

package/src/runtime.ts

@@ -273,6 +273,10 @@ const CORRELATION_STREAM_ORIGINS_SCHEMA = z
   .min(1)
   .array()
   .min(2)
+const CORRELATION_INPUT_POLICY_SCHEMA = z.object({
+  consumption: z.enum(["consume", "retain"]),
+  selection: z.enum(["oldest", "latest"]),
+})
 
 const MERGE_INPUT_ORIGINS_SCHEMA = z
   .string()
@@ -287,6 +291,7 @@ const createCorrelationOfferSchema = <TKeySchema extends z.ZodType>(
 ) =>
   SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
     key: keySchema,
+    inputPolicies: CORRELATION_INPUT_POLICY_SCHEMA.array().min(2).optional(),
     occurrenceTtl: COORDINATION_DURATION_SCHEMA.optional(),
     ordered: z.boolean(),
     outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
@@ -304,6 +309,39 @@ const createCorrelationOfferSchema = <TKeySchema extends z.ZodType>(
         path: ["streamIndex"],
       })
     }
+    if (
+      entry.inputPolicies &&
+      entry.inputPolicies.length !== entry.streamOrigins.length
+    ) {
+      context.addIssue({
+        code: "custom",
+        message: "Correlation input policies must match the input streams.",
+        path: ["inputPolicies"],
+      })
+    }
+  })
+
+const createTakeOfferSchema = <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("take"),
+    ttl: COORDINATION_DURATION_SCHEMA.optional(),
+  })
+
+const createRateLimitOfferSchema = <TKeySchema extends z.ZodType>(
+  keySchema: TKeySchema,
+) =>
+  SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
+    interval: COORDINATION_DURATION_SCHEMA,
+    key: keySchema,
+    limit: z.number().int().positive(),
+    outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
+    overflow: z.enum(["drop", "wait"]),
+    policy: z.literal("rateLimit"),
   })
 
 const MERGE_OFFER_SCHEMA = SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
@@ -328,6 +366,19 @@ const createSerializationOfferSchema = <TKeySchema extends z.ZodType>(
     sourceOrigins: z.string().min(1).array(),
   })
 
+const createConcurrencyOfferSchema = <TKeySchema extends z.ZodType>(
+  keySchema: TKeySchema,
+) =>
+  SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
+    key: keySchema,
+    limit: z.number().int().positive(),
+    outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
+    policy: z.literal("concurrent"),
+    releaseScopePath: HOOK_SCOPE_PATH_SCHEMA,
+    releaseSlot: z.number().int().nonnegative(),
+    sourceOrigins: z.string().min(1).array(),
+  })
+
 const createCollectionOfferSchema = <TKeySchema extends z.ZodType>(
   keySchema: TKeySchema,
 ) =>
@@ -425,6 +476,9 @@ const CORRELATION_OFFER_SCHEMA = createCorrelationOfferSchema(encodableSchema)
 const FUNNEL_OFFER_SCHEMA = createFunnelOfferSchema(encodableSchema)
 const SERIALIZATION_OFFER_SCHEMA =
   createSerializationOfferSchema(encodableSchema)
+const CONCURRENCY_OFFER_SCHEMA = createConcurrencyOfferSchema(encodableSchema)
+const RATE_LIMIT_OFFER_SCHEMA = createRateLimitOfferSchema(encodableSchema)
+const TAKE_OFFER_SCHEMA = createTakeOfferSchema(encodableSchema)
 
 const RACE_OFFER_BASE_SCHEMA = SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
   cohortActionDependencyIds: z.string().array(),
@@ -455,21 +509,27 @@ const RACE_OFFER_SCHEMA = z
 const COORDINATION_OFFER_SCHEMA = z.union([
   COLLECTION_OFFER_SCHEMA,
   CORRELATION_OFFER_SCHEMA,
+  CONCURRENCY_OFFER_SCHEMA,
   FANOUT_OFFER_SCHEMA,
   FUNNEL_OFFER_SCHEMA,
   MERGE_OFFER_SCHEMA,
+  RATE_LIMIT_OFFER_SCHEMA,
   RACE_OFFER_SCHEMA,
   SERIALIZATION_OFFER_SCHEMA,
+  TAKE_OFFER_SCHEMA,
 ])
 
 const COORDINATION_OFFER_TRANSPORT_SCHEMA = z.union([
   createCollectionOfferSchema(codecEnvelopeSchema),
   createCorrelationOfferSchema(codecEnvelopeSchema),
+  createConcurrencyOfferSchema(codecEnvelopeSchema),
   FANOUT_OFFER_SCHEMA,
   createFunnelOfferSchema(codecEnvelopeSchema),
   MERGE_OFFER_SCHEMA,
+  createRateLimitOfferSchema(codecEnvelopeSchema),
   RACE_OFFER_SCHEMA,
   createSerializationOfferSchema(codecEnvelopeSchema),
+  createTakeOfferSchema(codecEnvelopeSchema),
 ])
 
 /** One validated durable coordination offer sent by the automation runtime. */