@pellux/goodvibes-sdk 0.18.14 → 0.18.16

package/dist/_internal/platform/automation/delivery-manager.js

@@ -0,0 +1,306 @@
+import { randomUUID } from 'node:crypto';
+import { ChannelDeliveryRouter, RouteBindingManager } from '../channels/index.js';
+import { ServiceRegistry } from '../config/service-registry.js';
+import { createDomainDispatch } from '../runtime/store/index.js';
+import { emitDeliveryFailed, emitDeliveryQueued, emitDeliveryStarted, emitDeliverySucceeded, } from '../runtime/emitters/index.js';
+import { classifyDeliveryError } from '@pellux/goodvibes-sdk/platform/integrations/delivery';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function calculateRetryDelay(baseDelayMs, attempt, strategy, maxDelayMs, jitterMs) {
+    const multiplier = strategy === 'fixed' ? 1 : strategy === 'linear' ? attempt : Math.pow(2, attempt - 1);
+    const base = baseDelayMs * multiplier;
+    const jitter = jitterMs ? Math.floor(Math.random() * jitterMs) : 0;
+    return Math.min(base + jitter, maxDelayMs ?? Number.MAX_SAFE_INTEGER);
+}
+function buildDeliveryMessage(job, run) {
+    const lines = [
+        `Automation: ${job.name}`,
+        `Run: ${run.id}`,
+        `Status: ${run.status}`,
+    ];
+    if (run.error)
+        lines.push(`Error: ${run.error}`);
+    if (job.delivery.includeSummary) {
+        const content = typeof run.result === 'string'
+            ? run.result
+            : run.result !== undefined
+                ? JSON.stringify(run.result, null, 2)
+                : '';
+        if (content) {
+            lines.push('');
+            lines.push(content.length > 3500 ? `${content.slice(0, 3500)}...` : content);
+        }
+    }
+    return lines.join('\n');
+}
+function toDeliveryKind(surfaceKind) {
+    return surfaceKind === 'webhook' ? 'callback' : 'notification';
+}
+function toDeliverySurfaceKind(surfaceKind) {
+    return surfaceKind ?? 'webhook';
+}
+function extractArtifactReferences(result) {
+    if (!result || typeof result !== 'object')
+        return [];
+    const record = result;
+    const rawItems = [
+        ...(Array.isArray(record.artifacts) ? record.artifacts : []),
+        ...(Array.isArray(record.attachments) ? record.attachments : []),
+        ...(Array.isArray(record.artifactIds) ? record.artifactIds.map((artifactId) => ({ artifactId })) : []),
+    ];
+    const references = [];
+    for (const entry of rawItems) {
+        if (typeof entry === 'string' && entry.trim().length > 0) {
+            references.push({ artifactId: entry.trim() });
+            continue;
+        }
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const candidate = entry;
+        const artifactId = typeof candidate.artifactId === 'string'
+            ? candidate.artifactId
+            : typeof candidate.id === 'string'
+                ? candidate.id
+                : '';
+        if (!artifactId)
+            continue;
+        references.push({
+            artifactId,
+            ...(typeof candidate.label === 'string' ? { label: candidate.label } : {}),
+            ...(typeof candidate.metadata === 'object' && candidate.metadata !== null
+                ? { metadata: candidate.metadata }
+                : {}),
+        });
+    }
+    return references.filter((entry, index, values) => values.findIndex((candidate) => candidate.artifactId === entry.artifactId) === index);
+}
+export class AutomationDeliveryManager {
+    routeBindings;
+    deliveryRouter;
+    runtimeDispatch = null;
+    runtimeBus = null;
+    constructor(config) {
+        this.routeBindings = config.routeBindings;
+        if (config.deliveryRouter) {
+            this.deliveryRouter = config.deliveryRouter;
+        }
+        else {
+            if (!config.serviceRegistry || !config.configManager || !config.artifactStore) {
+                throw new Error('AutomationDeliveryManager requires serviceRegistry, configManager, and artifactStore when no deliveryRouter is provided.');
+            }
+            this.deliveryRouter = new ChannelDeliveryRouter({
+                configManager: config.configManager,
+                serviceRegistry: config.serviceRegistry,
+                artifactStore: config.artifactStore,
+            });
+        }
+        if (config.runtimeStore)
+            this.runtimeDispatch = createDomainDispatch(config.runtimeStore);
+        this.runtimeBus = config.runtimeBus ?? null;
+    }
+    attachRuntime(config) {
+        if (config.runtimeStore) {
+            this.runtimeDispatch = createDomainDispatch(config.runtimeStore);
+        }
+        if (config.runtimeBus) {
+            this.runtimeBus = config.runtimeBus;
+        }
+    }
+    getDeliveryRouter() {
+        return this.deliveryRouter;
+    }
+    setControlPlaneGateway(gateway) {
+        this.deliveryRouter.setControlPlaneGateway(gateway);
+    }
+    async deliverJobRun(job, run) {
+        if (job.delivery.mode === 'none')
+            return [];
+        await this.routeBindings.start();
+        const body = buildDeliveryMessage(job, run);
+        const primaryTargets = this.resolveTargets(job.delivery.targets.length > 0
+            ? [...job.delivery.targets]
+            : job.delivery.replyToRouteId
+                ? [{ kind: 'surface', routeId: job.delivery.replyToRouteId }]
+                : []);
+        const attempts = await this.deliverText(job, run, body, primaryTargets.map((entry) => entry.target));
+        const needsFallback = attempts.length === 0 || attempts.every((attempt) => attempt.status === 'failed' || attempt.status === 'dead_lettered');
+        if (!needsFallback || job.delivery.fallbackTargets.length === 0) {
+            return attempts;
+        }
+        const fallbackAttempts = await this.deliverText(job, run, body, job.delivery.fallbackTargets);
+        return [...attempts, ...fallbackAttempts];
+    }
+    async deliverText(job, run, body, targets) {
+        await this.routeBindings.start();
+        const resolvedTargets = this.resolveTargets(targets);
+        if (resolvedTargets.length === 0)
+            return [];
+        const attempts = [];
+        for (const resolved of resolvedTargets) {
+            const target = resolved.target;
+            const deliveryId = `delivery-${randomUUID().slice(0, 8)}`;
+            const startedAt = Date.now();
+            let attempt = {
+                id: deliveryId,
+                runId: run.id,
+                jobId: job.id,
+                target,
+                status: 'pending',
+            };
+            attempts.push(attempt);
+            this.syncAttempt(attempt, run, 'queued');
+            const retryPolicy = job.failure.retryPolicy;
+            let attemptIndex = 0;
+            let lastError = '';
+            while (attemptIndex < Math.max(1, retryPolicy.maxAttempts)) {
+                attemptIndex += 1;
+                attempt = {
+                    ...attempt,
+                    status: 'sending',
+                    startedAt: Date.now(),
+                    error: undefined,
+                };
+                this.syncAttempt(attempt, run, 'started');
+                try {
+                    const responseId = await this.sendTarget(resolved, body, job, run);
+                    if (resolved.binding?.id && responseId) {
+                        await this.routeBindings.captureReplyTarget(resolved.binding.id, responseId, resolved.binding.threadId);
+                    }
+                    attempt = {
+                        ...attempt,
+                        status: 'sent',
+                        endedAt: Date.now(),
+                        responseId: responseId ?? target.address ?? target.routeId ?? target.label ?? target.surfaceKind ?? 'delivered',
+                    };
+                    attempts[attempts.length - 1] = attempt;
+                    this.syncAttempt(attempt, run, 'succeeded');
+                    lastError = '';
+                    break;
+                }
+                catch (error) {
+                    lastError = summarizeError(error);
+                    const retryable = classifyDeliveryError(error) === 'retryable';
+                    const lastTry = attemptIndex >= Math.max(1, retryPolicy.maxAttempts);
+                    if (!retryable || lastTry) {
+                        attempt = {
+                            ...attempt,
+                            status: retryable ? 'dead_lettered' : 'failed',
+                            endedAt: Date.now(),
+                            error: lastError,
+                        };
+                        attempts[attempts.length - 1] = attempt;
+                        this.syncAttempt(attempt, run, 'failed', lastError, retryable);
+                        break;
+                    }
+                    const delayMs = calculateRetryDelay(retryPolicy.delayMs, attemptIndex, retryPolicy.strategy, retryPolicy.maxDelayMs, retryPolicy.jitterMs);
+                    await sleep(delayMs);
+                }
+            }
+            if (lastError && attempts[attempts.length - 1]?.status === 'sending') {
+                const failedAttempt = {
+                    ...attempts[attempts.length - 1],
+                    status: 'failed',
+                    endedAt: Date.now(),
+                    error: lastError,
+                };
+                attempts[attempts.length - 1] = failedAttempt;
+                this.syncAttempt(failedAttempt, run, 'failed', lastError, true);
+            }
+        }
+        return attempts;
+    }
+    resolveTargets(targets) {
+        return targets.map((target) => {
+            if (!target.routeId)
+                return target;
+            const binding = this.routeBindings.getBinding(target.routeId);
+            if (!binding)
+                return { target };
+            return {
+                target: {
+                    ...target,
+                    surfaceKind: target.surfaceKind ?? binding.surfaceKind,
+                    address: target.address
+                        ?? (typeof binding.metadata.responseUrl === 'string' ? binding.metadata.responseUrl
+                            : typeof binding.metadata.callbackUrl === 'string' ? binding.metadata.callbackUrl
+                                : binding.channelId ?? binding.externalId),
+                    label: target.label ?? binding.title,
+                },
+                binding,
+            };
+        }).map((entry) => ('target' in entry ? entry : { target: entry }));
+    }
+    async sendTarget(resolved, body, job, run) {
+        return this.deliveryRouter.deliver({
+            target: resolved.target,
+            body,
+            title: job.name,
+            jobId: job.id,
+            runId: run.id,
+            status: run.status,
+            includeLinks: job.delivery.includeLinks,
+            ...(run.result !== undefined ? { attachments: extractArtifactReferences(run.result) } : {}),
+            ...(run.agentId ? { agentId: run.agentId } : {}),
+            ...(resolved.binding ? { binding: resolved.binding } : {}),
+        });
+    }
+    syncAttempt(attempt, run, phase, error, retryable = false) {
+        this.runtimeDispatch?.syncDeliveryAttempt(attempt, `deliveries.${phase}`);
+        if (!this.runtimeBus)
+            return;
+        const surfaceKind = toDeliverySurfaceKind(attempt.target.surfaceKind);
+        const targetId = attempt.target.address ?? attempt.target.routeId ?? 'unknown';
+        const ctx = {
+            sessionId: run.target.sessionId ?? 'automation',
+            source: 'automation-delivery-manager',
+            traceId: attempt.id,
+        };
+        if (phase === 'queued') {
+            emitDeliveryQueued(this.runtimeBus, ctx, {
+                deliveryId: attempt.id,
+                jobId: attempt.jobId,
+                runId: attempt.runId,
+                surfaceKind,
+                targetId,
+                deliveryKind: toDeliveryKind(surfaceKind),
+            });
+            return;
+        }
+        if (phase === 'started') {
+            emitDeliveryStarted(this.runtimeBus, ctx, {
+                deliveryId: attempt.id,
+                jobId: attempt.jobId,
+                runId: attempt.runId,
+                surfaceKind,
+                targetId,
+                startedAt: attempt.startedAt ?? Date.now(),
+            });
+            return;
+        }
+        if (phase === 'succeeded') {
+            emitDeliverySucceeded(this.runtimeBus, ctx, {
+                deliveryId: attempt.id,
+                jobId: attempt.jobId,
+                runId: attempt.runId,
+                surfaceKind,
+                targetId,
+                completedAt: attempt.endedAt ?? Date.now(),
+                durationMs: Math.max(0, (attempt.endedAt ?? Date.now()) - (attempt.startedAt ?? Date.now())),
+                statusCode: 200,
+            });
+            return;
+        }
+        emitDeliveryFailed(this.runtimeBus, ctx, {
+            deliveryId: attempt.id,
+            jobId: attempt.jobId,
+            runId: attempt.runId,
+            surfaceKind,
+            targetId,
+            failedAt: attempt.endedAt ?? Date.now(),
+            error: error ?? attempt.error ?? 'delivery failed',
+            retryable,
+        });
+    }
+}

