@xopcai/xopc 0.0.332 → 0.0.333

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

@@ -67,15 +67,41 @@ export interface AutomationManagement {
 }
 export type AutomationConversationMode = 'new_session' | 'continuous';
 export type AutomationNotificationPolicy = 'attention' | 'all' | 'none';
+export type AutomationDeliveryDestination = {
+    key: string;
+    kind: 'gateway_event';
+} | {
+    key: string;
+    kind: 'webhook';
+    endpoint: string;
+    secretId: string;
+} | {
+    key: string;
+    kind: 'file';
+    targetId: string;
+    pathTemplate: string;
+} | {
+    key: string;
+    kind: 'card';
+    channelId: string;
+    templateId: string;
+};
+export interface AutomationDeliveryPolicy {
+    notificationPolicy: AutomationNotificationPolicy;
+    destinations: AutomationDeliveryDestination[];
+}
+export interface AutomationRunDeliveryContext {
+    notificationPolicy: AutomationNotificationPolicy;
+    requiresAttention: boolean;
+    projectId?: string;
+}
 export interface AutomationReliability {
-    /** Overall run deadline. `timeoutSeconds` remains a read-only legacy fallback. */
     executionTimeoutSeconds?: number;
-    timeoutSeconds?: number;
     retryCount?: number;
     maxConcurrentRuns?: number;
     disableAfterConsecutiveFailures?: number;
 }
