@kafca/agentdock 0.1.58 → 0.1.62

package/dist-electron/services/local-ai-core/src/automation/automation-trigger-engine.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextActivationAt = nextActivationAt;
+exports.isActivationDue = isActivationDue;
+exports.missedActivationAt = missedActivationAt;
+const cron_js_1 = require("../scheduler/cron.js");
+const MINUTE_MS = 60_000;
+function nextActivationAt(activation, after) {
+    const afterMs = validDateMs(after, 'after');
+    const compiledCron = validateActivation(activation);
+    switch (activation.kind) {
+        case 'provider-event':
+            return null;
+        case 'once': {
+            const runAt = parseIsoTimestamp(activation.runAt, 'once runAt');
+            return runAt.getTime() > afterMs ? runAt : null;
+        }
+        case 'interval': {
+            const nextMs = (Math.floor(afterMs / activation.intervalMs) + 1) * activation.intervalMs;
+            return validResultDate(nextMs);
+        }
+        case 'cron': {
+            const result = (0, cron_js_1.findNextCronMatchUtc)(requireCompiledCron(compiledCron), after);
+            if (result.date)
+                return result.date;
+            throw new Error(`No UTC cron activation exists for expression: ${activation.expression}`);
+        }
+    }
+}
+function isActivationDue(activation, now, nextCheckAt) {
+    const nowMs = validDateMs(now, 'now');
+    const compiledCron = validateActivation(activation);
+    if (activation.kind === 'provider-event')
+        return false;
+    if (nextCheckAt !== undefined) {
+        return parseIsoTimestamp(nextCheckAt, 'nextCheckAt').getTime() <= nowMs;
+    }
+    switch (activation.kind) {
+        case 'once':
+            return parseIsoTimestamp(activation.runAt, 'once runAt').getTime() <= nowMs;
+        case 'interval':
+            return nowMs % activation.intervalMs === 0;
+        case 'cron':
+            return nowMs === floorUtcMinute(nowMs) && (0, cron_js_1.cronMatchesFields)(requireCompiledCron(compiledCron), {
+                minute: now.getUTCMinutes(),
+                hour: now.getUTCHours(),
+                dayOfMonth: now.getUTCDate(),
+                month: now.getUTCMonth() + 1,
+                dayOfWeek: now.getUTCDay(),
+            });
+    }
+}
+function missedActivationAt(activation, lastCheckedAt, now) {
+    const nowMs = validDateMs(now, 'now');
+    const compiledCron = validateActivation(activation);
+    if (activation.kind === 'provider-event' || lastCheckedAt === undefined)
+        return null;
+    const lastCheckedMs = parseIsoTimestamp(lastCheckedAt, 'lastCheckedAt').getTime();
+    if (lastCheckedMs >= nowMs)
+        return null;
+    switch (activation.kind) {
+        case 'once': {
+            const runAt = parseIsoTimestamp(activation.runAt, 'once runAt');
+            return runAt.getTime() > lastCheckedMs && runAt.getTime() <= nowMs ? runAt : null;
+        }
+        case 'interval': {
+            const latestMs = Math.floor(nowMs / activation.intervalMs) * activation.intervalMs;
+            return latestMs > lastCheckedMs ? validResultDate(latestMs) : null;
+        }
+        case 'cron': {
+            return (0, cron_js_1.findPreviousCronMatchUtc)(requireCompiledCron(compiledCron), now, new Date(lastCheckedMs)).date;
+        }
+    }
+}
+function validateActivation(activation) {
+    switch (activation.kind) {
+        case 'provider-event':
+            return undefined;
+        case 'once':
+            parseIsoTimestamp(activation.runAt, 'once runAt');
+            return undefined;
+        case 'interval':
+            assertInterval(activation.intervalMs);
+            return undefined;
+        case 'cron':
+            assertUtcTimezone(activation.timezone);
+            return (0, cron_js_1.compileCronExpression)(activation.expression);
+    }
+}
+function assertUtcTimezone(timezone) {
+    if (timezone !== 'UTC' && timezone !== 'Etc/UTC') {
+        throw new Error(`Automation scheduling currently supports only UTC cron timezones; received: ${timezone}`);
+    }
+}
+function assertInterval(intervalMs) {
+    if (!Number.isSafeInteger(intervalMs) || intervalMs <= 0) {
+        throw new Error('Automation intervalMs must be a positive safe integer.');
+    }
+}
+function parseIsoTimestamp(value, label) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d{1,3})?(?:Z|[+-]\d{2}:\d{2})$/.exec(value);
+    if (!match)
+        throw new Error(`Automation ${label} must be a valid ISO timestamp.`);
+    const date = new Date(value);
+    validDateMs(date, label);
+    const [, yearText, monthText, dayText, hourText, minuteText, secondText] = match;
+    const year = Number(yearText);
+    const month = Number(monthText);
+    const day = Number(dayText);
+    const calendarDate = new Date(0);
+    calendarDate.setUTCFullYear(year, month - 1, day);
+    calendarDate.setUTCHours(0, 0, 0, 0);
+    if (calendarDate.getUTCFullYear() !== year
+        || calendarDate.getUTCMonth() !== month - 1
+        || calendarDate.getUTCDate() !== day
+        || Number(hourText) > 23
+        || Number(minuteText) > 59
+        || Number(secondText) > 59) {
+        throw new Error(`Automation ${label} must be a valid ISO timestamp.`);
+    }
+    return date;
+}
+function requireCompiledCron(compiled) {
+    if (!compiled)
+        throw new Error('Automation cron expression was not compiled.');
+    return compiled;
+}
+function validDateMs(date, label) {
+    const value = date.getTime();
+    if (!Number.isFinite(value))
+        throw new Error(`Automation ${label} must be a valid date.`);
+    return value;
+}
+function validResultDate(value) {
+    const result = new Date(value);
+    validDateMs(result, 'activation result');
+    return result;
+}
+function floorUtcMinute(value) {
+    return Math.floor(value / MINUTE_MS) * MINUTE_MS;
+}

