@amalgm/automations 0.2.1 → 0.2.3

package/dist/src/run-journal.d.ts

@@ -0,0 +1,8 @@
+import type { AutomationRunJournal, AutomationStepRun, Json, ToolActionStep } from './contract.js';
+export declare function emptyJournal(): AutomationRunJournal;
+export declare function runJournal(value: Json | undefined, plan: readonly ToolActionStep[]): AutomationRunJournal;
+export declare function completed(journal: AutomationRunJournal, stepId: string): boolean;
+export declare function stepAttempt(journal: AutomationRunJournal, stepId: string): number;
+export declare function putStep(journal: AutomationRunJournal, step: AutomationStepRun): AutomationRunJournal;
+/** Journals are constructed from JSON fields only; this is the persistence boundary. */
+export declare function journalJson(journal: AutomationRunJournal): Json;

package/dist/src/run-journal.js

@@ -0,0 +1,56 @@
+export function emptyJournal() {
+    return { version: 1, steps: [] };
+}
+export function runJournal(value, plan) {
+    if (value === undefined)
+        return emptyJournal();
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Run step journal is invalid');
+    const source = value;
+    if (source.version !== 1 || !Array.isArray(source.steps))
+        throw new Error('Run step journal is invalid');
+    const planIds = new Set(plan.map(({ id }) => id));
+    const steps = source.steps.map(runStep);
+    const ids = new Set();
+    for (const step of steps) {
+        if (!planIds.has(step.id))
+            throw new Error(`Run step is not in the immutable plan: ${step.id}`);
+        if (ids.has(step.id))
+            throw new Error(`Run step journal has a duplicate id: ${step.id}`);
+        ids.add(step.id);
+    }
+    return { version: 1, steps };
+}
+export function completed(journal, stepId) {
+    return journal.steps.some((step) => step.id === stepId && step.status === 'completed');
+}
+export function stepAttempt(journal, stepId) {
+    return journal.steps.find((step) => step.id === stepId)?.attempts ?? 0;
+}
+export function putStep(journal, step) {
+    const index = journal.steps.findIndex(({ id }) => id === step.id);
+    const steps = [...journal.steps];
+    if (index === -1)
+        steps.push(step);
+    else
+        steps[index] = step;
+    return { version: 1, steps };
+}
+/** Journals are constructed from JSON fields only; this is the persistence boundary. */
+export function journalJson(journal) {
+    return journal;
+}
+function runStep(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Run step is invalid');
+    const item = value;
+    if (typeof item.id !== 'string' || !item.id)
+        throw new Error('Run step id is invalid');
+    if (item.status !== 'running' && item.status !== 'completed' && item.status !== 'failed') {
+        throw new Error(`Run step status is invalid: ${item.id}`);
+    }
+    if (!Number.isInteger(item.attempts) || Number(item.attempts) < 1 || typeof item.startedAt !== 'string') {
+        throw new Error(`Run step attempt is invalid: ${item.id}`);
+    }
+    return item;
+}

package/dist/src/runner.d.ts

@@ -0,0 +1,14 @@
+import type { ClaimedAutomationRun, MachineRuns } from './machine.js';
+export interface AutomationMachineRunnerOptions {
+    readonly runs: MachineRuns;
+    readonly execute: (run: ClaimedAutomationRun) => Promise<void>;
+    readonly batchSize?: number;
+    readonly leaseSeconds?: number;
+    readonly pollIntervalMs?: number;
+    readonly maxBackoffMs?: number;
+    readonly log?: (event: string, details?: Readonly<Record<string, unknown>>) => void;
+}
+export declare function createAutomationMachineRunner(options: AutomationMachineRunnerOptions): Readonly<{
+    start(): void;
+    close(): Promise<void>;
+}>;

package/dist/src/runner.js

