@xopcai/xopc 0.0.332 → 0.0.334

package/dist/src/automations/domain/validation.d.ts

@@ -171,7 +171,6 @@ export declare const AutomationManagementSchema: z.ZodObject<{
 }, z.core.$strict>;
 export declare const AutomationReliabilitySchema: z.ZodObject<{
     executionTimeoutSeconds: z.ZodOptional<z.ZodNumber>;
-    timeoutSeconds: z.ZodOptional<z.ZodNumber>;
     retryCount: z.ZodOptional<z.ZodNumber>;
     maxConcurrentRuns: z.ZodOptional<z.ZodNumber>;
     disableAfterConsecutiveFailures: z.ZodOptional<z.ZodNumber>;
@@ -183,6 +182,32 @@ export declare const AutomationSafetyPolicySchema: z.ZodObject<{
         auto_apply: "auto_apply";
     }>;
 }, z.core.$strict>;
+export declare const AutomationDeliveryPolicySchema: z.ZodObject<{
+    notificationPolicy: z.ZodDefault<z.ZodEnum<{
+        attention: "attention";
+        all: "all";
+        none: "none";
+    }>>;
+    destinations: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        key: z.ZodString;
+        kind: z.ZodLiteral<"gateway_event">;
+    }, z.core.$strict>, z.ZodObject<{
+        key: z.ZodString;
+        kind: z.ZodLiteral<"webhook">;
+        endpoint: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        secretId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        key: z.ZodString;
+        kind: z.ZodLiteral<"file">;
+        targetId: z.ZodString;
+        pathTemplate: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        key: z.ZodString;
+        kind: z.ZodLiteral<"card">;
+        channelId: z.ZodString;
+        templateId: z.ZodString;
+    }, z.core.$strict>], "kind">>>;
+}, z.core.$strict>;
 export declare const AutomationStateSchema: z.ZodObject<{
     nextRunAtMs: z.ZodOptional<z.ZodNumber>;
     runningRunId: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
@@ -365,15 +390,34 @@ export declare const AutomationSchema: z.ZodObject<{
         new_session: "new_session";
         continuous: "continuous";
     }>>;
-    notificationPolicy: z.ZodDefault<z.ZodEnum<{
-        attention: "attention";
-        all: "all";
-        none: "none";
-    }>>;
-    completionWebhookUrl: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
+    delivery: z.ZodDefault<z.ZodObject<{
+        notificationPolicy: z.ZodDefault<z.ZodEnum<{
+            attention: "attention";
+            all: "all";
+            none: "none";
+        }>>;
+        destinations: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            key: z.ZodString;
+            kind: z.ZodLiteral<"gateway_event">;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            kind: z.ZodLiteral<"webhook">;
+            endpoint: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            secretId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            kind: z.ZodLiteral<"file">;
+            targetId: z.ZodString;
+            pathTemplate: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            kind: z.ZodLiteral<"card">;
+            channelId: z.ZodString;
+            templateId: z.ZodString;
+        }, z.core.$strict>], "kind">>>;
+    }, z.core.$strict>>;
     reliability: z.ZodOptional<z.ZodObject<{
         executionTimeoutSeconds: z.ZodOptional<z.ZodNumber>;
-        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
         retryCount: z.ZodOptional<z.ZodNumber>;
         maxConcurrentRuns: z.ZodOptional<z.ZodNumber>;
         disableAfterConsecutiveFailures: z.ZodOptional<z.ZodNumber>;
@@ -559,6 +603,32 @@ export declare const CreateAutomationSchema: z.ZodObject<{
         payloadMatch: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
     }, z.core.$strict>], "kind">;
     description: z.ZodOptional<z.ZodString>;