package/dist/_internal/platform/automation/index.d.ts

@@ -0,0 +1,21 @@
+export type { AutomationJobStatus, AutomationRunStatus, AutomationRunTrigger, AutomationSurfaceKind, AutomationRouteKind, AutomationSourceKind, AutomationExecutionKind, AutomationDeliveryKind, AutomationEntityBase, } from '@pellux/goodvibes-sdk/platform/automation/types';
+export type { AutomationAtSchedule, AutomationEverySchedule, AutomationCronSchedule, AutomationScheduleDefinition, AutomationScheduleKind, } from '@pellux/goodvibes-sdk/platform/automation/schedules';
+export { DEFAULT_TOP_OF_HOUR_STAGGER_MS, parseEveryInterval, formatEveryInterval, validateSchedule, isRecurringTopOfHourCronExpression, normalizeCronStaggerMs, resolveDefaultCronStaggerMs, resolveAutomationCronStaggerMs, resolveStableAutomationCronOffsetMs, normalizeAtSchedule, normalizeEverySchedule, normalizeCronSchedule, getNextAutomationOccurrence, isAutomationDue, } from '@pellux/goodvibes-sdk/platform/automation/schedules';
+export type { AutomationExecutionPolicy, AutomationSessionTarget, AutomationSessionTargetKind, AutomationSandboxMode, AutomationWakeMode, AutomationExternalContentSource, AutomationExternalContentSourceKind, } from '@pellux/goodvibes-sdk/platform/automation/session-targets';
+export type { AutomationDeliveryMode, AutomationDeliveryTarget, AutomationDeliveryPolicy, AutomationDeliveryAttempt } from '@pellux/goodvibes-sdk/platform/automation/delivery';
+export type { AutomationFailureAction, AutomationRetryStrategy, AutomationRetryPolicy, AutomationFailurePolicy, AutomationFailureRecord } from '@pellux/goodvibes-sdk/platform/automation/failures';
+export type { AutomationSourceRecord, AutomationSourceSnapshot } from '@pellux/goodvibes-sdk/platform/automation/sources';
+export type { AutomationRouteBinding, AutomationRouteResolution } from '@pellux/goodvibes-sdk/platform/automation/routes';
+export type { AutomationJob } from '@pellux/goodvibes-sdk/platform/automation/jobs';
+export type { AutomationRun, AutomationRunSummary, AutomationRunTelemetry, AutomationRunUsageSummary, } from '@pellux/goodvibes-sdk/platform/automation/runs';
+export type { LegacySchedulerSnapshot } from '@pellux/goodvibes-sdk/platform/automation/migration';
+export { migrateLegacySchedules } from '@pellux/goodvibes-sdk/platform/automation/migration';
+export { AutomationDeliveryManager } from './delivery-manager.js';
+export { AutomationService } from './service.js';
+export { AutomationJobStore } from '@pellux/goodvibes-sdk/platform/automation/store/jobs';
+export { AutomationRunStore } from '@pellux/goodvibes-sdk/platform/automation/store/runs';
+export { AutomationRouteStore } from '@pellux/goodvibes-sdk/platform/automation/store/routes';
+export { AutomationSourceStore } from '@pellux/goodvibes-sdk/platform/automation/store/sources';
+export type { AutomationHeartbeatResult, AutomationHeartbeatWake, CreateAutomationJobInput, UpdateAutomationJobInput, } from './manager.js';
+export { AutomationManager } from './manager.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/automation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/automation/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,EACnB,oBAAoB,EACpB,uBAAuB,EACvB,sBAAsB,EACtB,oBAAoB,GACrB,MAAM,iDAAiD,CAAC;AAEzD,YAAY,EACV,oBAAoB,EACpB,uBAAuB,EACvB,sBAAsB,EACtB,4BAA4B,EAC5B,sBAAsB,GACvB,MAAM,qDAAqD,CAAC;AAC7D,OAAO,EACL,8BAA8B,EAC9B,kBAAkB,EAClB,mBAAmB,EACnB,gBAAgB,EAChB,kCAAkC,EAClC,sBAAsB,EACtB,2BAA2B,EAC3B,8BAA8B,EAC9B,mCAAmC,EACnC,mBAAmB,EACnB,sBAAsB,EACtB,qBAAqB,EACrB,2BAA2B,EAC3B,eAAe,GAChB,MAAM,qDAAqD,CAAC;AAE7D,YAAY,EACV,yBAAyB,EACzB,uBAAuB,EACvB,2BAA2B,EAC3B,qBAAqB,EACrB,kBAAkB,EAClB,+BAA+B,EAC/B,mCAAmC,GACpC,MAAM,2DAA2D,CAAC;AACnE,YAAY,EAAE,sBAAsB,EAAE,wBAAwB,EAAE,wBAAwB,EAAE,yBAAyB,EAAE,MAAM,oDAAoD,CAAC;AAChL,YAAY,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,MAAM,oDAAoD,CAAC;AACpM,YAAY,EAAE,sBAAsB,EAAE,wBAAwB,EAAE,MAAM,mDAAmD,CAAC;AAC1H,YAAY,EAAE,sBAAsB,EAAE,yBAAyB,EAAE,MAAM,kDAAkD,CAAC;AAC1H,YAAY,EAAE,aAAa,EAAE,MAAM,gDAAgD,CAAC;AACpF,YAAY,EACV,aAAa,EACb,oBAAoB,EACpB,sBAAsB,EACtB,yBAAyB,GAC1B,MAAM,gDAAgD,CAAC;AAExD,YAAY,EAAE,uBAAuB,EAAE,MAAM,qDAAqD,CAAC;AACnG,OAAO,EAAE,sBAAsB,EAAE,MAAM,qDAAqD,CAAC;AAC7F,OAAO,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAC1F,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAC1F,OAAO,EAAE,oBAAoB,EAAE,MAAM,wDAAwD,CAAC;AAC9F,OAAO,EAAE,qBAAqB,EAAE,MAAM,yDAAyD,CAAC;AAChG,YAAY,EACV,yBAAyB,EACzB,uBAAuB,EACvB,wBAAwB,EACxB,wBAAwB,GACzB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC"}

