@forestadmin/workflow-executor 1.0.0

package/dist/executors/summary/step-execution-formatters.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class StepExecutionFormatters {
+    // Returns null when no custom format is defined for the step type or when execution data
+    // doesn't satisfy formatter preconditions — caller falls back to generic Input:/Output:.
+    static format(execution) {
+        switch (execution.type) {
+            case 'load-related-record':
+                return StepExecutionFormatters.formatLoadRelatedRecord(execution);
+            case 'mcp':
+                return StepExecutionFormatters.formatMcp(execution);
+            case 'guidance':
+                return StepExecutionFormatters.formatGuidance(execution);
+            default:
+                return null;
+        }
+    }
+    static formatMcp(execution) {
+        const { executionResult } = execution;
+        if (!executionResult)
+            return null;
+        if ('skipped' in executionResult)
+            return null;
+        if (executionResult.formattedResponse) {
+            return `  Result: ${executionResult.formattedResponse}`;
+        }
+        const toolName = execution.executionParams?.name ?? 'unknown tool';
+        return `  Executed: ${toolName} (result not summarized)`;
+    }
+    static formatGuidance(execution) {
+        if (!execution.executionResult?.userInput)
+            return null;
+        return `  The user provided the following input: "${execution.executionResult.userInput}"`;
+    }
+    static formatLoadRelatedRecord(execution) {
+        const { executionResult } = execution;
+        if (!executionResult)
+            return null; // pending phase — no result yet
+        if ('skipped' in executionResult)
+            return null; // user skipped — generic fallback
+        const { selectedRecordRef } = execution;
+        const { relation, record } = executionResult;
+        const sourceId = selectedRecordRef.recordId.join(', ');
+        const recordId = record.recordId.join(', ');
+        return `  Loaded: ${selectedRecordRef.collectionName} #${sourceId} → [${relation.displayName}] → ${record.collectionName} #${recordId} (step ${record.stepIndex})`;
+    }
+}
+exports.default = StepExecutionFormatters;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/executors/summary/step-summary-builder.d.ts

@@ -0,0 +1,7 @@
+import type { StepExecutionData } from '../../types/step-execution-data';
+import type { StepDefinition } from '../../types/validated/step-definition';
+import type { StepOutcome } from '../../types/validated/step-outcome';
+export default class StepSummaryBuilder {
+    static build(step: StepDefinition, stepOutcome: StepOutcome, execution: StepExecutionData | undefined): string;
+}
+//# sourceMappingURL=step-summary-builder.d.ts.map

package/dist/executors/summary/step-summary-builder.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const step_execution_formatters_1 = __importDefault(require("./step-execution-formatters"));
+class StepSummaryBuilder {
+    static build(step, stepOutcome, execution) {
+        const prompt = step.prompt ?? '(no prompt)';
+        const header = `Step "${stepOutcome.stepId}" (index ${stepOutcome.stepIndex}):`;
+        const lines = [header, `  Prompt: ${prompt}`];
+        if (execution !== undefined) {
+            // Detect "handled manually": executor proposed an action (pendingData) but the user
+            // completed the step on the frontend without going through the trigger endpoint, so the
+            // executor never wrote executionResult. Normal completions (confirmation flow, skip, Branch B)
+            // always set executionResult before the step is marked done.
+            if (stepOutcome.status === 'success' &&
+                'pendingData' in execution &&
+                execution.pendingData !== undefined &&
+                execution.executionResult === undefined) {
+                lines.push(`  Proposed: ${JSON.stringify(execution.pendingData)}`);
+                lines.push(`  Note: the user handled this step manually — the actual outcome may differ from the proposal above.`);
+                return lines.join('\n');
+            }
+            // Try custom formatting — if it fires, it owns the entire output section (no Input: line)
+            const customLine = execution.executionResult
+                ? step_execution_formatters_1.default.format(execution)
+                : null;
+            if (customLine !== null) {
+                lines.push(customLine);
+            }
+            else {
+                if ('executionParams' in execution && execution.executionParams !== undefined) {
+                    lines.push(`  Input: ${JSON.stringify(execution.executionParams)}`);
+                }
+                else if ('pendingData' in execution && execution.pendingData !== undefined) {
+                    lines.push(`  Pending: ${JSON.stringify(execution.pendingData)}`);
+                }
+                if (execution.executionResult) {
+                    lines.push(`  Output: ${JSON.stringify(execution.executionResult)}`);
+                }
+            }
+        }
+        else {
+            const { stepId, stepIndex, type, ...historyDetails } = stepOutcome;
+            lines.push(`  History: ${JSON.stringify(historyDetails)}`);
+        }
+        return lines.join('\n');
+    }
+}
+exports.default = StepSummaryBuilder;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/executors/trigger-record-action-step-executor.d.ts