@@ -0,0 +1,70 @@
+export function createAutomationMachineRunner(options) {
+    const batchSize = integer(options.batchSize ?? 8, 1, 20, 'batchSize');
+    const leaseSeconds = integer(options.leaseSeconds ?? 60, 30, 900, 'leaseSeconds');
+    const pollIntervalMs = integer(options.pollIntervalMs ?? 1_000, 1, 60_000, 'pollIntervalMs');
+    const maxBackoffMs = integer(options.maxBackoffMs ?? Math.max(30_000, pollIntervalMs), pollIntervalMs, 300_000, 'maxBackoffMs');
+    let active = null;
+    let timer = null;
+    let stopped = true;
+    let failures = 0;
+    let nextDelay = pollIntervalMs;
+    const schedule = (delay) => {
+        if (stopped)
+            return;
+        timer = setTimeout(drain, delay);
+        timer.unref?.();
+    };
+    const drain = () => {
+        if (stopped || active)
+            return active;
+        active = options.runs.claim({ limit: batchSize, leaseSeconds })
+            .then(async (runs) => {
+            failures = 0;
+            if (runs.length)
+                options.log?.('automations.claimed', { count: runs.length });
+            const settled = await Promise.allSettled(runs.map(options.execute));
+            settled.forEach((result) => {
+                if (result.status === 'rejected') {
+                    options.log?.('automations.run.failed', { error: safe(result.reason) });
+                }
+            });
+            nextDelay = runs.length === batchSize ? 0 : pollIntervalMs;
+        })
+            .catch((error) => {
+            failures += 1;
+            const delayMs = Math.min(maxBackoffMs, pollIntervalMs * (2 ** Math.min(failures - 1, 10)));
+            options.log?.('automations.poll.failed', { error: safe(error), retryInMs: delayMs });
+            nextDelay = delayMs;
+        })
+            .finally(() => {
+            active = null;
+            schedule(nextDelay);
+        });
+        return active;
+    };
+    return Object.freeze({
+        start() {
+            if (!stopped)
+                return;
+            stopped = false;
+            failures = 0;
+            void drain();
+        },
+        async close() {
+            stopped = true;
+            if (timer)
+                clearTimeout(timer);
+            timer = null;
+            await active;
+        },
+    });
+}
+function integer(value, minimum, maximum, name) {
+    if (!Number.isInteger(value) || value < minimum || value > maximum) {
+        throw new Error(`${name} must be an integer from ${minimum} to ${maximum}`);
+    }
+    return value;
+}
+function safe(error) {
+    return (error instanceof Error ? error.message : String(error)).replace(/[\r\n]+/g, ' ').slice(0, 500);
+}