package/dist/_internal/platform/automation/index.js

@@ -0,0 +1,9 @@
+export { DEFAULT_TOP_OF_HOUR_STAGGER_MS, parseEveryInterval, formatEveryInterval, validateSchedule, isRecurringTopOfHourCronExpression, normalizeCronStaggerMs, resolveDefaultCronStaggerMs, resolveAutomationCronStaggerMs, resolveStableAutomationCronOffsetMs, normalizeAtSchedule, normalizeEverySchedule, normalizeCronSchedule, getNextAutomationOccurrence, isAutomationDue, } from '@pellux/goodvibes-sdk/platform/automation/schedules';
+export { migrateLegacySchedules } from '@pellux/goodvibes-sdk/platform/automation/migration';
+export { AutomationDeliveryManager } from './delivery-manager.js';
+export { AutomationService } from './service.js';
+export { AutomationJobStore } from '@pellux/goodvibes-sdk/platform/automation/store/jobs';
+export { AutomationRunStore } from '@pellux/goodvibes-sdk/platform/automation/store/runs';
+export { AutomationRouteStore } from '@pellux/goodvibes-sdk/platform/automation/store/routes';
+export { AutomationSourceStore } from '@pellux/goodvibes-sdk/platform/automation/store/sources';
+export { AutomationManager } from './manager.js';