+    delivery: z.ZodDefault<z.ZodObject<{
+        notificationPolicy: z.ZodDefault<z.ZodEnum<{
+            attention: "attention";
+            all: "all";
+            none: "none";
+        }>>;
+        destinations: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            key: z.ZodString;
+            kind: z.ZodLiteral<"gateway_event">;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            kind: z.ZodLiteral<"webhook">;
+            endpoint: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            secretId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            kind: z.ZodLiteral<"file">;
+            targetId: z.ZodString;
+            pathTemplate: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            kind: z.ZodLiteral<"card">;
+            channelId: z.ZodString;
+            templateId: z.ZodString;
+        }, z.core.$strict>], "kind">>>;
+    }, z.core.$strict>>;
     safety: z.ZodOptional<z.ZodObject<{
         mode: z.ZodEnum<{
             suggest_only: "suggest_only";
@@ -570,15 +640,8 @@ export declare const CreateAutomationSchema: z.ZodObject<{
         new_session: "new_session";
         continuous: "continuous";
     }>>;
-    notificationPolicy: z.ZodDefault<z.ZodEnum<{
-        attention: "attention";
-        all: "all";
-        none: "none";
-    }>>;
-    completionWebhookUrl: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
     reliability: z.ZodOptional<z.ZodObject<{
         executionTimeoutSeconds: z.ZodOptional<z.ZodNumber>;
-        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
         retryCount: z.ZodOptional<z.ZodNumber>;
         maxConcurrentRuns: z.ZodOptional<z.ZodNumber>;
         disableAfterConsecutiveFailures: z.ZodOptional<z.ZodNumber>;
@@ -772,10 +835,8 @@ export declare const UpdateAutomationSchema: z.ZodObject<{
             auto_apply: "auto_apply";
         }>;
     }, z.core.$strict>>>;
-    completionWebhookUrl: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>>;
     reliability: z.ZodOptional<z.ZodOptional<z.ZodObject<{
         executionTimeoutSeconds: z.ZodOptional<z.ZodNumber>;
-        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
         retryCount: z.ZodOptional<z.ZodNumber>;
         maxConcurrentRuns: z.ZodOptional<z.ZodNumber>;
         disableAfterConsecutiveFailures: z.ZodOptional<z.ZodNumber>;
@@ -793,11 +854,32 @@ export declare const UpdateAutomationSchema: z.ZodObject<{
         new_session: "new_session";
         continuous: "continuous";
     }>>;
-    notificationPolicy: z.ZodOptional<z.ZodEnum<{
-        attention: "attention";
-        all: "all";
-        none: "none";
-    }>>;
+    delivery: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        notificationPolicy: z.ZodDefault<z.ZodEnum<{
+            attention: "attention";
+            all: "all";
+            none: "none";
+        }>>;
+        destinations: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            key: z.ZodString;
+            kind: z.ZodLiteral<"gateway_event">;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            kind: z.ZodLiteral<"webhook">;
+            endpoint: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            secretId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            kind: z.ZodLiteral<"file">;
+            targetId: z.ZodString;
+            pathTemplate: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            kind: z.ZodLiteral<"card">;
+            channelId: z.ZodString;
+            templateId: z.ZodString;
+        }, z.core.$strict>], "kind">>>;
+    }, z.core.$strict>>>;
     state: z.ZodOptional<z.ZodObject<{
         nextRunAtMs: z.ZodOptional<z.ZodNumber>;
         runningRunId: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;

package/dist/src/automations/domain/validation.js

@@ -6,6 +6,19 @@ import { CronExpressionParser } from "cron-parser";
 init_src();
 const nonEmptyString = z.string().trim().min(1);
 const optionalTrimmedString = (max) => z.string().trim().max(max).nullish().transform((value) => value || void 0);
+const httpsUrl = z.string().trim().min(1).max(2e3).transform((value, ctx) => {
+	try {
+		const parsed = new URL(value);
+		if (parsed.protocol !== "https:") throw new Error("unsupported protocol");
+		return parsed.toString();
+	} catch {
+		ctx.addIssue({
+			code: "custom",
+			message: "Webhook endpoint must be a valid HTTPS URL"
+		});
+		return z.NEVER;
+	}
+});
 const AutomationScheduleSchema = z.discriminatedUnion("kind", [
 	z.object({
 		kind: z.literal("once"),
@@ -108,7 +121,6 @@ const AutomationManagementSchema = z.object({
 }).strict();
 const AutomationReliabilitySchema = z.object({
 	executionTimeoutSeconds: z.number().int().min(1).max(86400).optional(),
-	timeoutSeconds: z.number().int().min(1).max(86400).optional(),
 	retryCount: z.number().int().min(0).max(10).optional(),
 	maxConcurrentRuns: z.number().int().min(1).max(20).optional(),
 	disableAfterConsecutiveFailures: z.number().int().min(1).max(100).optional()
@@ -118,6 +130,50 @@ const AutomationSafetyPolicySchema = z.object({ mode: z.enum([
 	"ask_before_apply",
 	"auto_apply"
 ]) }).strict();
+const AutomationDeliveryPolicySchema = z.object({
+	notificationPolicy: z.enum([
+		"attention",
+		"all",
+		"none"
+	]).default("attention"),
+	destinations: z.array(z.discriminatedUnion("kind", [
+		z.object({
+			key: nonEmptyString.max(100),
+			kind: z.literal("gateway_event")
+		}).strict(),
+		z.object({
+			key: nonEmptyString.max(100),
+			kind: z.literal("webhook"),
+			endpoint: httpsUrl,
+			secretId: nonEmptyString.max(200)
+		}).strict(),
+		z.object({
+			key: nonEmptyString.max(100),
+			kind: z.literal("file"),
+			targetId: nonEmptyString.max(200),
+			pathTemplate: nonEmptyString.max(2e3)
+		}).strict(),
+		z.object({
+			key: nonEmptyString.max(100),
+			kind: z.literal("card"),
+			channelId: nonEmptyString.max(200),
+			templateId: nonEmptyString.max(200)
+		}).strict()
+	])).max(20).superRefine((destinations, ctx) => {
+		const keys = /* @__PURE__ */ new Set();
+		destinations.forEach((destination, index) => {
+			if (keys.has(destination.key)) ctx.addIssue({
+				code: "custom",
+				path: [index, "key"],
+				message: `Duplicate destination key: ${destination.key}`
+			});
+			keys.add(destination.key);
+		});
+	}).default([{
+		key: "gateway_event",
+		kind: "gateway_event"
+	}])
+}).strict();
 const AutomationStateSchema = z.object({
 	nextRunAtMs: z.number().int().nonnegative().optional(),
 	runningRunId: optionalTrimmedString(100),
@@ -144,12 +200,13 @@ const AutomationSchema = z.object({
 	action: AutomationActionSchema,
 	safety: AutomationSafetyPolicySchema.optional(),
 	conversationMode: z.enum(["new_session", "continuous"]).default("new_session"),
-	notificationPolicy: z.enum([
-		"attention",
-		"all",
-		"none"
-	]).default("attention"),
-	completionWebhookUrl: optionalTrimmedString(2e3),
+	delivery: AutomationDeliveryPolicySchema.default({
+		notificationPolicy: "attention",
+		destinations: [{
+			key: "gateway_event",
+			kind: "gateway_event"
+		}]
+	}),
 	reliability: AutomationReliabilitySchema.optional(),
 	management: AutomationManagementSchema.optional(),
 	state: AutomationStateSchema.default({}),
@@ -173,12 +230,8 @@ const UpdateAutomationSchema = AutomationSchema.omit({
 	updatedAtMs: true
 }).extend({
 	conversationMode: z.enum(["new_session", "continuous"]),
-	notificationPolicy: z.enum([
-		"attention",
-		"all",
-		"none"
-	]),
+	delivery: AutomationDeliveryPolicySchema.optional(),
 	state: AutomationStateSchema
 }).partial().refine((data) => Object.keys(data).length > 0, { message: "At least one field must be provided" });
 //#endregion
-export { AutomationActionSchema, AutomationManagementSchema, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, UpdateAutomationSchema };
+export { AutomationActionSchema, AutomationDeliveryPolicySchema, AutomationManagementSchema, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, UpdateAutomationSchema };

package/dist/src/automations/draft/automation-draft-prompt.js

@@ -11,7 +11,7 @@ JSON shape:
     "action": { "kind": "agent", "instruction": "clear instruction for the agent" },
     "safety": { "mode": "suggest_only" },
     "conversationMode": "new_session",
-    "notificationPolicy": "attention",
+    "delivery": { "notificationPolicy": "attention" },
     "reliability": { "executionTimeoutSeconds": 300, "disableAfterConsecutiveFailures": 3 }
   },
   "explanation": "Short explanation",
@@ -52,7 +52,7 @@ Rules:
 - Use cron for daily/weekly schedules. Use standard 5-field cron.
 - Keep executionTimeoutSeconds between 60 and 1800.
 - Use conversationMode "new_session" unless the user explicitly wants each run to continue the same conversation.
-- Use notificationPolicy "attention" unless the user explicitly requests every-run notifications or no notifications.
+- Use delivery.notificationPolicy "attention" unless the user explicitly requests every-run notifications or no notifications.
 - Language for user-facing copy: ${params.language ?? "en"}.
 
 User request:
@@ -85,8 +85,7 @@ JSON shape:
     "action": "optional complete action object",
     "safety": "optional complete safety object",
     "conversationMode": "optional new_session or continuous",
-    "notificationPolicy": "optional attention, all, or none",
-    "completionWebhookUrl": "optional HTTPS URL",
+    "delivery": { "notificationPolicy": "optional attention, all, or none", "destinations": [{ "key": "stable key", "kind": "gateway_event or webhook", "endpoint": "HTTPS URL for webhook", "secretId": "outbound secret id for webhook" }] },
     "reliability": "optional complete reliability object",
     "enabled": true
   },

package/dist/src/automations/draft/automation-draft-service.js

@@ -37,6 +37,9 @@ var AutomationDraftService = class {
 				maxTokens: 2048,
 				temperature: attempt === 0 ? .2 : .1,
 				signal
+			}, void 0, {
+				operation: "automation.generate_draft",
+				trigger: attempt === 0 ? "user" : "retry"
 			}));
 			try {
 				return buildAutomationDraftResponse(parseGeneratedAutomationDraft(lastText), attempt);
@@ -90,6 +93,9 @@ var AutomationDraftService = class {
 				maxTokens: 2048,
 				temperature: attempt === 0 ? .15 : .05,
 				signal
+			}, void 0, {
+				operation: "automation.generate_draft",
+				trigger: attempt === 0 ? "user" : "retry"
 			}));
 			try {
 				return parseGeneratedAutomationRepairDraft(lastText, attempt);

package/dist/src/automations/draft/automation-draft-validator.d.ts

@@ -11,8 +11,29 @@ export declare function buildAutomationDraftResponse(draft: GeneratedAutomationD
     draftId: `${string}-${string}-${string}-${string}-${string}`;
     automation: {
         name: string;
+        delivery: {
+            notificationPolicy: "attention" | "all" | "none";
+            destinations: ({
+                key: string;
+                kind: "gateway_event";
+            } | {
+                key: string;
+                kind: "webhook";
+                secretId: string;
+                endpoint?: string;
+            } | {
+                key: string;
+                kind: "file";
+                targetId: string;
+                pathTemplate: string;
+            } | {
+                key: string;
+                kind: "card";
+                channelId: string;
+                templateId: string;
+            })[];
+        };
         conversationMode: "new_session" | "continuous";
-        notificationPolicy: "attention" | "all" | "none";
         projectId?: string;
         action?: {
             kind: "agent";
@@ -135,10 +156,8 @@ export declare function buildAutomationDraftResponse(draft: GeneratedAutomationD
         safety?: {
             mode: "suggest_only" | "ask_before_apply" | "auto_apply";
         };
-        completionWebhookUrl?: string;
         reliability?: {
             executionTimeoutSeconds?: number;
-            timeoutSeconds?: number;
             retryCount?: number;
             maxConcurrentRuns?: number;
             disableAfterConsecutiveFailures?: number;

package/dist/src/automations/draft/automation-draft-validator.js

@@ -54,9 +54,9 @@ function simulateAutomation(input) {
 	const triggerSummary = summarizeTrigger(automation.trigger);
 	const actionSummary = summarizeAction(automation.action);
 	if (automation.action.kind === "agent" && /delete|remove|send|post|publish|付款|删除|发送|发布/i.test(automation.action.instruction)) requiredConfirmations.push("Agent instruction may perform an external or destructive action.");
-	if (automation.completionWebhookUrl) {
-		safetyNotes.push("The completion webhook will call an external URL after each run.");
-		requiredConfirmations.push("External webhook call should be reviewed before publishing.");
+	if (automation.delivery.destinations.some((destination) => destination.kind === "webhook")) {
+		safetyNotes.push("The result webhook will call an external URL after each run.");
+		requiredConfirmations.push("External result delivery should be reviewed before publishing.");
 	}
 	const safetyMode = automation.safety?.mode ?? "auto_apply";
 	if (safetyMode === "suggest_only") safetyNotes.push("Suggest-only safety mode will generate recommendations without applying changes.");
@@ -97,7 +97,7 @@ function summarizeAction(action) {
 }
 function repairPatchNeedsApproval(patch) {
 	if (patch.safety?.mode === "auto_apply") return true;
-	if (patch.completionWebhookUrl) return true;
+	if (patch.delivery?.destinations.some((destination) => destination.kind === "webhook")) return true;
 	if (patch.trigger?.kind === "webhook") return true;
 	if (patch.action?.kind === "agent") return /delete|remove|send|post|publish|付款|删除|发送|发布/i.test(patch.action.instruction);
 	return false;

package/dist/src/automations/events/event-catalog.d.ts

@@ -0,0 +1,14 @@
+import { type ZodType } from 'zod';
+import type { AutomationEventEnvelope } from '../domain/types.js';
+export interface BusinessEventDefinition<TPayload extends Record<string, unknown> = Record<string, unknown>> {
+    type: string;
+    source: string;
+    schemaVersion: number;
+    payloadSchema: ZodType<TPayload>;
+    defaultTrust: Extract<AutomationEventEnvelope['trust'], 'system' | 'user' | 'connector'>;
+    description: string;
+    subjectKind: string;
+}
+export declare function registerBusinessEvent<TPayload extends Record<string, unknown>>(definition: BusinessEventDefinition<TPayload>): void;
+export declare function validateCatalogedBusinessEvent(event: AutomationEventEnvelope): void;
+export declare function listBusinessEventDefinitions(): BusinessEventDefinition[];

package/dist/src/automations/events/event-catalog.js

@@ -0,0 +1,117 @@
+import { z } from "zod";
+//#region src/automations/events/event-catalog.ts
+const definitions = /* @__PURE__ */ new Map();
+function catalogKey(type, source, schemaVersion) {
+	return `${source}\0${type}\0${schemaVersion}`;
+}
+function registerBusinessEvent(definition) {
+	const key = catalogKey(definition.type, definition.source, definition.schemaVersion);
+	if (definitions.has(key)) throw new Error(`Business event is already registered: ${definition.source}/${definition.type}@${definition.schemaVersion}`);
+	definitions.set(key, definition);
+}
+function validateCatalogedBusinessEvent(event) {
+	const definition = definitions.get(catalogKey(event.type, event.source, event.schemaVersion));
+	if (!definition) return;
+	if (event.subject?.kind !== definition.subjectKind) throw new Error(`Business event subject must be ${definition.subjectKind}: ${event.type}`);
+	definition.payloadSchema.parse(event.payload);
+}
+function listBusinessEventDefinitions() {
+	return [...definitions.values()].toSorted((left, right) => `${left.source}/${left.type}`.localeCompare(`${right.source}/${right.type}`));
+}
+const objectPayload = z.record(z.string(), z.unknown());
+for (const definition of [
+	[
+		"tasks",
+		"task.changed.v2",
+		"task",
+		"A Task changed."
+	],
+	[
+		"tasks",
+		"task.deleted.v1",
+		"task",
+		"A Task was deleted."
+	],
+	[
+		"notes",
+		"note.created",
+		"note",
+		"A Note was created."
+	],
+	[
+		"notes",
+		"note.updated",
+		"note",
+		"A Note changed."
+	],
+	[
+		"notes",
+		"note.deleted",
+		"note",
+		"A Note was deleted."
+	],
+	[
+		"projects",
+		"project.created",
+		"project",
+		"A Project was created."
+	],
+	[
+		"projects",
+		"project.changed",
+		"project",
+		"A Project changed."
+	],
+	[
+		"projects",
+		"project.deleted",
+		"project",
+		"A Project was deleted."
+	],
+	[
+		"scenes",
+		"scene.created",
+		"scene",
+		"A Scene was created."
+	],
+	[
+		"scenes",
+		"scene.changed",
+		"scene",
+		"A Scene changed."
+	],
+	[
+		"scenes",
+		"scene.deleted",
+		"scene",
+		"A Scene was deleted."
+	],
+	[
+		"discussions",
+		"discussion.completed",
+		"discussion",
+		"A Discussion completed."
+	],
+	[
+		"sessions",
+		"session.transcript.updated",
+		"session",
+		"A Session transcript changed."
+	],
+	[
+		"workflows",
+		"workflow.run.completed",
+		"workflow_run",
+		"A Workflow run completed."
+	]
+]) registerBusinessEvent({
+	source: definition[0],
+	type: definition[1],
+	subjectKind: definition[2],
+	description: definition[3],
+	schemaVersion: 1,
+	payloadSchema: objectPayload,
+	defaultTrust: "system"
+});
+//#endregion
+export { listBusinessEventDefinitions, registerBusinessEvent, validateCatalogedBusinessEvent };

package/dist/src/automations/events/event-dispatcher.d.ts

@@ -0,0 +1,27 @@
+import type { AutomationEventEnvelope, AutomationRun } from '../domain/types.js';
+import type { AutomationService } from '../service/automation-service.js';
+export declare class AutomationEventDispatcher {
+    private readonly automationService;
+    private readonly options;
+    private timer?;
+    private active?;
+    private stopping;
+    private readonly owner;
+    private readonly abortController;
+    constructor(automationService: AutomationService, options?: {
+        onEvent?: (event: AutomationEventEnvelope, signal?: AbortSignal) => void | Promise<void>;
+        onDeadLetter?: (input: {
+            phase: 'event_projection' | 'event_delivery';
+            eventId: string;
+            automationId?: string;
+            error: string;
+        }) => void;
+        intervalMs?: number;
+    });
+    start(): void;
+    stop(): Promise<void>;
+    dispatch(): Promise<number>;
+    runCompleted(run: AutomationRun): void;
+    private runDispatch;
+    private projectEvents;
+}