-export type AutomationRunPhase = 'queued' | 'action' | 'completion_hook' | 'cancelling' | 'completed';
+export type AutomationRunPhase = 'queued' | 'action' | 'cancelling' | 'completed';
 export interface AutomationRunTermination {
     reason: 'completed' | 'failed' | 'user_cancelled' | 'deadline_exceeded';
     component?: 'automation' | 'agent_turn' | 'tool' | 'mcp' | 'process';
@@ -104,8 +130,7 @@ export interface Automation {
     action: AutomationAction;
     safety?: AutomationSafetyPolicy;
     conversationMode: AutomationConversationMode;
-    notificationPolicy: AutomationNotificationPolicy;
-    completionWebhookUrl?: string;
+    delivery: AutomationDeliveryPolicy;
     reliability?: AutomationReliability;
     management?: AutomationManagement;
     state: AutomationState;
@@ -142,7 +167,7 @@ export interface AutomationRun {
     rootRunId?: string;
     readAtMs?: number;
 }
-export type AutomationRunEventType = 'run.queued' | 'run.started' | 'run.deadline_resolved' | 'run.cancel_requested' | 'run.cancel_confirmed' | 'run.cancellation_unconfirmed' | 'run.recovered' | 'action.started' | 'action.retry_scheduled' | 'action.completed' | 'action.failed' | 'completion_hook.started' | 'completion_hook.completed' | 'completion_hook.failed' | 'run.completed';
+export type AutomationRunEventType = 'run.queued' | 'run.started' | 'run.deadline_resolved' | 'run.cancel_requested' | 'run.cancel_confirmed' | 'run.cancellation_unconfirmed' | 'run.recovered' | 'action.started' | 'action.retry_scheduled' | 'action.completed' | 'action.failed' | 'run.completed';
 export interface AutomationRunEvent {
     id: string;
     runId: string;
@@ -157,10 +182,60 @@ export interface AutomationProductEventRun {
     triggerEvent: AutomationRunEvent;
 }
 export interface AutomationEvent {
+    id?: string;
     type: string;
     source?: string;
+    schemaVersion?: number;
+    subject?: {
+        kind: string;
+        id: string;
+    };
     payload?: Record<string, unknown>;
     occurredAtMs?: number;
+    correlationId?: string;
+    causationId?: string;
+    rootEventId?: string;
+    chainDepth?: number;
+    dedupeKey?: string;
+    trust?: 'system' | 'user' | 'connector' | 'untrusted_webhook';
+}
+export interface AutomationEventEnvelope extends AutomationEvent {
+    id: string;
+    source: string;
+    schemaVersion: number;
+    occurredAtMs: number;
+    ingestedAtMs: number;
+    correlationId: string;
+    rootEventId: string;
+    chainDepth: number;
+    trust: 'system' | 'user' | 'connector' | 'untrusted_webhook';
+    payload: Record<string, unknown>;
+}
+export type AutomationEventProjectionStatus = 'pending' | 'projecting' | 'retrying' | 'projected' | 'dead_letter';
+export type AutomationEventDeliveryStatus = 'pending' | 'retrying' | 'queued' | 'completed' | 'failed' | 'cancelled' | 'skipped' | 'dead_letter';
+export interface AutomationEventRecord {
+    event: AutomationEventEnvelope;
+    projectionStatus: AutomationEventProjectionStatus;
+    projectionAttempts: number;
+    projectionError?: string;
+    deliveries: Array<{
+        automationId: string;
+        status: AutomationEventDeliveryStatus;
+        runId?: string;
+        attempts: number;
+        lastError?: string;
+    }>;
+}
+export interface AutomationResultDeliveryRecord {
+    runId: string;
+    destinationKey: string;
+    kind: string;
+    status: 'pending' | 'delivering' | 'retrying' | 'delivered' | 'dead_letter';
+    attempts: number;
+    nextAttemptAtMs: number;
+    lastError?: string;
+    createdAtMs: number;
+    updatedAtMs: number;
 }
 export interface AutomationMetrics {
     totalAutomations: number;
@@ -172,7 +247,73 @@ export interface AutomationMetrics {
         name: string;
         runAtMs: number;
     };
+    pendingEvents: number;
+    oldestPendingEventAgeMs: number;
+    projectionDeadLetters: number;
+    pendingRunDeliveries: number;
+    runDeliveryDeadLetters: number;
+    pendingResultDeliveries: number;
+    resultDeliveryDeadLetters: number;
+    activeExecutions: number;
+    activeDeliveryLeases: number;
+}
+export type AutomationArtifact = {
+    id: string;
+    kind: 'text';
+    text: string;
+    mediaType: 'text/plain' | 'text/markdown';
+} | {
+    id: string;
+    kind: 'json';
+    schema: string;
+    data: Record<string, unknown>;
+} | {
+    id: string;
+    kind: 'file';
+    uri: string;
+    name: string;
+    mediaType: string;
+    bytes?: number;
+    sha256?: string;
+} | {
+    id: string;
+    kind: 'card';
+    schema: string;
+    data: Record<string, unknown>;
+} | {
+    id: string;
+    kind: 'reference';
+    resourceType: string;
+    resourceId: string;
+    url?: string;
+};
+export interface AutomationResultEnvelope {
+    schemaVersion: 1;
+    resultId: string;
+    runId: string;
+    automationId: string;
+    status: Extract<AutomationRunStatus, 'succeeded' | 'failed' | 'cancelled' | 'timeout'>;
+    summary?: string;
+    error?: {
+        code: string;
+        message: string;
+        retryable: boolean;
+    };
+    artifacts: AutomationArtifact[];
+    correlationId: string;
+    rootEventId: string;
+    createdAtMs: number;
+    completedAtMs: number;
 }
+export type AutomationRetrySafety = {
+    mode: 'never';
+} | {
+    mode: 'idempotent';
+    key: 'run_id';
+} | {
+    mode: 'transient_only';
+    classify: (error: unknown) => boolean;
+};
 export interface PrepareAutomationAgentSessionInput {
     automationName?: string;
     conversationId: string;
@@ -210,7 +351,16 @@ export interface AutomationDeps {
             error?: string;
         }>;
     };
-    onRunCompleted?: (run: AutomationRun) => void;
+    onRunCompleted?: (run: AutomationRun, context: AutomationRunDeliveryContext) => void | Promise<void>;
+    onEvent?: (event: AutomationEventEnvelope, signal?: AbortSignal) => void | Promise<void>;
+    onReliabilityAttention?: (input: {
+        phase: 'event_projection' | 'event_delivery' | 'result_delivery';
+        eventId?: string;
+        automationId?: string;
+        runId?: string;
+        destinationKey?: string;
+        error: string;
+    }) => void;
     executeTaskCommand?: (input: {
         taskId: string;
         idempotencyKey: string;
@@ -242,6 +392,7 @@ export interface AutomationActionTask {
     model?: string;
     deadlineAtMs?: number;
     termination?: AutomationRunTermination;
+    artifacts?: AutomationArtifact[];
 }
 export interface AutomationActionExecutionHooks {
     onRunPatch?: (patch: Partial<AutomationRun>) => void | Promise<void>;

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>;
@@ -570,15 +614,34 @@ 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>>;
+    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>;
@@ -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

@@ -12,7 +12,28 @@ export declare function buildAutomationDraftResponse(draft: GeneratedAutomationD
     automation: {
         name: string;
         conversationMode: "new_session" | "continuous";
-        notificationPolicy: "attention" | "all" | "none";
+        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;
+            })[];
+        };
         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[];