package/dist/_internal/platform/automation/manager-runtime-delivery.d.ts

@@ -0,0 +1,25 @@
+import type { AutomationDeliveryManager } from './delivery-manager.js';
+import type { AutomationJob } from '@pellux/goodvibes-sdk/platform/automation/jobs';
+import type { AutomationRun } from '@pellux/goodvibes-sdk/platform/automation/runs';
+interface AutomationFailureFollowUpContext {
+    readonly jobs: Map<string, AutomationJob>;
+    readonly retryTimers: Map<string, ReturnType<typeof setTimeout>>;
+    readonly deliveryManager: AutomationDeliveryManager | null;
+    readonly activeRunCount: () => number;
+    readonly maxConcurrentRuns: () => number;
+    readonly executeJob: (job: AutomationJob, trigger: 'scheduled', dueRun: boolean, attempt?: number) => Promise<AutomationRun>;
+    readonly saveJobs: () => Promise<void>;
+    readonly scheduleJob: (job: AutomationJob) => void;
+}
+interface AutomationRunDeliveryContext {
+    readonly runs: Map<string, AutomationRun>;
+    readonly deliveryInFlight: Set<string>;
+    readonly deliveryManager: AutomationDeliveryManager | null;
+    readonly syncRunToRuntime: (run: AutomationRun, source: string) => void;
+    readonly saveRuns: () => Promise<void>;
+}
+export declare function scheduleAutomationFailureFollowUp(context: AutomationFailureFollowUpContext, maybeDeliverFailureNotice: (job: AutomationJob, run: AutomationRun) => void, job: AutomationJob, run: AutomationRun): void;
+export declare function maybeDeliverAutomationFailureNotice(deliveryManager: AutomationDeliveryManager | null, job: AutomationJob, run: AutomationRun): void;
+export declare function maybeDeliverAutomationRun(context: AutomationRunDeliveryContext, job: AutomationJob, run: AutomationRun): void;
+export {};
+//# sourceMappingURL=manager-runtime-delivery.d.ts.map