@@ -0,0 +1,17 @@
+import type { StepExecutionResult } from '../types/execution-context';
+import type { TriggerActionStepDefinition } from '../types/validated/step-definition';
+import RecordStepExecutor from './record-step-executor';
+export default class TriggerRecordActionStepExecutor extends RecordStepExecutor<TriggerActionStepDefinition> {
+    protected checkIdempotency(): Promise<StepExecutionResult | null>;
+    protected doExecute(): Promise<StepExecutionResult>;
+    private handleFirstCall;
+    /** Branch B — executor runs the action via the audited agent, then persists the result. */
+    private executeOnExecutor;
+    /** Branch A — the frontend executed the action; executor only persists the result it sent. */
+    private saveFrontendResult;
+    private selectAction;
+    private buildSelectActionTool;
+    private findActionByTechnicalName;
+    private findAction;
+}
+//# sourceMappingURL=trigger-record-action-step-executor.d.ts.map

package/dist/executors/trigger-record-action-step-executor.js

@@ -0,0 +1,169 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ai_proxy_1 = require("@forestadmin/ai-proxy");
+const zod_1 = require("zod");
+const errors_1 = require("../errors");
+const record_step_executor_1 = __importDefault(require("./record-step-executor"));
+const step_definition_1 = require("../types/validated/step-definition");
+const TRIGGER_ACTION_SYSTEM_PROMPT = `You are an AI agent triggering an action on a record based on a user request.
+Select the action to trigger.
+
+Important rules:
+- Be precise: only trigger the action directly relevant to the request.
+- Final answer is definitive, you won't receive any other input from the user.
+- Do not refer to yourself as "I" in the response, use a passive formulation instead.`;
+class TriggerRecordActionStepExecutor extends record_step_executor_1.default {
+    async checkIdempotency() {
+        const existing = await this.findPendingExecution('trigger-action');
+        if (existing?.idempotencyPhase === 'done') {
+            return this.buildOutcomeResult({ status: 'success' });
+        }
+        if (existing?.idempotencyPhase === 'executing') {
+            throw new errors_1.StepStateError('Step execution was interrupted. Please retry the step manually.');
+        }
+        return null;
+    }
+    async doExecute() {
+        // Branch A -- Re-entry after pending execution found in RunStore
+        const pending = await this.patchAndReloadPendingData(this.context.incomingPendingData);
+        if (pending) {
+            return this.handleConfirmationFlow(pending, async (exec) => {
+                const { selectedRecordRef, pendingData, userConfirmation } = exec;
+                // The frontend executes the action itself and posts the result back.
+                // A confirmed step without actionResult is a broken frontend contract.
+                if (!pendingData || !userConfirmation || !('actionResult' in userConfirmation)) {
+                    throw new errors_1.StepStateError(`Frontend confirmed action but did not provide actionResult ` +
+                        `(run "${this.context.runId}", step ${this.context.stepIndex})`);
+                }
+                const target = {
+                    selectedRecordRef,
+                    displayName: pendingData.displayName,
+                    name: pendingData.name,
+                };
+                return this.saveFrontendResult(target, userConfirmation.actionResult, exec);
+            });
+        }
+        // Branches B & C -- First call
+        return this.handleFirstCall();
+    }
+    async handleFirstCall() {
+        const { stepDefinition: step } = this.context;
+        const { preRecordedArgs } = step;
+        const records = await this.getAvailableRecordRefs();
+        const selectedRecordRef = await this.resolveRecordRef(records, step.prompt, preRecordedArgs?.selectedRecordStepIndex);
+        const schema = await this.getCollectionSchema(selectedRecordRef.collectionName);
+        const recordedAction = preRecordedArgs?.actionName;
+        const actionName = recordedAction ?? (await this.selectAction(schema, step.prompt)).actionName;
+        const action = this.findActionByTechnicalName(schema, actionName);
+        if (!action) {
+            throw new errors_1.ActionNotFoundError(actionName, schema.collectionName);
+        }
+        const target = {
+            selectedRecordRef,
+            displayName: action.displayName,
+            name: action.name,
+        };
+        // Branch B -- fully automated: executor runs the action itself, so it cannot
+        // handle forms (no UI to fill them). Reject form-bearing actions here. When the
+        // frontend is in the loop (Branch C), it handles the form natively so no check.
+        if (step.executionType === step_definition_1.StepExecutionMode.FullyAutomated) {
+            const { hasForm } = await this.context.agent.getActionFormInfo({
+                collection: selectedRecordRef.collectionName,
+                action: target.name,
+                id: selectedRecordRef.recordId,
+            });
+            if (hasForm)
+                throw new errors_1.UnsupportedActionFormError(target.displayName);
+            return this.executeOnExecutor(target);
+        }
+        // Branch C -- Awaiting confirmation (frontend executes the action, including forms)
+        await this.context.runStore.saveStepExecution(this.context.runId, {
+            type: 'trigger-action',
+            stepIndex: this.context.stepIndex,
+            pendingData: { displayName: target.displayName, name: target.name },
+            selectedRecordRef: target.selectedRecordRef,
+        });
+        return this.buildOutcomeResult({ status: 'awaiting-input' });
+    }
+    /** Branch B — executor runs the action via the audited agent, then persists the result. */
+    async executeOnExecutor(target) {
+        const { selectedRecordRef, displayName, name } = target;
+        const actionResult = await this.context.agent.executeAction({
+            collection: selectedRecordRef.collectionName,
+            action: name,
+            id: selectedRecordRef.recordId,
+        }, {
+            beforeCall: () => this.context.runStore.saveStepExecution(this.context.runId, {
+                type: 'trigger-action',
+                stepIndex: this.context.stepIndex,
+                selectedRecordRef,
+                idempotencyPhase: 'executing',
+            }),
+        });
+        await this.context.runStore.saveStepExecution(this.context.runId, {
+            type: 'trigger-action',
+            stepIndex: this.context.stepIndex,
+            executionParams: { displayName, name },
+            executionResult: { success: true, actionResult },
+            selectedRecordRef,
+            idempotencyPhase: 'done',
+        });
+        return this.buildOutcomeResult({ status: 'success' });
+    }
+    /** Branch A — the frontend executed the action; executor only persists the result it sent. */
+    async saveFrontendResult(target, actionResult, existingExecution) {
+        const { selectedRecordRef, displayName, name } = target;
+        await this.context.runStore.saveStepExecution(this.context.runId, {
+            ...existingExecution,
+            type: 'trigger-action',
+            stepIndex: this.context.stepIndex,
+            executionParams: { displayName, name },
+            executionResult: { success: true, actionResult },
+            selectedRecordRef,
+        });
+        return this.buildOutcomeResult({ status: 'success' });
+    }
+    async selectAction(schema, prompt) {
+        const tool = this.buildSelectActionTool(schema);
+        const messages = [
+            this.buildContextMessage(),
+            ...(await this.buildPreviousStepsMessages()),
+            new ai_proxy_1.SystemMessage(TRIGGER_ACTION_SYSTEM_PROMPT),
+            new ai_proxy_1.SystemMessage(`The selected record belongs to the "${schema.collectionDisplayName}" collection.`),
+            new ai_proxy_1.HumanMessage(`**Request**: ${prompt ?? 'Trigger the relevant action.'}`),
+        ];
+        const { actionName } = await this.invokeWithTool(messages, tool);
+        return { actionName: this.findAction(schema, actionName)?.name ?? actionName };
+    }
+    buildSelectActionTool(schema) {
+        if (schema.actions.length === 0) {
+            throw new errors_1.NoActionsError(schema.collectionName);
+        }
+        const displayNames = schema.actions.map(a => a.displayName);
+        const technicalNames = schema.actions
+            .map(a => `${a.displayName} (technical name: ${a.name})`)
+            .join(', ');
+        return new ai_proxy_1.DynamicStructuredTool({
+            name: 'select-action',
+            description: 'Select the action to trigger on the record.',
+            schema: zod_1.z.object({
+                actionName: zod_1.z
+                    .enum(displayNames)
+                    .describe(`The name of the action to trigger. Available: ${technicalNames}`),
+                reasoning: zod_1.z.string().describe('Why this action was chosen'),
+            }),
+            func: undefined,
+        });
+    }
+    findActionByTechnicalName(schema, name) {
+        return schema.actions.find(a => a.name === name);
+    }
+    findAction(schema, name) {
+        return (schema.actions.find(a => a.displayName === name) ?? schema.actions.find(a => a.name === name));
+    }
+}
+exports.default = TriggerRecordActionStepExecutor;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"trigger-record-action-step-executor.js","sourceRoot":"","sources":["../../src/executors/trigger-record-action-step-executor.ts"],"names":[],"mappings":"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"}