package/dist-electron/services/local-ai-core/src/automation/condition-evaluator.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.evaluateMonitorCondition = evaluateMonitorCondition;
 exports.evaluateExpression = evaluateExpression;
+exports.evaluateRestrictedExpression = evaluateRestrictedExpression;
+exports.validateRestrictedExpression = validateRestrictedExpression;
+exports.compileRestrictedExpression = compileRestrictedExpression;
 exports.readMetric = readMetric;
 function evaluateMonitorCondition(condition, event) {
     if (condition.expression) {
@@ -27,27 +30,52 @@ function evaluateMonitorCondition(condition, event) {
     }
 }
 function evaluateExpression(expression, event) {
-    const orParts = splitExpression(expression, '||');
-    return orParts.some((orPart) => splitExpression(orPart, '&&').every((andPart) => evaluateComparison(andPart.trim(), event)));
+    return evaluateRestrictedExpression(expression, (metric) => readMetric(event, metric));
 }
-function evaluateComparison(expression, event) {
-    const match = expression.match(/^([a-zA-Z0-9_.-]+)\s*(>=|<=|==|!=|>|<)\s*(.+)$/);
-    if (!match) {
+function evaluateRestrictedExpression(expression, contextOrResolver) {
+    const compiled = compileRestrictedExpression(expression);
+    const resolveMetric = typeof contextOrResolver === 'function'
+        ? contextOrResolver
+        : (metric) => readContextMetric(contextOrResolver, metric);
+    return compiled.some((orPart) => orPart.every((comparison) => evaluateRestrictedComparison(comparison, resolveMetric)));
+}
+function validateRestrictedExpression(expression) {
+    compileRestrictedExpression(expression);
+}
+function compileRestrictedExpression(expression) {
+    const source = String(expression || '').trim();
+    if (!source)
         throw new Error(`Unsupported monitor condition expression: ${expression}`);
-    }
-    const rawValue = String(match[3] || '').trim().replace(/^["']|["']$/g, '');
-    const numeric = Number(rawValue);
-    return evaluateMonitorCondition({
-        metric: String(match[1] || '').trim(),
+    return source.split('||').map((orPart) => {
+        if (!orPart.trim())
+            throw new Error(`Unsupported monitor condition expression: ${expression}`);
+        return orPart.split('&&').map((andPart) => compileRestrictedComparison(andPart.trim(), expression));
+    });
+}
+function compileRestrictedComparison(expression, original) {
+    const match = expression.match(/^([a-zA-Z0-9_.-]+)\s*(>=|<=|==|!=|>|<)\s*("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|[^\s&|<>=!]+)$/);
+    if (!match)
+        throw new Error(`Unsupported monitor condition expression: ${original}`);
+    return {
+        metric: String(match[1]),
         operator: match[2],
-        value: Number.isFinite(numeric) && rawValue !== '' ? numeric : rawValue,
-    }, event);
+        rawValue: String(match[3]),
+    };
 }
-function splitExpression(expression, operator) {
-    return expression
-        .split(operator)
-        .map((part) => part.trim())
-        .filter(Boolean);
+function evaluateRestrictedComparison(comparison, resolveMetric) {
+    const rawValue = comparison.rawValue.replace(/^["']|["']$/g, '');
+    const numeric = Number(rawValue);
+    const actual = resolveMetric(comparison.metric);
+    const expected = Number.isFinite(numeric) && rawValue !== '' ? numeric : rawValue;
+    switch (comparison.operator) {
+        case '>': return Number(actual) > Number(expected);
+        case '>=': return Number(actual) >= Number(expected);
+        case '<': return Number(actual) < Number(expected);
+        case '<=': return Number(actual) <= Number(expected);
+        case '==': return String(actual) === String(expected);
+        case '!=': return String(actual) !== String(expected);
+        default: return false;
+    }
 }
 function readMetric(event, metric) {
     const key = String(metric || '').trim();
@@ -75,3 +103,18 @@ function readMetric(event, metric) {
         return current[part];
     }, payload);
 }
+function readContextMetric(context, metric) {
+    if (metric === 'abs_change_percent') {
+        return Math.abs(Number(context.change_percent ?? context.changePercent ?? 0));
+    }
+    const normalizedKey = metric.replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`);
+    if (Object.prototype.hasOwnProperty.call(context, metric))
+        return context[metric];
+    if (Object.prototype.hasOwnProperty.call(context, normalizedKey))
+        return context[normalizedKey];
+    return metric.split('.').reduce((current, part) => {
+        if (!current || typeof current !== 'object')
+            return undefined;
+        return current[part];
+    }, context);
+}

package/dist-electron/services/local-ai-core/src/automation/legacy-automation-mappers.js

@@ -0,0 +1,286 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scheduledJobToAutomationInput = scheduledJobToAutomationInput;
+exports.automationToScheduledJob = automationToScheduledJob;
+exports.monitorToAutomationInput = monitorToAutomationInput;
+exports.automationToMonitor = automationToMonitor;
+exports.automationToScheduledJobRun = automationToScheduledJobRun;
+exports.automationToMonitorRun = automationToMonitorRun;
+exports.latestFinishedEvaluation = latestFinishedEvaluation;
+exports.latestAutomationRun = latestAutomationRun;
+const superai_contracts_1 = require("../../../../packages/contracts/src/index.js");
+const condition_evaluator_js_1 = require("./condition-evaluator.js");
+function scheduledJobToAutomationInput(input) {
+    const triggerType = (0, superai_contracts_1.normalizeScheduledJobTriggerType)(input.triggerType);
+    const activation = triggerType === 'once'
+        ? { kind: 'once', runAt: requireText(input.runAt, 'Scheduled job runAt') }
+        : triggerType === 'cron'
+            ? { kind: 'cron', expression: requireText(input.cronExpr, 'Scheduled job cronExpr'), timezone: 'UTC' }
+            : fail(`Unsupported scheduled job trigger type: ${triggerType}`);
+    return {
+        workspaceId: requireText(input.workspaceId, 'Scheduled job workspaceId'),
+        title: String(input.description || '').trim() || requireText(input.promptTemplate, 'Scheduled job promptTemplate'),
+        enabled: input.enabled !== false,
+        activation,
+        condition: { kind: 'always' },
+        action: {
+            kind: 'agent-prompt',
+            promptTemplate: requireText(input.promptTemplate, 'Scheduled job promptTemplate'),
+            executionMode: legacyExecutionMode(input.executionMode, 'same-thread'),
+        },
+        delivery: { platform: requireText(input.platform, 'Scheduled job platform'), route: input.route },
+        policies: { concurrency: 'skip-if-running', cooldownMs: 0 },
+        originKind: 'scheduled-job',
+        legacyMetadata: { scheduledDescription: input.description ?? '' },
+    };
+}
+function automationToScheduledJob(automation, latestRun) {
+    assertOrigin(automation, 'scheduled-job');
+    if (automation.condition.kind !== 'always')
+        throw new Error('Scheduled-job automation condition must be always.');
+    if (automation.activation.kind !== 'cron' && automation.activation.kind !== 'once') {
+        throw new Error('Scheduled-job automation activation must be cron or once.');
+    }
+    return {
+        id: automation.id,
+        workspaceId: automation.workspaceId,
+        platform: automation.delivery.platform,
+        route: automation.delivery.route,
+        executionMode: automation.action.executionMode,
+        triggerType: automation.activation.kind,
+        ...(automation.activation.kind === 'cron' ? { cronExpr: automation.activation.expression } : { runAt: automation.activation.runAt }),
+        promptTemplate: automation.action.promptTemplate,
+        description: automation.legacyMetadata?.scheduledDescription ?? automation.title,
+        enabled: automation.enabled,
+        concurrencyPolicy: 'skip_if_running',
+        createdAt: automation.createdAt,
+        updatedAt: automation.updatedAt,
+        ...(latestRun?.finishedAt || latestRun?.startedAt || automation.lastEvaluationAt
+            ? { lastRunAt: latestRun?.finishedAt || latestRun?.startedAt || automation.lastEvaluationAt }
+            : {}),
+        ...(latestRun ? { lastStatus: latestRun.status } : {}),
+        ...(latestRun?.error ? { lastError: latestRun.error } : {}),
+    };
+}
+function monitorToAutomationInput(input) {
+    return {
+        workspaceId: requireText(input.workspaceId, 'Automation monitor workspaceId'),
+        title: requireText(input.title, 'Automation monitor title'),
+        enabled: input.enabled !== false,
+        activation: {
+            kind: 'provider-event',
+            sourceType: requireText(input.sourceType, 'Automation monitor sourceType'),
+            sourceConfig: input.sourceConfig || {},
+        },
+        condition: { kind: 'expression', expression: monitorConditionExpression(input.condition) },
+        action: {
+            kind: 'agent-prompt',
+            promptTemplate: requireText(input.promptTemplate, 'Automation monitor promptTemplate'),
+            executionMode: legacyExecutionMode(input.executionMode, 'side-thread'),
+        },
+        delivery: { platform: requireText(input.platform, 'Automation monitor platform'), route: input.route },
+        policies: { concurrency: 'skip-if-running', cooldownMs: input.cooldownMs ?? 15 * 60 * 1_000 },
+        originKind: 'automation-monitor',
+    };
+}
+function automationToMonitor(automation, latestEvaluation, latestRun, latestStateEvaluation) {
+    assertOrigin(automation, 'automation-monitor');
+    if (automation.activation.kind !== 'provider-event') {
+        throw new Error('Automation-monitor automation activation must be provider-event.');
+    }
+    if (automation.condition.kind !== 'expression') {
+        throw new Error('Automation-monitor automation condition must be expression.');
+    }
+    const stateEvaluation = latestStateEvaluation || latestEvaluation;
+    const lastState = stateEvaluation?.status === 'finished' ? stateEvaluation.nextState : undefined;
+    const latestEvaluationStatus = latestEvaluation && latestRun?.evaluationId !== latestEvaluation.id
+        ? evaluationStatus(latestEvaluation)
+        : undefined;
+    return {
+        id: automation.id,
+        workspaceId: automation.workspaceId,
+        title: automation.title,
+        sourceType: automation.activation.sourceType,
+        sourceConfig: automation.activation.sourceConfig,
+        condition: expressionToMonitorCondition(automation.condition.expression),
+        promptTemplate: automation.action.promptTemplate,
+        platform: automation.delivery.platform,
+        route: automation.delivery.route,
+        executionMode: automation.action.executionMode,
+        enabled: automation.enabled,
+        cooldownMs: automation.policies.cooldownMs,
+        concurrencyPolicy: 'skip_if_running',
+        ...(lastState ? { lastState } : {}),
+        createdAt: automation.createdAt,
+        updatedAt: automation.updatedAt,
+        ...(automation.lastTriggeredAt ? { lastTriggeredAt: automation.lastTriggeredAt } : {}),
+        ...(latestEvaluationStatus ? { lastStatus: latestEvaluationStatus } : latestRun ? { lastStatus: latestRun.status } : {}),
+        ...(latestEvaluation?.status === 'finished' && latestEvaluation.conditionOutcome === 'error' && latestEvaluation.resultSummary
+            ? { lastError: latestEvaluation.resultSummary }
+            : latestRun?.error
+                ? { lastError: latestRun.error }
+                : automation.consecutiveEvaluationFailures > 0 && latestEvaluation?.status === 'finished' && latestEvaluation.resultSummary
+                    ? { lastError: latestEvaluation.resultSummary }
+                    : {}),
+    };
+}
+function automationToScheduledJobRun(evaluation, run) {
+    const status = run?.status || evaluationStatus(evaluation);
+    const evaluationError = !run && evaluation.status === 'finished'
+        && (evaluation.conditionOutcome === 'skipped' || evaluation.conditionOutcome === 'error')
+        ? evaluation.resultSummary
+        : undefined;
+    return {
+        id: run?.id || evaluation.id,
+        jobId: evaluation.automationId,
+        status,
+        triggeredAt: evaluation.status === 'finished' ? evaluation.triggeredAt || evaluation.startedAt : evaluation.startedAt,
+        ...(run?.startedAt ? { startedAt: run.startedAt } : {}),
+        ...(run?.finishedAt ? { finishedAt: run.finishedAt } : {}),
+        ...(run?.error || evaluationError
+            ? { error: run?.error || evaluationError, deliveryError: run?.error || evaluationError }
+            : {}),
+        ...(run?.threadId ? { threadId: run.threadId } : {}),
+        ...(run?.acpRunId ? { runId: run.acpRunId } : {}),
+        ...(legacyDeliveryMode(run?.bridgeActivity?.deliveryMode) ? { deliveryMode: legacyDeliveryMode(run?.bridgeActivity?.deliveryMode) } : {}),
+        ...(run?.deliveryStatus
+            ? { deliveryStatus: legacyDeliveryStatus(run.deliveryStatus) }
+            : evaluationError ? { deliveryStatus: status === 'failed' ? 'failed' : 'skipped' } : {}),
+        ...(typeof run?.bridgeActivity?.lastBridgeEventAt === 'string'
+            ? { lastBridgeEventAt: run.bridgeActivity.lastBridgeEventAt }
+            : {}),
+    };
+}
+function automationToMonitorRun(evaluation, run) {
+    const payload = evaluation.status === 'finished' ? evaluation.payload : undefined;
+    const eventSnapshot = payload?.eventSnapshot ? parseEventSnapshot(payload.eventSnapshot) : undefined;
+    const evaluationError = !run && evaluation.status === 'finished'
+        && (evaluation.conditionOutcome === 'skipped' || evaluation.conditionOutcome === 'error')
+        ? evaluation.resultSummary
+        : undefined;
+    return {
+        id: run?.id || evaluation.id,
+        monitorId: evaluation.automationId,
+        status: run?.status || evaluationStatus(evaluation),
+        triggeredAt: eventSnapshot?.occurredAt || (evaluation.status === 'finished' ? evaluation.triggeredAt : undefined) || evaluation.startedAt,
+        ...(run?.startedAt ? { startedAt: run.startedAt } : {}),
+        ...(run?.finishedAt ? { finishedAt: run.finishedAt } : {}),
+        ...(run?.error || evaluationError
+            ? { error: run?.error || evaluationError, deliveryError: run?.error || evaluationError }
+            : {}),
+        ...(eventSnapshot ? { eventSnapshot } : {}),
+        ...(run?.threadId ? { threadId: run.threadId } : {}),
+        ...(run?.acpRunId ? { runId: run.acpRunId } : {}),
+        ...(legacyDeliveryMode(run?.bridgeActivity?.deliveryMode) ? { deliveryMode: legacyDeliveryMode(run?.bridgeActivity?.deliveryMode) } : {}),
+        ...(run?.deliveryStatus
+            ? { deliveryStatus: legacyDeliveryStatus(run.deliveryStatus) }
+            : evaluationError ? { deliveryStatus: (run?.status || evaluationStatus(evaluation)) === 'failed' ? 'failed' : 'skipped' } : {}),
+        ...(typeof run?.bridgeActivity?.lastBridgeEventAt === 'string'
+            ? { lastBridgeEventAt: run.bridgeActivity.lastBridgeEventAt }
+            : {}),
+    };
+}
+function latestFinishedEvaluation(evaluations) {
+    return evaluations.find((evaluation) => evaluation.status === 'finished');
+}
+function latestAutomationRun(runs) {
+    return runs[0];
+}
+function monitorConditionExpression(condition) {
+    const operator = (0, superai_contracts_1.normalizeAutomationMonitorConditionOperator)(condition.operator);
+    if (typeof condition.value !== 'number' && typeof condition.value !== 'string' && typeof condition.value !== 'boolean') {
+        throw new Error('Automation monitor condition value must be a number, string, or boolean.');
+    }
+    if (condition.expression?.trim()) {
+        const expression = condition.expression.trim();
+        (0, condition_evaluator_js_1.validateRestrictedExpression)(expression);
+        return expression;
+    }
+    const metric = requireText(condition.metric, 'Automation monitor condition metric');
+    const expression = `${metric} ${operator} ${JSON.stringify(condition.value)}`;
+    (0, condition_evaluator_js_1.validateRestrictedExpression)(expression);
+    return expression;
+}
+function expressionToMonitorCondition(expression) {
+    if (expression.includes('&&') || expression.includes('||')) {
+        return { metric: 'expression', operator: '==', value: true, expression };
+    }
+    const match = expression.trim().match(/^([a-zA-Z0-9_.-]+)\s*(>=|<=|==|!=|>|<)\s*(.+)$/);
+    if (!match)
+        return { metric: 'expression', operator: '==', value: true, expression };
+    const raw = match[3].trim();
+    let value = raw.replace(/^["']|["']$/g, '');
+    if (raw === 'true' || raw === 'false')
+        value = raw === 'true';
+    else if (raw !== '' && Number.isFinite(Number(raw)))
+        value = Number(raw);
+    return {
+        metric: match[1],
+        operator: parseMonitorOperator(match[2]),
+        value,
+    };
+}
+function evaluationStatus(evaluation) {
+    if (evaluation.status === 'running')
+        return 'running';
+    if (evaluation.conditionOutcome === 'error')
+        return 'failed';
+    if (evaluation.triggerDecision !== 'triggered')
+        return 'skipped';
+    return 'queued';
+}
+function legacyDeliveryStatus(status) {
+    if (status === 'delivered')
+        return 'succeeded';
+    if (status === 'delivering')
+        return 'streaming';
+    return status;
+}
+function legacyDeliveryMode(value) {
+    return value === 'thread-only' || value === 'bridge-stream' || value === 'final-message' ? value : undefined;
+}
+function parseEventSnapshot(value) {
+    if (!isRecord(value))
+        throw new Error('Automation eventSnapshot must be an object.');
+    const candidate = value;
+    if (!isRecord(candidate.payload)) {
+        throw new Error('Automation eventSnapshot payload must be an object.');
+    }
+    return {
+        id: requireText(candidate.id, 'Automation eventSnapshot id'),
+        sourceType: requireText(candidate.sourceType, 'Automation eventSnapshot sourceType'),
+        occurredAt: requireText(candidate.occurredAt, 'Automation eventSnapshot occurredAt'),
+        subject: requireText(candidate.subject, 'Automation eventSnapshot subject'),
+        ...(typeof candidate.summary === 'string' ? { summary: candidate.summary } : {}),
+        payload: candidate.payload,
+    };
+}
+function parseMonitorOperator(value) {
+    if (value === '>' || value === '>=' || value === '<' || value === '<=' || value === '==' || value === '!=')
+        return value;
+    throw new Error(`Automation monitor operator is invalid: ${String(value)}`);
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function assertOrigin(automation, expected) {
+    if (automation.originKind !== expected)
+        throw new Error(`Automation must have ${expected} origin.`);
+}
+function requireText(value, label) {
+    const text = String(value || '').trim();
+    if (!text)
+        throw new Error(`${label} is required.`);
+    return text;
+}
+function legacyExecutionMode(value, fallback) {
+    const normalized = (0, superai_contracts_1.normalizeScheduledJobExecutionMode)(value, fallback);
+    if (normalized === 'same-thread')
+        return 'same-thread';
+    if (normalized === 'side-thread')
+        return 'side-thread';
+    throw new Error('Scheduled job execution mode must be same-thread or side-thread.');
+}
+function fail(message) {
+    throw new Error(message);
+}