package/dist/_internal/platform/automation/manager-runtime-delivery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager-runtime-delivery.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/automation/manager-runtime-delivery.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gDAAgD,CAAC;AACpF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gDAAgD,CAAC;AAGpF,UAAU,gCAAgC;IACxC,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAC1C,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC,CAAC;IACjE,QAAQ,CAAC,eAAe,EAAE,yBAAyB,GAAG,IAAI,CAAC;IAC3D,QAAQ,CAAC,cAAc,EAAE,MAAM,MAAM,CAAC;IACtC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,MAAM,CAAC;IACzC,QAAQ,CAAC,UAAU,EAAE,CAAC,GAAG,EAAE,aAAa,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC;IAC7H,QAAQ,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACvC,QAAQ,CAAC,WAAW,EAAE,CAAC,GAAG,EAAE,aAAa,KAAK,IAAI,CAAC;CACpD;AAED,UAAU,4BAA4B;IACpC,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAC1C,QAAQ,CAAC,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACvC,QAAQ,CAAC,eAAe,EAAE,yBAAyB,GAAG,IAAI,CAAC;IAC3D,QAAQ,CAAC,gBAAgB,EAAE,CAAC,GAAG,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACxE,QAAQ,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACxC;AAED,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,gCAAgC,EACzC,yBAAyB,EAAE,CAAC,GAAG,EAAE,aAAa,EAAE,GAAG,EAAE,aAAa,KAAK,IAAI,EAC3E,GAAG,EAAE,aAAa,EAClB,GAAG,EAAE,aAAa,GACjB,IAAI,CA2CN;AAED,wBAAgB,mCAAmC,CACjD,eAAe,EAAE,yBAAyB,GAAG,IAAI,EACjD,GAAG,EAAE,aAAa,EAClB,GAAG,EAAE,aAAa,GACjB,IAAI,CAsBN;AAED,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,4BAA4B,EACrC,GAAG,EAAE,aAAa,EAClB,GAAG,EAAE,aAAa,GACjB,IAAI,CA+BN"}

package/dist/_internal/platform/automation/manager-runtime-delivery.js