package/dist/src/schema.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod/v3';
-import type { CreateAutomation, CreateScheduleTrigger, CreateWebhookTrigger, CreateWorkflow, Json, ListAutomations, ListRuns, PageQuery, UpdateAutomation, UpdateScheduleTrigger, UpdateWebhookTrigger, UpdateWorkflow } from './contract.js';
+import type { CreateAutomation, CreateScheduleTrigger, CreateWebhookTrigger, CreateWorkflow, Json, ListAutomations, ListRuns, PageQuery, RunAutomationNow, UpdateAutomation, UpdateScheduleTrigger, UpdateWebhookTrigger, UpdateWorkflow } from './contract.js';
 export declare const identifierSchema: z.ZodString;
 export declare const pageQuerySchema: z.ZodObject<{
     limit: z.ZodOptional<z.ZodNumber>;
@@ -122,46 +122,51 @@ export declare const createWebhookTriggerSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     source: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     event: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-    secret: z.ZodString;
+    secret: z.ZodOptional<z.ZodString>;
     enabled: z.ZodOptional<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
-    secret: string;
     enabled?: boolean | undefined;
     event?: string | undefined;
-    source?: string | undefined;
+    secret?: string | undefined;
     id?: string | undefined;
+    source?: string | undefined;
 }, {
-    secret: string;
     enabled?: boolean | undefined;
     event?: string | undefined;
-    source?: string | undefined;
+    secret?: string | undefined;
     id?: string | undefined;
+    source?: string | undefined;
 }>;
 export declare const updateWebhookTriggerSchema: z.ZodEffects<z.ZodObject<{
     source: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     event: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-    secret: z.ZodOptional<z.ZodString>;
+    secret: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    rotateUrl: z.ZodOptional<z.ZodBoolean>;
     enabled: z.ZodOptional<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
     enabled?: boolean | undefined;
     event?: string | undefined;
-    secret?: string | undefined;
+    secret?: string | null | undefined;
     source?: string | undefined;
+    rotateUrl?: boolean | undefined;
 }, {
     enabled?: boolean | undefined;
     event?: string | undefined;
-    secret?: string | undefined;
+    secret?: string | null | undefined;
     source?: string | undefined;
+    rotateUrl?: boolean | undefined;
 }>, {
     enabled?: boolean | undefined;
     event?: string | undefined;
-    secret?: string | undefined;
+    secret?: string | null | undefined;
     source?: string | undefined;
+    rotateUrl?: boolean | undefined;
 }, {
     enabled?: boolean | undefined;
     event?: string | undefined;
-    secret?: string | undefined;
+    secret?: string | null | undefined;
     source?: string | undefined;
+    rotateUrl?: boolean | undefined;
 }>;
 export declare const createWorkflowSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
@@ -193,26 +198,26 @@ export declare const updateWorkflowSchema: z.ZodEffects<z.ZodObject<{
     limits: z.ZodOptional<z.ZodNullable<z.ZodType<Json, z.ZodTypeDef, Json>>>;
 }, "strict", z.ZodTypeAny, {
     name?: string | null | undefined;
-    script?: string | undefined;
     compiled?: Json | undefined;
+    script?: string | undefined;
     allowlist?: Json | undefined;
     limits?: Json | undefined;
 }, {
     name?: string | null | undefined;
-    script?: string | undefined;
     compiled?: Json | undefined;
+    script?: string | undefined;
     allowlist?: Json | undefined;
     limits?: Json | undefined;
 }>, {
     name?: string | null | undefined;
-    script?: string | undefined;
     compiled?: Json | undefined;
+    script?: string | undefined;
     allowlist?: Json | undefined;
     limits?: Json | undefined;
 }, {
     name?: string | null | undefined;
-    script?: string | undefined;
     compiled?: Json | undefined;
+    script?: string | undefined;
     allowlist?: Json | undefined;
     limits?: Json | undefined;
 }>;
@@ -230,6 +235,16 @@ export declare const listRunsSchema: z.ZodObject<{
     limit?: number | undefined;
     offset?: number | undefined;
 }>;
+export declare const runAutomationNowSchema: z.ZodObject<{
+    input: z.ZodOptional<z.ZodType<Json, z.ZodTypeDef, Json>>;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    input?: Json | undefined;
+    idempotencyKey?: string | undefined;
+}, {
+    input?: Json | undefined;
+    idempotencyKey?: string | undefined;
+}>;
 export declare function parseCreateAutomation(value: unknown): CreateAutomation;
 export declare function parseUpdateAutomation(value: unknown): UpdateAutomation;
 export declare function parseListAutomations(value: unknown): ListAutomations;
@@ -241,4 +256,5 @@ export declare function parseCreateWorkflow(value: unknown): CreateWorkflow;
 export declare function parseUpdateWorkflow(value: unknown): UpdateWorkflow;
 export declare function parsePageQuery(value: unknown): PageQuery;
 export declare function parseListRuns(value: unknown): ListRuns;
+export declare function parseRunAutomationNow(value: unknown): RunAutomationNow;
 export declare function parse<T>(schema: z.ZodType<T>, value: unknown): T;

package/dist/src/schema.js

@@ -1,5 +1,6 @@
 import { z } from 'zod/v3';
 import { ValidationError } from './errors.js';