package/dist/executors/update-record-step-executor.d.ts

@@ -0,0 +1,13 @@
+import type { StepExecutionResult } from '../types/execution-context';
+import type { UpdateRecordStepDefinition } from '../types/validated/step-definition';
+import RecordStepExecutor from './record-step-executor';
+export default class UpdateRecordStepExecutor extends RecordStepExecutor<UpdateRecordStepDefinition> {
+    protected checkIdempotency(): Promise<StepExecutionResult | null>;
+    protected doExecute(): Promise<StepExecutionResult>;
+    private coerceOverride;
+    private handleFirstCall;
+    private resolveAndUpdate;
+    private selectFieldAndValue;
+    private buildUpdateFieldTool;
+}
+//# sourceMappingURL=update-record-step-executor.d.ts.map

package/dist/executors/update-record-step-executor.js

@@ -0,0 +1,245 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ai_proxy_1 = require("@forestadmin/ai-proxy");
+const zod_1 = require("zod");
+const errors_1 = require("../errors");
+const record_step_executor_1 = __importDefault(require("./record-step-executor"));
+const step_definition_1 = require("../types/validated/step-definition");
+const UPDATE_RECORD_SYSTEM_PROMPT = `You are an AI agent updating a field on a record based on a user request.
+Select the field to update and provide the new value.
+
+Important rules:
+- Be precise: only update the field that is directly relevant to the request.
+- Final answer is definitive, you won't receive any other input from the user.
+- Do not refer to yourself as "I" in the response, use a passive formulation instead.`;
+const jsonStringSchema = zod_1.z
+    .string()
+    .refine(val => {
+    try {
+        JSON.parse(val);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}, { message: 'Must be a valid JSON string' })
+    .describe('JSON content as a valid JSON string');
+function buildZodSchemaForPrimitive(type, enumValues) {
+    switch (type) {
+        case 'Boolean':
+            return zod_1.z.preprocess(val => {
+                if (typeof val !== 'string')
+                    return val;
+                if (val === 'true')
+                    return true;
+                if (val === 'false')
+                    return false;
+                return val;
+            }, zod_1.z.boolean());
+        case 'Date':
+            return zod_1.z.iso.datetime().describe('ISO 8601 datetime, e.g. 2024-06-01T00:00:00Z');
+        case 'Dateonly':
+            return zod_1.z.iso.date().describe('ISO 8601 date, e.g. 2024-06-01');
+        case 'Number':
+            return zod_1.z.coerce.number();
+        case 'Enum':
+            if (enumValues && enumValues.length >= 2) {
+                return zod_1.z.enum(enumValues);
+            }
+            if (enumValues?.length === 1)
+                return zod_1.z.literal(enumValues[0]);
+            return zod_1.z.string();
+        case 'Json':
+            return jsonStringSchema;
+        case 'Point':
+            return zod_1.z.array(zod_1.z.number()).length(2).describe('[longitude, latitude]');
+        // String, Uuid, Time, Binary, Timeonly, File → plain string
+        default:
+            return zod_1.z.string();
+    }
+}
+function buildZodSchemaForField(field, collectionName) {
+    const { type, enumValues } = field;
+    // A writable (non-relationship) field with no column type is a malformed schema for this update:
+    // we'd otherwise fall through to z.string() and silently write the wrong type. Fail visibly.
+    if (type == null) {
+        throw new errors_1.FieldTypeMissingError(field.displayName, collectionName);
+    }
+    if (Array.isArray(type)) {
+        // Nested array (e.g. [['String']]) → treat as opaque JSON.
+        if (Array.isArray(type[0]))
+            return zod_1.z.array(jsonStringSchema);
+        return zod_1.z.array(buildZodSchemaForPrimitive(type[0], enumValues));
+    }
+    if (typeof type === 'object' && type !== null) {
+        return jsonStringSchema;
+    }
+    return buildZodSchemaForPrimitive(type, enumValues);
+}
+// Coerce a user-overridden value to the field's native type before updating the record.
+// The HTTP schema accepts `unknown`, so the override may be a boolean or an array; this turns
+// it into the type the datasource expects, and throws a StepStateError on mismatch.
+function coerceFieldValue(fieldSchema, value, collectionName) {
+    // Field not found, relationship (type intentionally null), or explicit null → nothing to coerce.
+    if (!fieldSchema || fieldSchema.isRelationship || value === null)
+        return value;
+    const parsed = buildZodSchemaForField(fieldSchema, collectionName).safeParse(value);
+    if (!parsed.success) {
+        throw new errors_1.StepStateError(`Invalid value for field "${fieldSchema.displayName}": ${parsed.error.issues
+            .map(issue => issue.message)
+            .join(', ')}`);
+    }
+    return parsed.data;
+}
+class UpdateRecordStepExecutor extends record_step_executor_1.default {
+    async checkIdempotency() {
+        const existing = await this.findPendingExecution('update-record');
+        if (existing?.idempotencyPhase === 'done') {
+            return this.buildOutcomeResult({ status: 'success' });
+        }
+        if (existing?.idempotencyPhase === 'executing') {
+            throw new errors_1.StepStateError('Step execution was interrupted. Please retry the step manually.');
+        }
+        return null;
+    }
+    async doExecute() {
+        // Branch A -- Re-entry after pending execution found in RunStore
+        const pending = await this.patchAndReloadPendingData(this.context.incomingPendingData);
+        if (pending) {
+            return this.handleConfirmationFlow(pending, async (exec) => {
+                const { selectedRecordRef, pendingData, userConfirmation } = exec;
+                // A user override of `null` (clearing the field) must win over the AI suggestion, so
+                // distinguish "no override" (undefined) from "override to null".
+                const rawValue = userConfirmation?.value !== undefined ? userConfirmation.value : pendingData.value;
+                const target = {
+                    selectedRecordRef,
+                    ...pendingData,
+                    // The value comes from an `unknown` HTTP value (may be a boolean or array), so coerce
+                    // it to the field's native type before updating. Idempotent on already-typed values.
+                    value: await this.coerceOverride(selectedRecordRef, pendingData, rawValue),
+                };
+                return this.resolveAndUpdate(target, exec);
+            });
+        }
+        // Branches B & C -- First call
+        return this.handleFirstCall();
+    }
+    async coerceOverride(selectedRecordRef, pendingData, value) {
+        const schema = await this.getCollectionSchema(selectedRecordRef.collectionName);
+        const fieldSchema = this.findFieldByTechnicalName(schema, pendingData?.name);
+        return coerceFieldValue(fieldSchema, value, selectedRecordRef.collectionName);
+    }
+    async handleFirstCall() {
+        const { stepDefinition: step } = this.context;
+        const { preRecordedArgs } = step;
+        const records = await this.getAvailableRecordRefs();
+        const selectedRecordRef = await this.resolveRecordRef(records, step.prompt, preRecordedArgs?.selectedRecordStepIndex);
+        const schema = await this.getCollectionSchema(selectedRecordRef.collectionName);
+        if (preRecordedArgs?.fieldName !== undefined && preRecordedArgs?.value === undefined) {
+            throw new errors_1.InvalidPreRecordedArgsError('fieldName and value must both be provided or both omitted');
+        }
+        if (preRecordedArgs?.value !== undefined && preRecordedArgs?.fieldName === undefined) {
+            throw new errors_1.InvalidPreRecordedArgsError('fieldName and value must both be provided or both omitted');
+        }
+        const recordedField = preRecordedArgs?.fieldName;
+        const { fieldName, value } = recordedField !== undefined
+            ? { fieldName: recordedField, value: preRecordedArgs?.value }
+            : await this.selectFieldAndValue(schema, step.prompt);
+        const field = this.findFieldByTechnicalName(schema, fieldName);
+        if (!field) {
+            throw new errors_1.FieldNotFoundError(fieldName, schema.collectionName);
+        }
+        const target = {
+            selectedRecordRef,
+            displayName: field.displayName,
+            name: field.fieldName,
+            value,
+        };
+        // Branch B -- fully automated execution
+        if (step.executionType === step_definition_1.StepExecutionMode.FullyAutomated) {
+            return this.resolveAndUpdate(target);
+        }
+        // Branch C -- Awaiting confirmation
+        await this.context.runStore.saveStepExecution(this.context.runId, {
+            type: 'update-record',
+            stepIndex: this.context.stepIndex,
+            pendingData: {
+                displayName: target.displayName,
+                name: target.name,
+                value: target.value,
+            },
+            selectedRecordRef: target.selectedRecordRef,
+        });
+        return this.buildOutcomeResult({ status: 'awaiting-input' });
+    }
+    // existingExecution (confirmation flow) is spread into the saved execution to preserve pendingData.
+    async resolveAndUpdate(target, existingExecution) {
+        const { selectedRecordRef, displayName, name, value } = target;
+        const updated = await this.context.agent.updateRecord({
+            collection: selectedRecordRef.collectionName,
+            id: selectedRecordRef.recordId,
+            values: { [name]: value },
+        }, {
+            beforeCall: () => this.context.runStore.saveStepExecution(this.context.runId, {
+                ...existingExecution,
+                type: 'update-record',
+                stepIndex: this.context.stepIndex,
+                selectedRecordRef,
+                idempotencyPhase: 'executing',
+            }),
+        });
+        await this.context.runStore.saveStepExecution(this.context.runId, {
+            ...existingExecution,
+            type: 'update-record',
+            stepIndex: this.context.stepIndex,
+            executionParams: { displayName, name, value },
+            executionResult: { updatedValues: updated.values },
+            selectedRecordRef,
+            idempotencyPhase: 'done',
+        });
+        return this.buildOutcomeResult({ status: 'success' });
+    }
+    async selectFieldAndValue(schema, prompt) {
+        const tool = this.buildUpdateFieldTool(schema);
+        const messages = [
+            this.buildContextMessage(),
+            ...(await this.buildPreviousStepsMessages()),
+            new ai_proxy_1.SystemMessage(UPDATE_RECORD_SYSTEM_PROMPT),
+            new ai_proxy_1.SystemMessage(`The selected record belongs to the "${schema.collectionDisplayName}" collection.`),
+            new ai_proxy_1.HumanMessage(`**Request**: ${prompt ?? 'Update the relevant field.'}`),
+        ];
+        const { input } = await this.invokeWithTool(messages, tool);
+        return {
+            fieldName: this.resolveAiFieldName(schema, input.fieldName),
+            value: input.value,
+        };
+    }
+    buildUpdateFieldTool(schema) {
+        // Exclude type-less fields: they can't be coerced/written, so offering them to the AI would
+        // let a single drifted field fail the whole step. The override path still rejects an explicit
+        // type-less target via FieldTypeMissingError.
+        const nonRelationFields = schema.fields.filter(f => !f.isRelationship && f.type != null);
+        if (nonRelationFields.length === 0) {
+            throw new errors_1.NoWritableFieldsError(schema.collectionName);
+        }
+        const fieldObjects = nonRelationFields.map(f => zod_1.z.object({
+            fieldName: zod_1.z.literal(f.displayName),
+            value: buildZodSchemaForField(f, schema.collectionName).nullable(),
+            reasoning: zod_1.z.string().describe('Why this field and value were chosen'),
+        }));
+        const inputSchema = fieldObjects.length === 1
+            ? fieldObjects[0]
+            : zod_1.z.union(fieldObjects);
+        return new ai_proxy_1.DynamicStructuredTool({
+            name: 'update-record-field',
+            description: 'Update a field on the selected record.',
+            schema: zod_1.z.object({ input: inputSchema }),
+            func: undefined,
+        });
+    }
+}
+exports.default = UpdateRecordStepExecutor;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"update-record-step-executor.js","sourceRoot":"","sources":["../../src/executors/update-record-step-executor.ts"],"names":[],"mappings":";;;;;AAKA,oDAA2F;AAC3F,6BAAwB;AAExB,sCAMmB;AACnB,kFAAwD;AACxD,wEAAuE;AAEvE,MAAM,2BAA2B,GAAG;;;;;;sFAMkD,CAAC;AAEvF,MAAM,gBAAgB,GAAG,OAAC;KACvB,MAAM,EAAE;KACR,MAAM,CACL,GAAG,CAAC,EAAE;IACJ,IAAI,CAAC;QACH,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAEhB,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC,EACD,EAAE,OAAO,EAAE,6BAA6B,EAAE,CAC3C;KACA,QAAQ,CAAC,qCAAqC,CAAC,CAAC;AAEnD,SAAS,0BAA0B,CAAC,IAAY,EAAE,UAAqB;IACrE,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,SAAS;YACZ,OAAO,OAAC,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;gBACxB,IAAI,OAAO,GAAG,KAAK,QAAQ;oBAAE,OAAO,GAAG,CAAC;gBACxC,IAAI,GAAG,KAAK,MAAM;oBAAE,OAAO,IAAI,CAAC;gBAChC,IAAI,GAAG,KAAK,OAAO;oBAAE,OAAO,KAAK,CAAC;gBAElC,OAAO,GAAG,CAAC;YACb,CAAC,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,CAAC;QAClB,KAAK,MAAM;YACT,OAAO,OAAC,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,8CAA8C,CAAC,CAAC;QACnF,KAAK,UAAU;YACb,OAAO,OAAC,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,gCAAgC,CAAC,CAAC;QACjE,KAAK,QAAQ;YACX,OAAO,OAAC,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;QAC3B,KAAK,MAAM;YACT,IAAI,UAAU,IAAI,UAAU,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;gBACzC,OAAO,OAAC,CAAC,IAAI,CAAC,UAA2C,CAAC,CAAC;YAC7D,CAAC;YAED,IAAI,UAAU,EAAE,MAAM,KAAK,CAAC;gBAAE,OAAO,OAAC,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;YAE9D,OAAO,OAAC,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,MAAM;YACT,OAAO,gBAAgB,CAAC;QAC1B,KAAK,OAAO;YACV,OAAO,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,uBAAuB,CAAC,CAAC;QACzE,4DAA4D;QAC5D;YACE,OAAO,OAAC,CAAC,MAAM,EAAE,CAAC;IACtB,CAAC;AACH,CAAC;AAED,SAAS,sBAAsB,CAAC,KAAkB,EAAE,cAAsB;IACxE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,KAAK,CAAC;IAEnC,iGAAiG;IACjG,6FAA6F;IAC7F,IAAI,IAAI,IAAI,IAAI,EAAE,CAAC;QACjB,MAAM,IAAI,8BAAqB,CAAC,KAAK,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC;IACrE,CAAC;IAED,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;QACxB,2DAA2D;QAC3D,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAAE,OAAO,OAAC,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC;QAE7D,OAAO,OAAC,CAAC,KAAK,CAAC,0BAA0B,CAAC,IAAI,CAAC,CAAC,CAAW,EAAE,UAAU,CAAC,CAAC,CAAC;IAC5E,CAAC;IAED,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;QAC9C,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IAED,OAAO,0BAA0B,CAAC,IAAc,EAAE,UAAU,CAAC,CAAC;AAChE,CAAC;AAED,wFAAwF;AACxF,8FAA8F;AAC9F,oFAAoF;AACpF,SAAS,gBAAgB,CACvB,WAAoC,EACpC,KAAc,EACd,cAAsB;IAEtB,iGAAiG;IACjG,IAAI,CAAC,WAAW,IAAI,WAAW,CAAC,cAAc,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAE/E,MAAM,MAAM,GAAG,sBAAsB,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IAEpF,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;QACpB,MAAM,IAAI,uBAAc,CACtB,4BAA4B,WAAW,CAAC,WAAW,MAAM,MAAM,CAAC,KAAK,CAAC,MAAM;aACzE,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC;aAC3B,IAAI,CAAC,IAAI,CAAC,EAAE,CAChB,CAAC;IACJ,CAAC;IAED,OAAO,MAAM,CAAC,IAAI,CAAC;AACrB,CAAC;AAMD,MAAqB,wBAAyB,SAAQ,8BAA8C;IAC/E,KAAK,CAAC,gBAAgB;QACvC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,oBAAoB,CAC9C,eAAe,CAChB,CAAC;QAEF,IAAI,QAAQ,EAAE,gBAAgB,KAAK,MAAM,EAAE,CAAC;YAC1C,OAAO,IAAI,CAAC,kBAAkB,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;QACxD,CAAC;QAED,IAAI,QAAQ,EAAE,gBAAgB,KAAK,WAAW,EAAE,CAAC;YAC/C,MAAM,IAAI,uBAAc,CAAC,iEAAiE,CAAC,CAAC;QAC9F,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAES,KAAK,CAAC,SAAS;QACvB,iEAAiE;QACjE,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,yBAAyB,CAClD,IAAI,CAAC,OAAO,CAAC,mBAAmB,CACjC,CAAC;QAEF,IAAI,OAAO,EAAE,CAAC;YACZ,OAAO,IAAI,CAAC,sBAAsB,CAAgC,OAAO,EAAE,KAAK,EAAC,IAAI,EAAC,EAAE;gBACtF,MAAM,EAAE,iBAAiB,EAAE,WAAW,EAAE,gBAAgB,EAAE,GAAG,IAAI,CAAC;gBAClE,qFAAqF;gBACrF,iEAAiE;gBACjE,MAAM,QAAQ,GACZ,gBAAgB,EAAE,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAC,WAAY,CAAC,KAAK,CAAC;gBAEtF,MAAM,MAAM,GAAiB;oBAC3B,iBAAiB;oBACjB,GAAG,WAAY;oBACf,sFAAsF;oBACtF,qFAAqF;oBACrF,KAAK,EAAE,MAAM,IAAI,CAAC,cAAc,CAAC,iBAAiB,EAAE,WAAW,EAAE,QAAQ,CAAC;iBAC3E,CAAC;gBAEF,OAAO,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;YAC7C,CAAC,CAAC,CAAC;QACL,CAAC;QAED,+BAA+B;QAC/B,OAAO,IAAI,CAAC,eAAe,EAAE,CAAC;IAChC,CAAC;IAEO,KAAK,CAAC,cAAc,CAC1B,iBAA4B,EAC5B,WAAuC,EACvC,KAAc;QAEd,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,mBAAmB,CAAC,iBAAiB,CAAC,cAAc,CAAC,CAAC;QAChF,MAAM,WAAW,GAAG,IAAI,CAAC,wBAAwB,CAAC,MAAM,EAAE,WAAW,EAAE,IAAI,CAAC,CAAC;QAE7E,OAAO,gBAAgB,CAAC,WAAW,EAAE,KAAK,EAAE,iBAAiB,CAAC,cAAc,CAAC,CAAC;IAChF,CAAC;IAEO,KAAK,CAAC,eAAe;QAC3B,MAAM,EAAE,cAAc,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC;QAC9C,MAAM,EAAE,eAAe,EAAE,GAAG,IAAI,CAAC;QACjC,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAEpD,MAAM,iBAAiB,GAAG,MAAM,IAAI,CAAC,gBAAgB,CACnD,OAAO,EACP,IAAI,CAAC,MAAM,EACX,eAAe,EAAE,uBAAuB,CACzC,CAAC;QACF,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,mBAAmB,CAAC,iBAAiB,CAAC,cAAc,CAAC,CAAC;QAEhF,IAAI,eAAe,EAAE,SAAS,KAAK,SAAS,IAAI,eAAe,EAAE,KAAK,KAAK,SAAS,EAAE,CAAC;YACrF,MAAM,IAAI,oCAA2B,CACnC,2DAA2D,CAC5D,CAAC;QACJ,CAAC;QAED,IAAI,eAAe,EAAE,KAAK,KAAK,SAAS,IAAI,eAAe,EAAE,SAAS,KAAK,SAAS,EAAE,CAAC;YACrF,MAAM,IAAI,oCAA2B,CACnC,2DAA2D,CAC5D,CAAC;QACJ,CAAC;QAED,MAAM,aAAa,GAAG,eAAe,EAAE,SAAS,CAAC;QACjD,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,GACxB,aAAa,KAAK,SAAS;YACzB,CAAC,CAAC,EAAE,SAAS,EAAE,aAAa,EAAE,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE;YAC7D,CAAC,CAAC,MAAM,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QAC1D,MAAM,KAAK,GAAG,IAAI,CAAC,wBAAwB,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;QAE/D,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,IAAI,2BAAkB,CAAC,SAAS,EAAE,MAAM,CAAC,cAAc,CAAC,CAAC;QACjE,CAAC;QAED,MAAM,MAAM,GAAiB;YAC3B,iBAAiB;YACjB,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,IAAI,EAAE,KAAK,CAAC,SAAS;YACrB,KAAK;SACN,CAAC;QAEF,wCAAwC;QACxC,IAAI,IAAI,CAAC,aAAa,KAAK,mCAAiB,CAAC,cAAc,EAAE,CAAC;YAC5D,OAAO,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;QACvC,CAAC;QAED,oCAAoC;QACpC,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE;YAChE,IAAI,EAAE,eAAe;YACrB,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,SAAS;YACjC,WAAW,EAAE;gBACX,WAAW,EAAE,MAAM,CAAC,WAAW;gBAC/B,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,KAAK,EAAE,MAAM,CAAC,KAAK;aACpB;YACD,iBAAiB,EAAE,MAAM,CAAC,iBAAiB;SAC5C,CAAC,CAAC;QAEH,OAAO,IAAI,CAAC,kBAAkB,CAAC,EAAE,MAAM,EAAE,gBAAgB,EAAE,CAAC,CAAC;IAC/D,CAAC;IAED,oGAAoG;IAC5F,KAAK,CAAC,gBAAgB,CAC5B,MAAoB,EACpB,iBAAiD;QAEjD,MAAM,EAAE,iBAAiB,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,MAAM,CAAC;QAE/D,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,YAAY,CACnD;YACE,UAAU,EAAE,iBAAiB,CAAC,cAAc;YAC5C,EAAE,EAAE,iBAAiB,CAAC,QAAQ;YAC9B,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE;SAC1B,EACD;YACE,UAAU,EAAE,GAAG,EAAE,CACf,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE;gBAC1D,GAAG,iBAAiB;gBACpB,IAAI,EAAE,eAAe;gBACrB,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,SAAS;gBACjC,iBAAiB;gBACjB,gBAAgB,EAAE,WAAW;aAC9B,CAAC;SACL,CACF,CAAC;QAEF,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE;YAChE,GAAG,iBAAiB;YACpB,IAAI,EAAE,eAAe;YACrB,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,SAAS;YACjC,eAAe,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE;YAC7C,eAAe,EAAE,EAAE,aAAa,EAAE,OAAO,CAAC,MAAM,EAAE;YAClD,iBAAiB;YACjB,gBAAgB,EAAE,MAAM;SACzB,CAAC,CAAC;QAEH,OAAO,IAAI,CAAC,kBAAkB,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;IACxD,CAAC;IAEO,KAAK,CAAC,mBAAmB,CAC/B,MAAwB,EACxB,MAA0B;QAE1B,MAAM,IAAI,GAAG,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;QAC/C,MAAM,QAAQ,GAAG;YACf,IAAI,CAAC,mBAAmB,EAAE;YAC1B,GAAG,CAAC,MAAM,IAAI,CAAC,0BAA0B,EAAE,CAAC;YAC5C,IAAI,wBAAa,CAAC,2BAA2B,CAAC;YAC9C,IAAI,wBAAa,CACf,uCAAuC,MAAM,CAAC,qBAAqB,eAAe,CACnF;YACD,IAAI,uBAAY,CAAC,gBAAgB,MAAM,IAAI,4BAA4B,EAAE,CAAC;SAC3E,CAAC;QAEF,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,cAAc,CAExC,QAAQ,EAAE,IAAI,CAAC,CAAC;QAEnB,OAAO;YACL,SAAS,EAAE,IAAI,CAAC,kBAAkB,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC;YAC3D,KAAK,EAAE,KAAK,CAAC,KAAK;SACnB,CAAC;IACJ,CAAC;IAEO,oBAAoB,CAAC,MAAwB;QACnD,4FAA4F;QAC5F,8FAA8F;QAC9F,8CAA8C;QAC9C,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,cAAc,IAAI,CAAC,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC;QAEzF,IAAI,iBAAiB,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACnC,MAAM,IAAI,8BAAqB,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;QACzD,CAAC;QAQD,MAAM,YAAY,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAC7C,OAAC,CAAC,MAAM,CAAC;YACP,SAAS,EAAE,OAAC,CAAC,OAAO,CAAC,CAAC,CAAC,WAAW,CAAC;YACnC,KAAK,EAAE,sBAAsB,CAAC,CAAC,EAAE,MAAM,CAAC,cAAc,CAAC,CAAC,QAAQ,EAAE;YAClE,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,sCAAsC,CAAC;SACvE,CAAC,CACc,CAAC;QAEnB,MAAM,WAAW,GACf,YAAY,CAAC,MAAM,KAAK,CAAC;YACvB,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC;YACjB,CAAC,CAAC,OAAC,CAAC,KAAK,CAAC,YAA4D,CAAC,CAAC;QAE5E,OAAO,IAAI,gCAAqB,CAAC;YAC/B,IAAI,EAAE,qBAAqB;YAC3B,WAAW,EAAE,wCAAwC;YACrD,MAAM,EAAE,OAAC,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC;YACxC,IAAI,EAAE,SAAS;SAChB,CAAC,CAAC;IACL,CAAC;CACF;AA3ND,2CA2NC"}

package/dist/http/executor-http-server.d.ts

@@ -0,0 +1,25 @@
+import type { Logger } from '../ports/logger-port';
+import type { WorkflowPort } from '../ports/workflow-port';
+import type Runner from '../runner';
+import http from 'http';
+export interface ExecutorHttpServerOptions {
+    port: number;
+    runner: Runner;
+    authSecret: string;
+    workflowPort: WorkflowPort;
+    logger?: Logger;
+}
+export default class ExecutorHttpServer {
+    private readonly app;
+    private readonly options;
+    private readonly logger;
+    private server;
+    constructor(options: ExecutorHttpServerOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    get callback(): (req: http.IncomingMessage | import("http2").Http2ServerRequest, res: http.ServerResponse | import("http2").Http2ServerResponse) => Promise<void>;
+    private hasRunAccessMiddleware;
+    private handleGetRun;
+    private handleTrigger;
+}
+//# sourceMappingURL=executor-http-server.d.ts.map