@@ -0,0 +1,109 @@
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+export function scheduleAutomationFailureFollowUp(context, maybeDeliverFailureNotice, job, run) {
+    maybeDeliverFailureNotice(job, run);
+    if (!job.enabled)
+        return;
+    if (job.failure.action === 'cooldown') {
+        const cooled = {
+            ...job,
+            nextRunAt: Date.now() + Math.max(1_000, job.failure.cooldownMs),
+            updatedAt: Date.now(),
+        };
+        context.jobs.set(job.id, cooled);
+        context.scheduleJob(cooled);
+        void context.saveJobs();
+        return;
+    }
+    const maxAttempts = Math.max(1, job.execution.maxAttempts ?? 1);
+    if (job.failure.action !== 'retry' || run.attempt >= maxAttempts) {
+        return;
+    }
+    const retryKey = `${job.id}:${run.id}`;
+    const existing = context.retryTimers.get(retryKey);
+    if (existing) {
+        clearTimeout(existing);
+    }
+    const timer = setTimeout(() => {
+        context.retryTimers.delete(retryKey);
+        const latestJob = context.jobs.get(job.id);
+        if (!latestJob?.enabled)
+            return;
+        if (context.activeRunCount() >= context.maxConcurrentRuns()) {
+            scheduleAutomationFailureFollowUp(context, maybeDeliverFailureNotice, latestJob, run);
+            return;
+        }
+        void context.executeJob(latestJob, 'scheduled', false, run.attempt + 1).catch((error) => {
+            logger.warn('AutomationManager: retry execution failed', {
+                jobId: latestJob.id,
+                runId: run.id,
+                attempt: run.attempt + 1,
+                error: summarizeError(error),
+            });
+        });
+    }, Math.max(1_000, job.failure.cooldownMs));
+    context.retryTimers.set(retryKey, timer);
+}
+export function maybeDeliverAutomationFailureNotice(deliveryManager, job, run) {
+    if (!deliveryManager)
+        return;
+    const routeIds = [job.failure.notifyRouteId, job.failure.deadLetterRouteId].filter((value) => typeof value === 'string' && value.length > 0);
+    if (routeIds.length === 0)
+        return;
+    const targets = routeIds.map((routeId) => ({
+        kind: 'surface',
+        routeId,
+    }));
+    const message = [
+        `Automation failure: ${job.name}`,
+        `Run: ${run.id}`,
+        `Status: ${run.status}`,
+        run.error ? `Error: ${run.error}` : null,
+        run.cancelledReason ? `Cancelled: ${run.cancelledReason}` : null,
+    ].filter((value) => typeof value === 'string' && value.length > 0).join('\n');
+    void deliveryManager.deliverText(job, run, message, targets).catch((error) => {
+        logger.warn('AutomationManager: failure notice delivery failed', {
+            jobId: job.id,
+            runId: run.id,
+            error: summarizeError(error),
+        });
+    });
+}
+export function maybeDeliverAutomationRun(context, job, run) {
+    if (!context.deliveryManager)
+        return;
+    if (job.delivery.mode === 'none')
+        return;
+    if (context.deliveryInFlight.has(run.id))
+        return;
+    if (run.deliveryIds.length > 0)
+        return;
+    context.deliveryInFlight.add(run.id);
+    void context.deliveryManager.deliverJobRun(job, run)
+        .then(async (deliveryAttempts) => {
+        if (deliveryAttempts.length === 0)
+            return;
+        const latest = context.runs.get(run.id);
+        if (!latest)
+            return;
+        const updated = {
+            ...latest,
+            deliveryIds: deliveryAttempts.map((attempt) => attempt.id),
+            deliveryAttempts,
+            updatedAt: Date.now(),
+        };
+        context.runs.set(updated.id, updated);
+        context.syncRunToRuntime(updated, 'automation.delivery');
+        await context.saveRuns();
+    })
+        .catch((error) => {
+        logger.warn('AutomationManager: delivery failed', {
+            runId: run.id,
+            jobId: job.id,
+            error: summarizeError(error),
+        });
+    })
+        .finally(() => {
+        context.deliveryInFlight.delete(run.id);
+    });
+}

package/dist/_internal/platform/automation/manager-runtime-events.d.ts

@@ -0,0 +1,11 @@
+import type { RuntimeEventBus } from '../runtime/events/index.js';
+import type { AutomationJob } from '@pellux/goodvibes-sdk/platform/automation/jobs';
+import type { AutomationRun } from '@pellux/goodvibes-sdk/platform/automation/runs';
+export declare function emitAutomationManagerJobCreated(runtimeBus: RuntimeEventBus | null, job: AutomationJob): void;
+export declare function emitAutomationManagerJobUpdated(runtimeBus: RuntimeEventBus | null, job: AutomationJob, changedFields: string[]): void;
+export declare function emitAutomationManagerJobAutoDisabled(runtimeBus: RuntimeEventBus | null, job: AutomationJob, reason: string): void;
+export declare function emitAutomationManagerRunQueued(runtimeBus: RuntimeEventBus | null, job: AutomationJob, run: AutomationRun): void;
+export declare function emitAutomationManagerRunStarted(runtimeBus: RuntimeEventBus | null, job: AutomationJob, run: AutomationRun): void;
+export declare function emitAutomationManagerRunCompleted(runtimeBus: RuntimeEventBus | null, job: AutomationJob, run: AutomationRun, outcome: 'success' | 'partial' | 'failed' | 'cancelled'): void;
+export declare function emitAutomationManagerRunFailed(runtimeBus: RuntimeEventBus | null, job: AutomationJob, run: AutomationRun, error: string, retryable: boolean): void;
+//# sourceMappingURL=manager-runtime-events.d.ts.map