+import { compiledAutomationPlan } from './plan.js';
 import { IDENTIFIER } from './validation.js';
 const maxPageSize = 100;
 const identifierMessage = 'Identifier is invalid';
@@ -53,13 +54,14 @@ export const createWebhookTriggerSchema = z.object({
     id: identifierSchema.optional(),
     source: text(200, 'Webhook source').optional(),
     event: text(200, 'Webhook event').optional(),
-    secret: z.string().min(16, 'Webhook secret must be at least 16 characters').max(10_000, 'Webhook secret is too long'),
+    secret: z.string().min(16, 'Webhook secret must be at least 16 characters').max(10_000, 'Webhook secret is too long').optional(),
     enabled: z.boolean().optional(),
 }).strict();
 export const updateWebhookTriggerSchema = z.object({
     source: text(200, 'Webhook source').optional(),
     event: text(200, 'Webhook event').optional(),
-    secret: z.string().min(16, 'Webhook secret must be at least 16 characters').max(10_000, 'Webhook secret is too long').optional(),
+    secret: z.string().min(16, 'Webhook secret must be at least 16 characters').max(10_000, 'Webhook secret is too long').nullable().optional(),
+    rotateUrl: z.boolean().optional(),
     enabled: z.boolean().optional(),
 }).strict().refine((patch) => Object.keys(patch).length > 0, 'Webhook trigger update must include a change');
 export const createWorkflowSchema = z.object({
@@ -80,6 +82,10 @@ export const updateWorkflowSchema = z.object({
 export const listRunsSchema = pageQuerySchema.extend({
     status: z.enum(['pending', 'sent', 'running', 'completed', 'failed']).optional(),
 }).strict();
+export const runAutomationNowSchema = z.object({
+    input: jsonSchema.optional(),
+    idempotencyKey: z.string().min(1).max(500).optional(),
+}).strict();
 export function parseCreateAutomation(value) {
     return parse(createAutomationSchema, value);
 }
@@ -102,10 +108,16 @@ export function parseUpdateWebhookTrigger(value) {
     return parse(updateWebhookTriggerSchema, value);
 }
 export function parseCreateWorkflow(value) {
-    return parse(createWorkflowSchema, value);
+    const workflow = parse(createWorkflowSchema, value);
+    if (workflow.compiled !== undefined)
+        validateCompiledPlan(workflow.compiled);
+    return workflow;
 }
 export function parseUpdateWorkflow(value) {
-    return parse(updateWorkflowSchema, value);
+    const workflow = parse(updateWorkflowSchema, value);
+    if (workflow.compiled !== undefined && workflow.compiled !== null)
+        validateCompiledPlan(workflow.compiled);
+    return workflow;
 }
 export function parsePageQuery(value) {
     return parse(pageQuerySchema, value);
@@ -113,9 +125,20 @@ export function parsePageQuery(value) {
 export function parseListRuns(value) {
     return parse(listRunsSchema, value);
 }
+export function parseRunAutomationNow(value) {
+    return parse(runAutomationNowSchema, value);
+}
 export function parse(schema, value) {
     const result = schema.safeParse(value);
     if (result.success)
         return result.data;
     throw new ValidationError(result.error.issues[0]?.message || 'Input is invalid');
 }
+function validateCompiledPlan(value) {
+    try {
+        compiledAutomationPlan(value);
+    }
+    catch (error) {
+        throw new ValidationError(error instanceof Error ? error.message : String(error));
+    }
+}

package/dist/src/supabase-crud/mappers.d.ts

@@ -1,8 +1,9 @@
-import type { Automation, AutomationRun, Page, PageQuery, ScheduleTrigger, WebhookTrigger, Workflow } from '../contract.js';
+import type { Automation, AutomationRun, Page, PageQuery, ScheduleTrigger, Workflow } from '../contract.js';
+import type { WebhookTriggerRecord } from '../crud/repository.js';
 import type { AutomationRow, PageResult, RunRow, TriggerRow, WorkflowRow } from './rows.js';
 export declare function automation(row: AutomationRow): Automation;
 export declare function schedule(row: TriggerRow): ScheduleTrigger;
-export declare function webhook(row: TriggerRow): WebhookTrigger;
+export declare function webhook(row: TriggerRow): WebhookTriggerRecord;
 export declare function workflow(row: WorkflowRow): Workflow;
 export declare function run(row: RunRow): AutomationRun;
 export declare function paged<T, U>(result: PageResult<T>, mapper: (row: T) => U, query: Required<PageQuery>): Page<U>;

package/dist/src/supabase-crud/mappers.js

@@ -25,6 +25,8 @@ export function schedule(row) {
     };
 }
 export function webhook(row) {
+    if (!row.endpoint_id)
+        throw new Error('Webhook trigger is missing its endpoint id');
     return {
         id: row.id,
         automationId: row.automation_id,
@@ -32,6 +34,7 @@ export function webhook(row) {
         enabled: row.enabled,
         source: row.source,
         event: row.event,
+        endpointId: row.endpoint_id,
         secretConfigured: row.secret_configured,
         createdAt: timestamp(row.created_at),
         updatedAt: timestamp(row.updated_at),
@@ -58,6 +61,8 @@ export function run(row) {
         workflowId: row.workflow_id,
         targetId: row.target_id,
         status: row.status,
+        attempts: row.attempts,
+        ...(row.retry_at ? { retryAt: timestamp(row.retry_at) } : {}),
         input: row.input,
         createdAt: timestamp(row.created_at),
         ...(row.sent_at ? { sentAt: timestamp(row.sent_at) } : {}),

package/dist/src/supabase-crud/rows.d.ts

@@ -20,6 +20,7 @@ export type TriggerRow = {
     remaining_occurrences: number | null;
     source: string | null;
     event: string | null;
+    endpoint_id: string | null;
     secret_configured: boolean;
     created_at: Date | string;
     updated_at: Date | string;
@@ -42,6 +43,8 @@ export type RunRow = {
     workflow_id: string;
     target_id: string;
     status: AutomationRun['status'];
+    attempts: number;
+    retry_at: Date | string | null;
     input: AutomationRun['input'];
     created_at: Date | string;
     sent_at: Date | string | null;

package/dist/src/supabase-crud/workflow-runs.d.ts

@@ -1,5 +1,5 @@
 import type { AutomationCrudRepository } from '../crud.js';
 import { type SupabaseRpcClient } from './rpc.js';
-type Operations = Pick<AutomationCrudRepository, 'createWorkflow' | 'getWorkflow' | 'updateWorkflow' | 'deleteWorkflow' | 'listRuns' | 'getRun'>;
+type Operations = Pick<AutomationCrudRepository, 'createWorkflow' | 'getWorkflow' | 'updateWorkflow' | 'deleteWorkflow' | 'listRuns' | 'getRun' | 'runAutomationNow'>;
 export declare function workflowRunRepository(client: SupabaseRpcClient): Operations;
 export {};

package/dist/src/supabase-crud/workflow-runs.js

@@ -37,5 +37,15 @@ export function workflowRunRepository(client) {
             });
             return row ? run(row) : null;
         },
+        runAutomationNow: async (userId, automationId, input, idempotencyKey, now) => {
+            const rows = await call(client, 'enqueue_amalgm_manual_run', {
+                p_user_id: userId,
+                p_automation_id: automationId,
+                p_input: input,
+                p_idempotency_key: idempotencyKey,
+                p_now: now.toISOString(),
+            });
+            return rows[0] ? run(rows[0]) : null;
+        },
     };
 }

package/dist/src/supabase-machine.js

@@ -43,6 +43,7 @@ function run(row) {
         input: row.input,
         status: row.status,
         attempts: row.attempts,
+        ...(row.retry_at ? { retryAt: timestamp(row.retry_at) } : {}),
         leaseToken: row.lease_token,
         leaseExpiresAt: timestamp(row.lease_expires_at),
         createdAt: timestamp(row.created_at),
@@ -56,6 +57,7 @@ function run(row) {
 function update(value) {
     return {
         status: value.status,
+        ...(value.retryAt === undefined ? {} : { retryAt: value.retryAt }),
         ...(value.output === undefined ? {} : { output: value.output }),
         ...(value.error === undefined ? {} : { error: value.error }),
     };

package/dist/src/supabase-store.d.ts

@@ -1,4 +1,4 @@
-import type { AutomationStore, AutomationTarget, AutomationRun, DueCronTrigger, RunInput, RunUpdate, StoredEventTrigger } from './types.js';
+import type { AutomationStore, AutomationRun, DueCronTrigger, RunInput, StoredEventTrigger } from './types.js';
 export interface SupabaseRpcClient {
     rpc(functionName: string, arguments_: Record<string, unknown>): PromiseLike<{
         data: unknown;
@@ -11,13 +11,10 @@ export declare class SupabaseStore implements AutomationStore {
     #private;
     readonly client: SupabaseRpcClient;
     constructor(client: SupabaseRpcClient);
-    eventTriggers(target: AutomationTarget): Promise<StoredEventTrigger[]>;
+    eventTrigger(endpointId: string): Promise<StoredEventTrigger | null>;
     dueCronTriggers(now: Date): Promise<DueCronTrigger[]>;
     enqueueEvent(trigger: StoredEventTrigger, input: Extract<RunInput, {
         kind: 'event';
-    }>, now: Date): Promise<AutomationRun | null>;
+    }>, now: Date, deliveryKey: string | null): Promise<AutomationRun | null>;
     enqueueCron(trigger: DueCronTrigger, nextRunAt: string, now: Date): Promise<AutomationRun | null>;
-    pendingRuns(target: AutomationTarget): Promise<AutomationRun[]>;
-    markSent(runId: string, target: AutomationTarget, now: Date): Promise<boolean>;
-    updateRun(target: AutomationTarget, runId: string, update: RunUpdate): Promise<AutomationRun | null>;
 }

package/dist/src/supabase-store.js

@@ -22,13 +22,14 @@ export class SupabaseStore {
     constructor(client) {
         this.client = client;
     }
-    async eventTriggers(target) {
-        const rows = await this.#call('list_amalgm_event_triggers', {
-            p_user_id: target.userId,
-            p_target_id: target.targetId,
+    async eventTrigger(endpointId) {
+        const rows = await this.#call('resolve_amalgm_webhook', {
+            p_endpoint_id: endpointId,
         });
-        return rows.map((row) => ({
+        const row = rows[0];
+        return row ? {
             kind: 'event',
+            endpointId: row.endpoint_id,
             userId: row.user_id,
             automationId: row.automation_id,
             triggerId: row.trigger_id,
@@ -36,7 +37,7 @@ export class SupabaseStore {
             source: row.source,
             event: row.event,
             secret: row.secret,
-        }));
+        } : null;
     }
     async dueCronTriggers(now) {
         const rows = await this.#call('list_due_amalgm_crons', { p_now: now.toISOString() });
@@ -52,46 +53,24 @@ export class SupabaseStore {
             ...(row.remaining_occurrences === null ? {} : { remainingOccurrences: row.remaining_occurrences }),
         }));
     }
-    enqueueEvent(trigger, input, now) {
-        return this.#enqueue(trigger, input, now, null);
+    enqueueEvent(trigger, input, now, deliveryKey) {
+        return this.#enqueue(trigger, input, now, null, deliveryKey);
     }
     enqueueCron(trigger, nextRunAt, now) {
         return this.#enqueue(trigger, {
             kind: 'cron',
             scheduledFor: trigger.nextRunAt,
-        }, now, nextRunAt);
-    }
-    async pendingRuns(target) {
-        const rows = await this.#call('list_amalgm_pending_runs', {
-            p_user_id: target.userId,
-            p_target_id: target.targetId,
-        });
-        return rows.map(automationRun);
-    }
-    markSent(runId, target, now) {
-        return this.#call('mark_amalgm_run_sent', {
-            p_run_id: runId,
-            p_user_id: target.userId,
-            p_target_id: target.targetId,
-            p_now: now.toISOString(),
-        });
-    }
-    async updateRun(target, runId, update) {
-        const rows = await this.#call('update_amalgm_run', {
-            p_run_id: runId,
-            p_user_id: target.userId,
-            p_target_id: target.targetId,
-            p_update: update,
-        });
-        return rows[0] ? automationRun(rows[0]) : null;
+        }, now, nextRunAt, null);
     }
