@forestadmin/workflow-executor 1.0.0

package/dist/executors/base-step-executor.js

@@ -0,0 +1,267 @@
+"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 errors_1 = require("../errors");
+const pending_data_validators_1 = __importDefault(require("../http/pending-data-validators"));
+const step_summary_builder_1 = __importDefault(require("./summary/step-summary-builder"));
+class BaseStepExecutor {
+    constructor(context) {
+        this.context = context;
+    }
+    async execute() {
+        const { baseRecordRef } = this.context;
+        this.context.logger.info('Step execution started', {
+            ...this.logCtx,
+            collection: baseRecordRef.collectionName,
+        });
+        try {
+            // Idempotency guard — mutating executors override this. Runs before doExecute so a cache
+            // hit or uncertain-state error short-circuits before any side effect.
+            const cached = await this.checkIdempotency();
+            if (cached) {
+                this.context.logger.info('Step execution completed (replayed from cache)', {
+                    ...this.logCtx,
+                    status: cached.stepOutcome.status,
+                });
+                return cached;
+            }
+            const result = await this.runWithTimeout();
+            this.context.logger.info('Step execution completed', {
+                ...this.logCtx,
+                status: result.stepOutcome.status,
+            });
+            return result;
+        }
+        catch (error) {
+            if (error instanceof errors_1.StepTimeoutError) {
+                this.context.logger.error(error.message, {
+                    ...this.logCtx,
+                    timeoutMs: this.context.stepTimeoutMs,
+                });
+                return this.buildOutcomeResult({ status: 'error', error: error.userMessage });
+            }
+            if (error instanceof errors_1.WorkflowExecutorError) {
+                this.context.logger.error(error.message, {
+                    ...this.logCtx,
+                    cause: (0, errors_1.extractErrorMessage)(error.cause),
+                    stack: error.cause instanceof Error ? error.cause.stack : undefined,
+                });
+                return this.buildOutcomeResult({ status: 'error', error: error.userMessage });
+            }
+            const { cause: errorCause } = error;
+            this.context.logger.error('Unexpected error during step execution', {
+                ...this.logCtx,
+                error: (0, errors_1.extractErrorMessage)(error),
+                cause: (0, errors_1.extractErrorMessage)(errorCause),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            return this.buildOutcomeResult({
+                status: 'error',
+                error: 'Unexpected error during step execution',
+            });
+        }
+    }
+    checkIdempotency() {
+        return Promise.resolve(null);
+    }
+    // Promise.race doesn't abort the losing branch — it keeps running in the background. The .catch()
+    // on execPromise must be attached BEFORE the race so a late rejection doesn't trigger
+    // UnhandledPromiseRejection. Late resolutions are silently discarded.
+    async runWithTimeout() {
+        const timeoutMs = this.context.stepTimeoutMs;
+        if (!timeoutMs || timeoutMs <= 0)
+            return this.doExecute();
+        let timer;
+        let hasTimeoutFired = false;
+        const execPromise = this.doExecute();
+        execPromise.catch(err => {
+            if (!hasTimeoutFired)
+                return;
+            this.context.logger.warn('Step work rejected after timeout — result discarded', {
+                ...this.logCtx,
+                error: (0, errors_1.extractErrorMessage)(err),
+            });
+        });
+        try {
+            return await Promise.race([
+                execPromise,
+                new Promise((_, reject) => {
+                    timer = setTimeout(() => {
+                        hasTimeoutFired = true;
+                        reject(new errors_1.StepTimeoutError(timeoutMs));
+                    }, timeoutMs);
+                }),
+            ]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    async findPendingExecution(type) {
+        const stepExecutions = await this.context.runStore.getStepExecutions(this.context.runId);
+        return stepExecutions.find((e) => e.type === type && e.stepIndex === this.context.stepIndex);
+    }
+    async patchAndReloadPendingData(pendingData) {
+        const { type } = this.context.stepDefinition;
+        const execution = await this.findPendingExecution(type);
+        if (!execution)
+            return undefined;
+        if (pendingData === undefined)
+            return execution;
+        const schema = pending_data_validators_1.default[execution.type];
+        if (!schema) {
+            throw new errors_1.StepStateError(`No pending-data validator registered for step type "${execution.type}"`);
+        }
+        const parsed = schema.safeParse(pendingData);
+        if (!parsed.success) {
+            throw new errors_1.StepStateError(`Invalid pending data: ${parsed.error.issues.map(i => i.message).join(', ')}`);
+        }
+        const userConfirmation = parsed.data;
+        const updated = {
+            ...execution,
+            userConfirmation,
+        };
+        await this.context.runStore.saveStepExecution(this.context.runId, updated);
+        return updated;
+    }
+    // userConfirmed branches: undefined → re-emit awaiting-input (POST not yet called);
+    // false → save as skipped + success outcome; true → resolveAndExecute.
+    async handleConfirmationFlow(execution, resolveAndExecute) {
+        if (!execution.pendingData) {
+            throw new errors_1.StepStateError(`Step at index ${this.context.stepIndex} has no pending data`);
+        }
+        const { userConfirmed } = execution.userConfirmation ?? {};
+        if (userConfirmed === undefined) {
+            return this.buildOutcomeResult({ status: 'awaiting-input' });
+        }
+        if (!userConfirmed) {
+            await this.context.runStore.saveStepExecution(this.context.runId, {
+                ...execution,
+                executionResult: { skipped: true },
+            });
+            return this.buildOutcomeResult({ status: 'success' });
+        }
+        return resolveAndExecute(execution);
+    }
+    buildContextMessage() {
+        const { user, stepDefinition } = this.context;
+        const now = new Date();
+        const lines = [
+            `Step executed by: ${user.firstName} ${user.lastName} (${user.email}, id: ${user.id})`,
+            `Role: ${user.role} | Team: ${user.team}`,
+            `Current date and time: ${now.toISOString()} (UTC)`,
+        ];
+        // Fall back to the step title only when there is no prompt — the prompt, when present, is the
+        // authoritative intent (surfaced by each executor), so the title would just be noise.
+        if (!stepDefinition.prompt?.trim() && stepDefinition.title) {
+            lines.push(`Step title: "${stepDefinition.title}"`);
+        }
+        return new ai_proxy_1.SystemMessage(lines.join('\n'));
+    }
+    async buildPreviousStepsMessages() {
+        if (!this.context.previousSteps.length)
+            return [];
+        const allStepExecutions = await this.context.runStore.getStepExecutions(this.context.runId);
+        const summary = this.context.previousSteps
+            .map(step => {
+            const execution = this.resolveStepExecution(step, allStepExecutions);
+            return step_summary_builder_1.default.build(step.stepDefinition, step.stepOutcome, execution);
+        })
+            .join('\n\n');
+        return [new ai_proxy_1.SystemMessage(summary)];
+    }
+    // A step the executor ran has its execution at its own stepIndex. A revision clone never ran,
+    // so it inherits the record of the step it copied (originalStepIndex). Own-index-first is what
+    // stops a re-executed step (which has its own entry) from resurfacing the superseded
+    // original's record.
+    resolveStepExecution(step, executions) {
+        const own = executions.find(e => e.stepIndex === step.stepOutcome.stepIndex);
+        if (own)
+            return own;
+        // An errored clone persists nothing, so inheriting the copied record would resurface the
+        // superseded original's — only fall back when the clone didn't run-and-fail.
+        if (step.originalStepIndex !== undefined && step.stepOutcome.status !== 'error') {
+            return executions.find(e => e.stepIndex === step.originalStepIndex);
+        }
+        return undefined;
+    }
+    static mergeLeadingSystemMessages(messages) {
+        let i = 0;
+        while (i < messages.length && messages[i] instanceof ai_proxy_1.SystemMessage)
+            i += 1;
+        if (i <= 1)
+            return messages;
+        const merged = new ai_proxy_1.SystemMessage(messages
+            .slice(0, i)
+            .map(m => (typeof m.content === 'string' ? m.content : JSON.stringify(m.content)))
+            .filter(Boolean)
+            .join('\n\n'));
+        return [merged, ...messages.slice(i)];
+    }
+    static assertNoMidArraySystemMessages(messages) {
+        let seenNonSystem = false;
+        for (let i = 0; i < messages.length; i += 1) {
+            if (!(messages[i] instanceof ai_proxy_1.SystemMessage)) {
+                seenNonSystem = true;
+            }
+            else if (seenNonSystem) {
+                throw new errors_1.InvalidAiRequestError(`SystemMessage at position ${i} appears after a non-system message — move all system context to the front of the messages array.`);
+            }
+        }
+    }
+    async invokeWithTools(messages, tools) {
+        BaseStepExecutor.assertNoMidArraySystemMessages(messages);
+        const modelWithTools = this.context.model.bindTools(tools, { tool_choice: 'any' });
+        const preparedMessages = BaseStepExecutor.mergeLeadingSystemMessages(messages);
+        const aiTimeoutMs = this.context.aiInvokeTimeoutMs;
+        const timeoutMs = aiTimeoutMs && aiTimeoutMs > 0 ? aiTimeoutMs : undefined;
+        const signal = timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined;
+        let response;
+        try {
+            // `signal: undefined` is equivalent to passing no options — LangChain leaves the call un-timed.
+            response = await modelWithTools.invoke(preparedMessages, { signal });
+        }
+        catch (err) {
+            // Detect the timeout via our own signal, not the thrown error's name: providers wrap an
+            // aborted request differently (AbortError, TimeoutError, APIUserAbortError, …).
+            if (timeoutMs !== undefined && signal?.aborted)
+                throw new errors_1.AiInvokeTimeoutError(timeoutMs);
+            throw err;
+        }
+        const toolCall = response.tool_calls?.[0];
+        if (toolCall !== undefined) {
+            if (toolCall.args !== undefined && toolCall.args !== null) {
+                return { toolName: toolCall.name, args: toolCall.args };
+            }
+            throw new errors_1.MalformedToolCallError(toolCall.name ?? 'unknown', 'args field is missing or null');
+        }
+        const invalidCall = response.invalid_tool_calls?.[0];
+        if (invalidCall) {
+            throw new errors_1.MalformedToolCallError(invalidCall.name ?? 'unknown', invalidCall.error ?? 'no details available');
+        }
+        throw new errors_1.MissingToolCallError();
+    }
+    async invokeWithTool(messages, tool) {
+        return (await this.invokeWithTools(messages, [tool])).args;
+    }
+    // Overridden by executors that carry type-specific log identifiers (e.g. McpStepExecutor).
+    getExtraLogContext() {
+        return {};
+    }
+    get logCtx() {
+        const { runId, stepId, stepIndex, stepDefinition } = this.context;
+        return {
+            runId,
+            stepId,
+            stepIndex,
+            stepType: stepDefinition.type,
+            ...this.getExtraLogContext(),
+        };
+    }
+}
+exports.default = BaseStepExecutor;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-step-executor.js","sourceRoot":"","sources":["../../src/executors/base-step-executor.ts"],"names":[],"mappings":"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"}

package/dist/executors/condition-step-executor.d.ts

@@ -0,0 +1,15 @@
+import type { StepExecutionResult } from '../types/execution-context';
+import type { ConditionStepDefinition } from '../types/validated/step-definition';
+import type { ConditionStepOutcome } from '../types/validated/step-outcome';
+import BaseStepExecutor from './base-step-executor';
+export default class ConditionStepExecutor extends BaseStepExecutor<ConditionStepDefinition> {
+    protected buildOutcomeResult(outcome: {
+        status: ConditionStepOutcome['status'];
+        error?: string;
+        selectedOption?: string;
+    }): StepExecutionResult;
+    protected doExecute(): Promise<StepExecutionResult>;
+    private readUserChoice;
+    private askAi;
+}
+//# sourceMappingURL=condition-step-executor.d.ts.map

package/dist/executors/condition-step-executor.js

@@ -0,0 +1,108 @@
+"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 base_step_executor_1 = __importDefault(require("./base-step-executor"));
+const pending_data_validators_1 = __importDefault(require("../http/pending-data-validators"));
+const step_definition_1 = require("../types/validated/step-definition");
+const GATEWAY_SYSTEM_PROMPT = `You are an AI agent selecting the correct option for a workflow gateway decision.
+
+**Task**: Analyze the question and available options, then select the option that DIRECTLY answers the question. Options must be literal answers, not interpretations.
+
+**Critical Rule**: Options must semantically match possible answers to the question.
+- Question "Does X contain Y?" expects options like "yes"/"no", NOT colors or unrelated values
+- Question "What is the status?" expects options like "active"/"inactive", NOT arbitrary words
+- If options don't match expected answer types, select null
+
+**NEVER invent mappings** between options and answers (e.g., never assume "purple"="no" or "red"="yes")
+
+**When to select null**:
+- Options are semantically unrelated to the question type (colors for yes/no questions)
+- None of the options literally match the expected answer
+- The question is ambiguous or lacks necessary context
+- You are less than 80% confident in any option
+
+**Reasoning format**:
+- State which option you selected and why
+- If selecting null: explain why options don't match the question
+- Do not refer to yourself as "I" in the response, use a passive formulation instead.`;
+class ConditionStepExecutor extends base_step_executor_1.default {
+    buildOutcomeResult(outcome) {
+        return {
+            stepOutcome: {
+                type: 'condition',
+                stepId: this.context.stepId,
+                stepIndex: this.context.stepIndex,
+                ...outcome,
+            },
+        };
+    }
+    async doExecute() {
+        const { stepDefinition: step, incomingPendingData } = this.context;
+        // Manual mode: the user picks the option from the frontend. Wait for their input
+        // without ever calling the AI.
+        const isManual = step.executionType === step_definition_1.StepExecutionMode.Manual;
+        if (isManual && incomingPendingData === undefined) {
+            return this.buildOutcomeResult({ status: 'awaiting-input' });
+        }
+        const { selectedOption, reasoning } = incomingPendingData !== undefined
+            ? this.readUserChoice(step, incomingPendingData)
+            : await this.askAi(step);
+        await this.context.runStore.saveStepExecution(this.context.runId, {
+            type: 'condition',
+            stepIndex: this.context.stepIndex,
+            executionParams: { answer: selectedOption, reasoning },
+            executionResult: selectedOption ? { answer: selectedOption } : undefined,
+        });
+        if (!selectedOption) {
+            return this.buildOutcomeResult({
+                status: 'error',
+                error: "The AI couldn't decide. Try rephrasing the step's prompt.",
+            });
+        }
+        return this.buildOutcomeResult({ status: 'success', selectedOption });
+    }
+    readUserChoice(step, incomingPendingData) {
+        const parsed = pending_data_validators_1.default.condition.safeParse(incomingPendingData);
+        if (!parsed.success) {
+            throw new errors_1.StepStateError(`Invalid condition input: ${parsed.error.issues.map(i => i.message).join(', ')}`);
+        }
+        const { selectedOption } = parsed.data;
+        if (!step.options.includes(selectedOption)) {
+            const allowed = step.options.join(', ');
+            throw new errors_1.StepStateError(`Option "${selectedOption}" is not a valid choice (expected one of: ${allowed})`);
+        }
+        return { selectedOption, reasoning: 'Selected by user' };
+    }
+    async askAi(step) {
+        const tool = new ai_proxy_1.DynamicStructuredTool({
+            name: 'choose-gateway-option',
+            description: 'Select the option that answers the question. ' +
+                'Use null if no option matches or you are uncertain. ' +
+                'Explain your reasoning.',
+            schema: zod_1.z.object({
+                reasoning: zod_1.z.string().describe('The reasoning behind the choice'),
+                question: zod_1.z.string().describe('The question to answer by choosing an option'),
+                option: zod_1.z
+                    .enum(step.options)
+                    .nullable()
+                    .describe('The chosen option, or null if no option clearly answers the question.'),
+            }),
+            func: undefined,
+        });
+        const messages = [
+            this.buildContextMessage(),
+            ...(await this.buildPreviousStepsMessages()),
+            new ai_proxy_1.SystemMessage(GATEWAY_SYSTEM_PROMPT),
+            new ai_proxy_1.HumanMessage(`**Question**: ${step.prompt ?? 'Choose the most appropriate option.'}`),
+        ];
+        const args = await this.invokeWithTool(messages, tool);
+        return { selectedOption: args.option, reasoning: args.reasoning };
+    }
+}
+exports.default = ConditionStepExecutor;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/executors/guidance-step-executor.d.ts

@@ -0,0 +1,12 @@
+import type { StepExecutionResult } from '../types/execution-context';
+import type { GuidanceStepDefinition } from '../types/validated/step-definition';
+import type { RecordStepStatus } from '../types/validated/step-outcome';
+import BaseStepExecutor from './base-step-executor';
+export default class GuidanceStepExecutor extends BaseStepExecutor<GuidanceStepDefinition> {
+    protected doExecute(): Promise<StepExecutionResult>;
+    protected buildOutcomeResult(outcome: {
+        status: RecordStepStatus;
+        error?: string;
+    }): StepExecutionResult;
+}
+//# sourceMappingURL=guidance-step-executor.d.ts.map

package/dist/executors/guidance-step-executor.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../errors");
+const base_step_executor_1 = __importDefault(require("./base-step-executor"));
+const pending_data_validators_1 = __importDefault(require("../http/pending-data-validators"));
+class GuidanceStepExecutor extends base_step_executor_1.default {
+    async doExecute() {
+        const { incomingPendingData } = this.context;
+        if (!incomingPendingData) {
+            return this.buildOutcomeResult({ status: 'awaiting-input' });
+        }
+        const parsed = pending_data_validators_1.default.guidance.safeParse(incomingPendingData);
+        if (!parsed.success) {
+            throw new errors_1.StepStateError(`Invalid guidance input: ${parsed.error.issues.map(i => i.message).join(', ')}`);
+        }
+        const { userInput } = parsed.data;
+        await this.context.runStore.saveStepExecution(this.context.runId, {
+            type: 'guidance',
+            stepIndex: this.context.stepIndex,
+            executionResult: { userInput: userInput ?? '' },
+        });
+        return this.buildOutcomeResult({ status: 'success' });
+    }
+    buildOutcomeResult(outcome) {
+        return {
+            stepOutcome: {
+                type: 'guidance',
+                stepId: this.context.stepId,
+                stepIndex: this.context.stepIndex,
+                ...outcome,
+            },
+        };
+    }
+}
+exports.default = GuidanceStepExecutor;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ3VpZGFuY2Utc3RlcC1leGVjdXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9leGVjdXRvcnMvZ3VpZGFuY2Utc3RlcC1leGVjdXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUlBLHNDQUEyQztBQUMzQyw4RUFBb0Q7QUFDcEQsOEZBQStEO0FBRS9ELE1BQXFCLG9CQUFxQixTQUFRLDRCQUF3QztJQUM5RSxLQUFLLENBQUMsU0FBUztRQUN2QixNQUFNLEVBQUUsbUJBQW1CLEVBQUUsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDO1FBRTdDLElBQUksQ0FBQyxtQkFBbUIsRUFBRSxDQUFDO1lBQ3pCLE9BQU8sSUFBSSxDQUFDLGtCQUFrQixDQUFDLEVBQUUsTUFBTSxFQUFFLGdCQUFnQixFQUFFLENBQUMsQ0FBQztRQUMvRCxDQUFDO1FBRUQsTUFBTSxNQUFNLEdBQUcsaUNBQWdCLENBQUMsUUFBUSxDQUFDLFNBQVMsQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDO1FBRXhFLElBQUksQ0FBQyxNQUFNLENBQUMsT0FBTyxFQUFFLENBQUM7WUFDcEIsTUFBTSxJQUFJLHVCQUFjLENBQ3RCLDJCQUEyQixNQUFNLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQ2hGLENBQUM7UUFDSixDQUFDO1FBRUQsTUFBTSxFQUFFLFNBQVMsRUFBRSxHQUFHLE1BQU0sQ0FBQyxJQUE4QixDQUFDO1FBRTVELE1BQU0sSUFBSSxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsaUJBQWlCLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxLQUFLLEVBQUU7WUFDaEUsSUFBSSxFQUFFLFVBQVU7WUFDaEIsU0FBUyxFQUFFLElBQUksQ0FBQyxPQUFPLENBQUMsU0FBUztZQUNqQyxlQUFlLEVBQUUsRUFBRSxTQUFTLEVBQUUsU0FBUyxJQUFJLEVBQUUsRUFBRTtTQUNoRCxDQUFDLENBQUM7UUFFSCxPQUFPLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxFQUFFLE1BQU0sRUFBRSxTQUFTLEVBQUUsQ0FBQyxDQUFDO0lBQ3hELENBQUM7SUFFUyxrQkFBa0IsQ0FBQyxPQUc1QjtRQUNDLE9BQU87WUFDTCxXQUFXLEVBQUU7Z0JBQ1gsSUFBSSxFQUFFLFVBQVU7Z0JBQ2hCLE1BQU0sRUFBRSxJQUFJLENBQUMsT0FBTyxDQUFDLE1BQU07Z0JBQzNCLFNBQVMsRUFBRSxJQUFJLENBQUMsT0FBTyxDQUFDLFNBQVM7Z0JBQ2pDLEdBQUcsT0FBTzthQUNYO1NBQ0YsQ0FBQztJQUNKLENBQUM7Q0FDRjtBQXhDRCx1Q0F3Q0MifQ==

package/dist/executors/load-related-record-step-executor.d.ts

@@ -0,0 +1,38 @@
+import type { StepExecutionResult } from '../types/execution-context';
+import type { LoadRelatedRecordStepDefinition } from '../types/validated/step-definition';
+import RecordStepExecutor from './record-step-executor';
+export default class LoadRelatedRecordStepExecutor extends RecordStepExecutor<LoadRelatedRecordStepDefinition> {
+    protected doExecute(): Promise<StepExecutionResult>;
+    private refreshCandidatesForField;
+    private handleFirstCall;
+    private resolveTarget;
+    private targetFromCandidate;
+    private requireRecordAtStepIndex;
+    private buildRelationCandidates;
+    private buildTarget;
+    private saveAndAwaitInput;
+    private collectCandidateIds;
+    private extractReferenceFieldValue;
+    /** Branch B: fully automated. xToOne loads the linked record; HasMany ranks candidates via AI; BelongsToMany takes the first. */
+    private resolveAndLoadAutomatic;
+    private fetchRecordForRelation;
+    private fetchXToOneRecordRef;
+    private fetchXToOneCandidate;
+    private resolveFromSelection;
+    private selectBestFromRelatedData;
+    /** HasMany + fully automated execution: fetch top 50, then AI calls to select the best record. */
+    private selectBestRelatedRecord;
+    private fetchFirstCandidate;
+    private fetchCandidates;
+    private fetchRelatedData;
+    /** Persists the loaded record ref and returns a success outcome. */
+    private persistAndReturn;
+    private relationOptionLabel;
+    private selectRelationToFollow;
+    /** AI call 1 for HasMany: selects the most relevant fields to compare candidates. */
+    private selectRelevantFields;
+    /** AI call 2 for HasMany: selects the best record by index from the candidate list. */
+    private selectBestRecordIndex;
+    private toRecordRef;
+}
+//# sourceMappingURL=load-related-record-step-executor.d.ts.map