package/dist/_internal/platform/automation/manager-runtime-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager-runtime-events.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/automation/manager-runtime-events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAalE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gDAAgD,CAAC;AACpF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gDAAgD,CAAC;AAUpF,wBAAgB,+BAA+B,CAAC,UAAU,EAAE,eAAe,GAAG,IAAI,EAAE,GAAG,EAAE,aAAa,GAAG,IAAI,CAQ5G;AAED,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,eAAe,GAAG,IAAI,EAClC,GAAG,EAAE,aAAa,EAClB,aAAa,EAAE,MAAM,EAAE,GACtB,IAAI,CAgBN;AAED,wBAAgB,oCAAoC,CAClD,UAAU,EAAE,eAAe,GAAG,IAAI,EAClC,GAAG,EAAE,aAAa,EAClB,MAAM,EAAE,MAAM,GACb,IAAI,CAON;AAED,wBAAgB,8BAA8B,CAC5C,UAAU,EAAE,eAAe,GAAG,IAAI,EAClC,GAAG,EAAE,aAAa,EAClB,GAAG,EAAE,aAAa,GACjB,IAAI,CAQN;AAED,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,eAAe,GAAG,IAAI,EAClC,GAAG,EAAE,aAAa,EAClB,GAAG,EAAE,aAAa,GACjB,IAAI,CAQN;AAED,wBAAgB,iCAAiC,CAC/C,UAAU,EAAE,eAAe,GAAG,IAAI,EAClC,GAAG,EAAE,aAAa,EAClB,GAAG,EAAE,aAAa,EAClB,OAAO,EAAE,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,WAAW,GACtD,IAAI,CAUN;AAED,wBAAgB,8BAA8B,CAC5C,UAAU,EAAE,eAAe,GAAG,IAAI,EAClC,GAAG,EAAE,aAAa,EAClB,GAAG,EAAE,aAAa,EAClB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,OAAO,GACjB,IAAI,CAUN"}

package/dist/_internal/platform/automation/manager-runtime-events.js

@@ -0,0 +1,90 @@
+import { emitAutomationJobAutoDisabled, emitAutomationJobCreated, emitAutomationJobDisabled, emitAutomationJobEnabled, emitAutomationJobUpdated, emitAutomationRunCompleted, emitAutomationRunFailed, emitAutomationRunQueued, emitAutomationRunStarted, } from '../runtime/emitters/index.js';
+function automationEmitterContext(traceId, sessionId) {
+    return {
+        sessionId: sessionId ?? 'automation',
+        source: 'automation-manager',
+        traceId,
+    };
+}
+export function emitAutomationManagerJobCreated(runtimeBus, job) {
+    if (!runtimeBus)
+        return;
+    emitAutomationJobCreated(runtimeBus, automationEmitterContext(job.id, job.execution.target.sessionId), {
+        jobId: job.id,
+        name: job.name,
+        scheduleKind: job.schedule.kind,
+        enabled: job.enabled,
+    });
+}
+export function emitAutomationManagerJobUpdated(runtimeBus, job, changedFields) {
+    if (!runtimeBus)
+        return;
+    emitAutomationJobUpdated(runtimeBus, automationEmitterContext(job.id, job.execution.target.sessionId), {
+        jobId: job.id,
+        changedFields,
+    });
+    if (job.enabled) {
+        emitAutomationJobEnabled(runtimeBus, automationEmitterContext(job.id, job.execution.target.sessionId), {
+            jobId: job.id,
+        });
+    }
+    else {
+        emitAutomationJobDisabled(runtimeBus, automationEmitterContext(job.id, job.execution.target.sessionId), {
+            jobId: job.id,
+            reason: job.pausedReason ?? 'disabled',
+        });
+    }
+}
+export function emitAutomationManagerJobAutoDisabled(runtimeBus, job, reason) {
+    if (!runtimeBus)
+        return;
+    emitAutomationJobAutoDisabled(runtimeBus, automationEmitterContext(job.id, job.execution.target.sessionId), {
+        jobId: job.id,
+        reason,
+        consecutiveFailures: job.failureCount,
+    });
+}
+export function emitAutomationManagerRunQueued(runtimeBus, job, run) {
+    if (!runtimeBus)
+        return;
+    emitAutomationRunQueued(runtimeBus, automationEmitterContext(run.id, job.execution.target.sessionId), {
+        jobId: job.id,
+        runId: run.id,
+        scheduledAt: run.queuedAt,
+        forced: run.forceRun,
+    });
+}
+export function emitAutomationManagerRunStarted(runtimeBus, job, run) {
+    if (!runtimeBus || run.startedAt === undefined)
+        return;
+    emitAutomationRunStarted(runtimeBus, automationEmitterContext(run.id, job.execution.target.sessionId), {
+        jobId: job.id,
+        runId: run.id,
+        startedAt: run.startedAt,
+        attempt: run.attempt,
+    });
+}
+export function emitAutomationManagerRunCompleted(runtimeBus, job, run, outcome) {
+    if (!runtimeBus || run.startedAt === undefined || run.endedAt === undefined)
+        return;
+    emitAutomationRunCompleted(runtimeBus, automationEmitterContext(run.id, job.execution.target.sessionId), {
+        jobId: job.id,
+        runId: run.id,
+        startedAt: run.startedAt,
+        completedAt: run.endedAt,
+        durationMs: run.durationMs ?? Math.max(0, run.endedAt - run.startedAt),
+        outcome,
+    });
+}
+export function emitAutomationManagerRunFailed(runtimeBus, job, run, error, retryable) {
+    if (!runtimeBus || run.startedAt === undefined || run.endedAt === undefined)
+        return;
+    emitAutomationRunFailed(runtimeBus, automationEmitterContext(run.id, job.execution.target.sessionId), {
+        jobId: job.id,
+        runId: run.id,
+        startedAt: run.startedAt,
+        failedAt: run.endedAt,
+        error,
+        retryable,
+    });
+}