-    async #enqueue(trigger, input, now, nextRunAt) {
+    async #enqueue(trigger, input, now, nextRunAt, deliveryKey) {
         const rows = await this.#call('enqueue_amalgm_run', {
             p_kind: trigger.kind,
             p_user_id: trigger.userId,
             p_automation_id: trigger.automationId,
             p_trigger_id: trigger.triggerId,
             p_target_id: trigger.targetId,
+            p_endpoint_id: trigger.kind === 'event' ? trigger.endpointId : null,
+            p_delivery_key: deliveryKey,
             p_expected_next_run_at: trigger.kind === 'cron' ? trigger.nextRunAt : null,
             p_next_run_at: nextRunAt,
             p_input: input,

package/dist/src/tool-surface.d.ts

@@ -0,0 +1,47 @@
+import type { Automation, AutomationCrud, AutomationRun, CreateAutomation, CreateScheduleTrigger, CreateWebhookTrigger, CreateWorkflow, ListAutomations, ListRuns, Page, Trigger, UpdateAutomation, UpdateScheduleTrigger, UpdateWebhookTrigger, UpdateWorkflow, Workflow } from './contract.js';
+export interface AutomationView {
+    automation: Automation;
+    triggers: Trigger[];
+    workflow: Workflow | null;
+    runs?: Page<AutomationRun>;
+}
+export interface CreateAutomationDefinition extends CreateAutomation {
+    schedules?: CreateScheduleTrigger[];
+    webhooks?: CreateWebhookTrigger[];
+    workflow?: CreateWorkflow;
+}
+interface Changes<Create extends {
+    id?: string;
+}, Update> {
+    create?: Create[];
+    update?: Array<{
+        id: string;
+        patch: Update;
+    }>;
+    delete?: string[];
+}
+export type WorkflowChange = {
+    create: CreateWorkflow;
+} | {
+    update: UpdateWorkflow;
+} | {
+    delete: true;
+};
+export interface UpdateAutomationDefinition {
+    patch?: UpdateAutomation;
+    schedules?: Changes<CreateScheduleTrigger, UpdateScheduleTrigger>;
+    webhooks?: Changes<CreateWebhookTrigger, UpdateWebhookTrigger>;
+    workflow?: WorkflowChange;
+}
+export interface AutomationToolSurface {
+    create(input: CreateAutomationDefinition): Promise<AutomationView>;
+    list(query?: ListAutomations): Promise<Page<Automation>>;
+    get(automationId: string, runs?: false | ListRuns): Promise<AutomationView>;
+    update(automationId: string, input: UpdateAutomationDefinition): Promise<AutomationView>;
+    delete(automationId: string): Promise<{
+        deleted: string;
+    }>;
+    runNow(automationId: string, input?: Parameters<AutomationCrud['runs']['runNow']>[1]): Promise<AutomationRun>;
+}
+export declare function createAutomationToolSurface(sdk: AutomationCrud): AutomationToolSurface;
+export {};