package/dist/_internal/platform/automation/manager-runtime-execution.d.ts

@@ -0,0 +1,67 @@
+import { SharedSessionBroker } from '../control-plane/index.js';
+import type { SharedSessionRecord, SharedSessionSubmission } from '../control-plane/index.js';
+import type { RouteBindingManager } from '../channels/index.js';
+import type { AutomationJob } from '@pellux/goodvibes-sdk/platform/automation/jobs';
+import type { AutomationRouteBinding } from '@pellux/goodvibes-sdk/platform/automation/routes';
+import type { AutomationRun, AutomationRunContinuationMode } from '@pellux/goodvibes-sdk/platform/automation/runs';
+import type { AutomationSessionTarget } from '@pellux/goodvibes-sdk/platform/automation/session-targets';
+import type { AutomationRunTrigger } from '@pellux/goodvibes-sdk/platform/automation/types';
+import type { ConfigManager } from '../config/manager.js';
+export interface AutomationManagerExecutionContext {
+    readonly configManager: ConfigManager;
+    readonly routeBindings: RouteBindingManager;
+    readonly sessionBroker: SharedSessionBroker;
+    readonly spawnTask: (input: {
+        readonly prompt: string;
+        readonly modelId?: string;
+        readonly modelProvider?: string;
+        readonly fallbackModels?: readonly string[];
+        readonly routing?: AutomationRun['execution']['routing'];
+        readonly executionIntent?: AutomationRun['execution']['executionIntent'];
+        readonly template?: string;
+        readonly reasoningEffort?: AutomationRun['execution']['reasoningEffort'];
+        readonly toolAllowlist?: readonly string[];
+        readonly context?: string;
+    }) => string;
+    readonly saveJobs: () => Promise<void>;
+    readonly saveRuns: () => Promise<void>;
+    readonly pruneRunHistory: (jobId?: string) => void;
+    readonly activeRunCount: () => number;
+    readonly maxConcurrentRuns: () => number;
+    readonly syncExecutionRoute: (job: AutomationJob, run: AutomationRun) => Promise<void>;
+    readonly syncRunToRuntime: (run: AutomationRun, source: string) => void;
+    readonly syncJobToRuntime: (job: AutomationJob, source: string) => void;
+    readonly emitRunQueued: (job: AutomationJob, run: AutomationRun) => void;
+    readonly emitRunStarted: (job: AutomationJob, run: AutomationRun) => void;
+    readonly emitRunCompleted: (job: AutomationJob, run: AutomationRun, outcome: 'success' | 'partial' | 'failed' | 'cancelled') => void;
+    readonly emitRunFailed: (job: AutomationJob, run: AutomationRun, error: string, retryable: boolean) => void;
+    readonly maybeDeliverRun: (job: AutomationJob, run: AutomationRun) => void;
+    readonly scheduleFailureFollowUp: (job: AutomationJob, run: AutomationRun) => void;
+    readonly applyFailureToJob: (job: AutomationJob, timestamp: number, countRun?: boolean) => AutomationJob;
+    readonly jobs: Map<string, AutomationJob>;
+    readonly runs: Map<string, AutomationRun>;
+}
+interface ResolvedAutomationExecution {
+    readonly task: string;
+    readonly continuationMode: AutomationRunContinuationMode;
+    readonly session?: SharedSessionRecord;
+    readonly route?: AutomationRouteBinding;
+    readonly agentId?: string;
+    readonly target: AutomationSessionTarget;
+    readonly executionIntent: AutomationRun['executionIntent'];
+    readonly updatedJob?: AutomationJob;
+}
+export declare function executeAutomationJob(context: AutomationManagerExecutionContext, job: AutomationJob, trigger: AutomationRunTrigger, dueRun: boolean, attempt?: number): Promise<AutomationRun>;
+export declare function resolveAutomationExecution(context: AutomationManagerExecutionContext, job: AutomationJob, prompt: string, trigger: AutomationRunTrigger): Promise<ResolvedAutomationExecution>;
+export declare function resolveSharedSessionExecution(context: AutomationManagerExecutionContext, job: AutomationJob, prompt: string, trigger: AutomationRunTrigger, input: {
+    readonly sessionId?: string;
+    readonly routeId?: string;
+    readonly target: AutomationSessionTarget;
+    readonly updatedJob?: AutomationJob;
+}): Promise<ResolvedAutomationExecution>;
+export declare function toResolvedExecution(job: AutomationJob, target: AutomationSessionTarget, submission: SharedSessionSubmission, updatedJob?: AutomationJob): ResolvedAutomationExecution;
+export declare function resolveRouteForTarget(context: AutomationManagerExecutionContext, target: AutomationSessionTarget, job: AutomationJob): AutomationRouteBinding | undefined;
+export declare function syncExecutionRoute(context: AutomationManagerExecutionContext, job: AutomationJob, run: AutomationRun): Promise<void>;
+export declare function applyFailureToJob(job: AutomationJob, timestamp: number, countRun?: boolean): AutomationJob;
+export {};
+//# sourceMappingURL=manager-runtime-execution.d.ts.map