@forestadmin/workflow-executor 1.0.0

package/dist/executors/load-related-record-step-executor.js

@@ -0,0 +1,478 @@
+"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 SELECT_RELATION_SYSTEM_PROMPT = `You are an AI agent loading a related record based on a user request.
+You are given relations to follow, each shown as "<source record> → <relation> (→ <target collection>)".
+Choose the relation that LEADS TO the collection the user wants to load — decide from each
+relation's target collection, NOT from which source record happens to resemble the request.
+
+Important rules:
+- Pick the relation whose target collection matches the requested record.
+- 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 SELECT_FIELDS_SYSTEM_PROMPT = `You are an AI agent selecting the most relevant fields to identify a related record.
+Choose the fields that are most useful for determining which record best matches the user request.`;
+const SELECT_RECORD_SYSTEM_PROMPT = `You are an AI agent selecting the most relevant related record from a list of candidates.
+Choose the record that best matches the user request based on the provided field values.`;
+// Bound only what is sent to the AI in selectBestRecordIndex — the full candidate list is
+// always returned to the front via availableRecordIds. These cap the prompt size, not the data.
+const MAX_RELEVANT_FIELDS = 6;
+const MAX_FIELD_VALUE_LENGTH = 80; // per-field serialized length before truncation
+const MAX_AI_CANDIDATES_CHARS = 16000; // global budget for the `Candidates:` block (~4k tokens)
+function clampFieldValue(value) {
+    const serialized = typeof value === 'string' ? value : JSON.stringify(value) ?? '';
+    if (serialized.length <= MAX_FIELD_VALUE_LENGTH)
+        return value;
+    return `${serialized.slice(0, MAX_FIELD_VALUE_LENGTH)}… (truncated)`;
+}
+class LoadRelatedRecordStepExecutor extends record_step_executor_1.default {
+    async doExecute() {
+        // Branch A -- Re-entry after pending execution found in RunStore
+        const pending = await this.patchAndReloadPendingData(this.context.incomingPendingData);
+        if (pending) {
+            const conf = pending.userConfirmation;
+            if (conf?.userConfirmed === undefined && conf?.fieldName !== undefined) {
+                return this.refreshCandidatesForField(pending, conf.fieldName);
+            }
+            return this.handleConfirmationFlow(pending, async (exec) => this.resolveFromSelection(exec));
+        }
+        // Branches B & C -- First call
+        return this.handleFirstCall();
+    }
+    async refreshCandidatesForField(execution, fieldName) {
+        if (!execution.pendingData) {
+            throw new errors_1.StepStateError(`Step at index ${this.context.stepIndex} has no pending data`);
+        }
+        const schema = await this.getCollectionSchema(execution.selectedRecordRef.collectionName);
+        const target = this.buildTarget(schema, fieldName, execution.selectedRecordRef);
+        const { availableRecordIds, suggestedRecord } = await this.collectCandidateIds(target);
+        await this.context.runStore.saveStepExecution(this.context.runId, {
+            ...execution,
+            userConfirmation: undefined,
+            pendingData: {
+                ...execution.pendingData,
+                suggestedField: { name: target.name, displayName: target.displayName },
+                availableRecordIds,
+                suggestedRecord,
+            },
+        });
+        return this.buildOutcomeResult({ status: 'awaiting-input' });
+    }
+    async handleFirstCall() {
+        const { stepDefinition: step } = this.context;
+        const target = await this.resolveTarget();
+        // Branch B -- fully automated execution
+        if (step.executionType === step_definition_1.StepExecutionMode.FullyAutomated) {
+            return this.resolveAndLoadAutomatic(target);
+        }
+        // Branch C -- pre-fetch candidates, await user confirmation
+        const sourceSchema = await this.getCollectionSchema(target.selectedRecordRef.collectionName);
+        return this.saveAndAwaitInput(target, sourceSchema);
+    }
+    // Picks the (record, relation) pair to follow. Unlike a separate record-then-relation choice,
+    // this lets the AI decide by what each relation LEADS TO — so "load the dvd" follows
+    // store→dvds rather than latching onto a previously-loaded dvd whose collection just matches.
+    async resolveTarget() {
+        const { preRecordedArgs } = this.context.stepDefinition;
+        const records = await this.getAvailableRecordRefs();
+        const sourceRecords = preRecordedArgs?.selectedRecordStepIndex !== undefined
+            ? [this.requireRecordAtStepIndex(records, preRecordedArgs.selectedRecordStepIndex)]
+            : records;
+        const candidates = await this.buildRelationCandidates(sourceRecords);
+        if (candidates.length === 0) {
+            throw new errors_1.NoRelationshipFieldsError(sourceRecords[0]?.collectionName ?? 'unknown');
+        }
+        // Pre-recorded relations are pinned by their stable technical name (PRD-426), matched exactly.
+        const pinned = preRecordedArgs?.relationName;
+        const eligible = pinned ? candidates.filter(c => c.field.fieldName === pinned) : candidates;
+        if (eligible.length === 0) {
+            // Relations exist, but the pre-recorded one doesn't match any of them.
+            throw new errors_1.InvalidPreRecordedArgsError(`No relation matching "${pinned}" on the selected record`);
+        }
+        const chosen = eligible.length === 1 ? eligible[0] : await this.selectRelationToFollow(eligible);
+        return this.targetFromCandidate(chosen);
+    }
+    targetFromCandidate(candidate) {
+        const { record, field } = candidate;
+        return {
+            selectedRecordRef: record,
+            displayName: field.displayName,
+            name: field.fieldName,
+            relationType: field.relationType,
+            relatedCollectionName: field.relatedCollectionName,
+        };
+    }
+    requireRecordAtStepIndex(records, stepIndex) {
+        const match = records.find(r => r.stepIndex === stepIndex);
+        if (!match) {
+            throw new errors_1.InvalidPreRecordedArgsError(`No record found at step index ${stepIndex}`);
+        }
+        return match;
+    }
+    async buildRelationCandidates(records) {
+        const candidates = [];
+        for (const record of records) {
+            // eslint-disable-next-line no-await-in-loop
+            const schema = await this.getCollectionSchema(record.collectionName);
+            for (const field of schema.fields) {
+                if (field.isRelationship && field.relatedCollectionName) {
+                    candidates.push({
+                        record,
+                        schema,
+                        field: { ...field, relatedCollectionName: field.relatedCollectionName },
+                    });
+                }
+            }
+        }
+        return candidates;
+    }
+    buildTarget(schema, relationName, selectedRecordRef) {
+        const field = this.findFieldByTechnicalName(schema, relationName);
+        if (!field) {
+            throw new errors_1.RelationNotFoundError(relationName, schema.collectionName);
+        }
+        if (!field.relatedCollectionName) {
+            throw new errors_1.StepStateError(`Step at index ${this.context.stepIndex} could not resolve relatedCollectionName for relation "${relationName}"`);
+        }
+        return {
+            selectedRecordRef,
+            displayName: field.displayName,
+            name: field.fieldName,
+            relationType: field.relationType,
+            relatedCollectionName: field.relatedCollectionName,
+        };
+    }
+    // Branch C: AI suggests the best candidate, then awaits user confirmation. Save errors
+    // propagate directly — the relation-load hasn't run yet, so the step can be safely retried.
+    async saveAndAwaitInput(target, sourceSchema) {
+        const { selectedRecordRef, name, displayName } = target;
+        const { availableRecordIds, suggestedRecord } = await this.collectCandidateIds(target);
+        const availableFields = sourceSchema.fields
+            .filter(f => f.isRelationship)
+            .map(f => ({ name: f.fieldName, displayName: f.displayName }));
+        await this.context.runStore.saveStepExecution(this.context.runId, {
+            type: 'load-related-record',
+            stepIndex: this.context.stepIndex,
+            pendingData: {
+                availableFields,
+                suggestedField: { name, displayName },
+                availableRecordIds,
+                suggestedRecord,
+            },
+            selectedRecordRef,
+        });
+        return this.buildOutcomeResult({ status: 'awaiting-input' });
+    }
+    async collectCandidateIds(target) {
+        if (target.relationType === 'BelongsTo' || target.relationType === 'HasOne') {
+            const candidate = await this.fetchXToOneCandidate(target);
+            return candidate
+                ? { availableRecordIds: [candidate], suggestedRecord: candidate }
+                : { availableRecordIds: [] };
+        }
+        const { relatedData, bestIndex, relatedSchema } = await this.selectBestFromRelatedData(target, 50);
+        if (relatedData.length === 0) {
+            return { availableRecordIds: [] };
+        }
+        const referenceField = relatedSchema.referenceField ?? null;
+        const toCandidate = (r) => ({
+            recordId: r.recordId,
+            referenceFieldValue: referenceField
+                ? this.extractReferenceFieldValue(r.values, referenceField)
+                : null,
+        });
+        return {
+            availableRecordIds: relatedData.map(toCandidate),
+            suggestedRecord: toCandidate(relatedData[bestIndex]),
+        };
+    }
+    extractReferenceFieldValue(values, referenceField) {
+        const v = values[referenceField];
+        return v === undefined || v === null ? null : String(v);
+    }
+    /** Branch B: fully automated. xToOne loads the linked record; HasMany ranks candidates via AI; BelongsToMany takes the first. */
+    async resolveAndLoadAutomatic(target) {
+        const record = await this.fetchRecordForRelation(target);
+        return this.persistAndReturn(record, target, undefined);
+    }
+    async fetchRecordForRelation(target) {
+        if (target.relationType === 'BelongsTo' || target.relationType === 'HasOne') {
+            return this.fetchXToOneRecordRef(target);
+        }
+        if (target.relationType === 'HasMany') {
+            return this.selectBestRelatedRecord(target);
+        }
+        return this.fetchFirstCandidate(target);
+    }
+    async fetchXToOneRecordRef(target) {
+        const candidate = await this.fetchXToOneCandidate(target);
+        if (!candidate) {
+            throw new errors_1.RelatedRecordNotFoundError(target.selectedRecordRef.collectionName, target.name);
+        }
+        return {
+            collectionName: target.relatedCollectionName,
+            recordId: candidate.recordId,
+            stepIndex: this.context.stepIndex,
+        };
+    }
+    async fetchXToOneCandidate(target) {
+        const relatedSchema = await this.getCollectionSchema(target.relatedCollectionName);
+        const referenceField = relatedSchema.referenceField ?? null;
+        const candidate = await this.context.agent.getSingleRelatedData({
+            collection: target.selectedRecordRef.collectionName,
+            id: target.selectedRecordRef.recordId,
+            relation: target.name,
+            relatedSchema,
+            ...(referenceField && { fields: [referenceField] }),
+        });
+        if (!candidate)
+            return null;
+        return {
+            recordId: candidate.recordId,
+            referenceFieldValue: referenceField
+                ? this.extractReferenceFieldValue(candidate.values, referenceField)
+                : null,
+        };
+    }
+    // Branch A: builds RecordRef from the user-confirmed selection without a new getRelatedData call.
+    async resolveFromSelection(execution) {
+        const { selectedRecordRef, pendingData, userConfirmation } = execution;
+        if (!pendingData) {
+            throw new errors_1.StepStateError(`Step at index ${this.context.stepIndex} has no pending data`);
+        }
+        const relationRef = userConfirmation?.fieldName
+            ? pendingData.availableFields.find(f => f.name === userConfirmation.fieldName)
+            : pendingData.suggestedField;
+        if (!relationRef) {
+            throw new errors_1.StepStateError(`Step at index ${this.context.stepIndex} could not resolve relation "${userConfirmation?.fieldName}" from available fields`);
+        }
+        const { name, displayName } = relationRef;
+        const selectedRecordId = userConfirmation?.selectedRecordId ?? pendingData.suggestedRecord?.recordId;
+        if (!selectedRecordId) {
+            throw new errors_1.RelatedRecordNotFoundError(selectedRecordRef.collectionName, name);
+        }
+        // Re-derive relatedCollectionName from the live schema — frontend never sends it.
+        const schema = await this.getCollectionSchema(selectedRecordRef.collectionName);
+        const field = schema.fields.find(f => f.fieldName === name);
+        if (!field?.relatedCollectionName) {
+            throw new errors_1.StepStateError(`Step at index ${this.context.stepIndex} could not resolve relatedCollectionName for relation "${name}"`);
+        }
+        const record = {
+            collectionName: field.relatedCollectionName,
+            recordId: selectedRecordId,
+            stepIndex: this.context.stepIndex,
+        };
+        return this.persistAndReturn(record, { selectedRecordRef, name, displayName }, execution);
+    }
+    async selectBestFromRelatedData(target, limit) {
+        const relatedSchema = await this.getCollectionSchema(target.relatedCollectionName);
+        const relatedData = await this.fetchRelatedData(target, relatedSchema, limit);
+        // Empty (bestIndex unused — callers guard on length) or single → no ranking needed.
+        if (relatedData.length <= 1) {
+            return { relatedData, bestIndex: 0, suggestedFields: [], relatedSchema };
+        }
+        const { preRecordedArgs } = this.context.stepDefinition;
+        if (preRecordedArgs?.selectedRecordIndex !== undefined) {
+            if (!Number.isInteger(preRecordedArgs.selectedRecordIndex) ||
+                preRecordedArgs.selectedRecordIndex < 0 ||
+                preRecordedArgs.selectedRecordIndex >= relatedData.length) {
+                throw new errors_1.InvalidPreRecordedArgsError(`Record index ${preRecordedArgs.selectedRecordIndex} is out of range (0-${relatedData.length - 1})`);
+            }
+            return {
+                relatedData,
+                bestIndex: preRecordedArgs.selectedRecordIndex,
+                suggestedFields: [],
+                relatedSchema,
+            };
+        }
+        const suggestedFields = await this.selectRelevantFields(relatedSchema, this.context.stepDefinition.prompt);
+        const bestIndex = await this.selectBestRecordIndex(relatedData, suggestedFields, this.context.stepDefinition.prompt);
+        return { relatedData, bestIndex, suggestedFields, relatedSchema };
+    }
+    /** HasMany + fully automated execution: fetch top 50, then AI calls to select the best record. */
+    async selectBestRelatedRecord(target) {
+        const { relatedData, bestIndex } = await this.selectBestFromRelatedData(target, 50);
+        if (relatedData.length === 0) {
+            throw new errors_1.RelatedRecordNotFoundError(target.selectedRecordRef.collectionName, target.name);
+        }
+        return this.toRecordRef(relatedData[bestIndex]);
+    }
+    async fetchFirstCandidate(target) {
+        const candidates = await this.fetchCandidates(target, 1);
+        return candidates[0];
+    }
+    async fetchCandidates(target, limit) {
+        const { selectedRecordRef, name } = target;
+        const relatedSchema = await this.getCollectionSchema(target.relatedCollectionName);
+        const relatedData = await this.fetchRelatedData(target, relatedSchema, limit);
+        if (relatedData.length === 0) {
+            throw new errors_1.RelatedRecordNotFoundError(selectedRecordRef.collectionName, name);
+        }
+        return relatedData.map(r => this.toRecordRef(r));
+    }
+    async fetchRelatedData(target, relatedSchema, limit) {
+        return this.context.agent.getRelatedData({
+            collection: target.selectedRecordRef.collectionName,
+            id: target.selectedRecordRef.recordId,
+            relation: target.name,
+            relatedSchema,
+            limit,
+        });
+    }
+    /** Persists the loaded record ref and returns a success outcome. */
+    async persistAndReturn(record, target, existingExecution) {
+        const { selectedRecordRef, name, displayName } = target;
+        await this.context.runStore.saveStepExecution(this.context.runId, {
+            ...existingExecution,
+            type: 'load-related-record',
+            stepIndex: this.context.stepIndex,
+            executionParams: { displayName, name },
+            executionResult: { relation: { name, displayName }, record },
+            selectedRecordRef,
+        });
+        return this.buildOutcomeResult({ status: 'success' });
+    }
+    relationOptionLabel(candidate) {
+        const { record, schema, field } = candidate;
+        return `Step ${record.stepIndex} - ${schema.collectionDisplayName} #${record.recordId} → ${field.displayName} (→ ${field.relatedCollectionName})`;
+    }
+    async selectRelationToFollow(candidates) {
+        const labels = candidates.map(c => this.relationOptionLabel(c));
+        const labelTuple = labels;
+        const tool = new ai_proxy_1.DynamicStructuredTool({
+            name: 'select-relation-to-follow',
+            description: 'Select the relation to follow to load the requested related record.',
+            schema: zod_1.z.object({
+                relation: zod_1.z
+                    .enum(labelTuple)
+                    .describe('The relation to follow, chosen by the collection it leads to'),
+                reasoning: zod_1.z.string().describe('Why this relation leads to the requested record'),
+            }),
+            func: undefined,
+        });
+        const messages = [
+            this.buildContextMessage(),
+            ...(await this.buildPreviousStepsMessages()),
+            new ai_proxy_1.SystemMessage(SELECT_RELATION_SYSTEM_PROMPT),
+            new ai_proxy_1.HumanMessage(`**Request**: ${this.context.stepDefinition.prompt ?? 'Load the relevant related record.'}`),
+        ];
+        const { relation } = await this.invokeWithTool(messages, tool);
+        const index = labels.indexOf(relation);
+        if (index === -1) {
+            throw new errors_1.InvalidAIResponseError(`AI selected relation "${relation}" which does not match any available option`);
+        }
+        return candidates[index];
+    }
+    /** AI call 1 for HasMany: selects the most relevant fields to compare candidates. */
+    async selectRelevantFields(schema, prompt) {
+        const nonRelationFields = schema.fields.filter(f => !f.isRelationship);
+        if (nonRelationFields.length === 0)
+            return [];
+        // Use displayName in both the enum and the prompt for consistency — the AI sees human-readable
+        // names throughout. Results are mapped back to technical fieldNames before returning.
+        const displayNames = nonRelationFields.map(f => f.displayName);
+        const tool = new ai_proxy_1.DynamicStructuredTool({
+            name: 'select-fields',
+            description: 'Select the most relevant fields to identify the right record.',
+            schema: zod_1.z.object({
+                fieldNames: zod_1.z
+                    .array(zod_1.z.enum(displayNames))
+                    .min(1)
+                    .max(MAX_RELEVANT_FIELDS)
+                    .describe(`The ${MAX_RELEVANT_FIELDS} fields most useful for identifying the relevant record`),
+            }),
+            func: undefined,
+        });
+        const messages = [
+            this.buildContextMessage(),
+            new ai_proxy_1.SystemMessage(SELECT_FIELDS_SYSTEM_PROMPT),
+            new ai_proxy_1.SystemMessage(`The related records are from the "${schema.collectionDisplayName}" collection. ` +
+                `Available fields: ${nonRelationFields.map(f => f.displayName).join(', ')}.`),
+            new ai_proxy_1.HumanMessage(`**Request**: ${prompt ?? 'Select the most relevant record.'}`),
+        ];
+        const { fieldNames: selectedDisplayNames } = await this.invokeWithTool(messages, tool);
+        // Zod's .min(1) shapes the prompt but is NOT validated against the AI response.
+        // Guard explicitly to avoid silently passing all fields to selectBestRecordIndex.
+        if (selectedDisplayNames.length === 0) {
+            throw new errors_1.InvalidAIResponseError(`AI returned no field names for field selection in collection "${schema.collectionName}"`);
+        }
+        // Map display names back to technical field names — values in RecordData are keyed by fieldName.
+        // .max() shapes the prompt only (not validated against the response), so cap explicitly.
+        return selectedDisplayNames
+            .slice(0, MAX_RELEVANT_FIELDS)
+            .map(dn => nonRelationFields.find(f => f.displayName === dn)?.fieldName ?? dn);
+    }
+    /** AI call 2 for HasMany: selects the best record by index from the candidate list. */
+    async selectBestRecordIndex(candidates, fieldNames, prompt) {
+        const filteredCandidates = candidates.map((c, i) => {
+            const entries = Object.entries(c.values).filter(([k]) => fieldNames.length === 0 || fieldNames.includes(k));
+            return {
+                index: i,
+                values: Object.fromEntries(entries.map(([k, v]) => [k, clampFieldValue(v)])),
+            };
+        });
+        // Bound the prompt only — the full candidate list is still returned upstream. Accumulate
+        // lines until the global budget is reached (always keep at least the first candidate).
+        const lines = [];
+        let usedChars = 0;
+        for (const c of filteredCandidates) {
+            const line = `[${c.index}] ${JSON.stringify(c.values)}`;
+            if (lines.length > 0 && usedChars + line.length > MAX_AI_CANDIDATES_CHARS)
+                break;
+            lines.push(line);
+            usedChars += line.length + 1;
+        }
+        const shown = lines.length;
+        if (shown < candidates.length) {
+            this.context.logger.warn('load-related-record: candidate list truncated for AI prompt', {
+                ...this.logCtx,
+                shown,
+                total: candidates.length,
+            });
+        }
+        const maxIndex = shown - 1;
+        const tool = new ai_proxy_1.DynamicStructuredTool({
+            name: 'select-record-by-content',
+            description: 'Select the most relevant related record by its index.',
+            schema: zod_1.z.object({
+                recordIndex: zod_1.z
+                    .number()
+                    .int()
+                    .min(0)
+                    .max(maxIndex)
+                    .describe(`0-based index of the most relevant record (0 to ${maxIndex})`),
+                reasoning: zod_1.z.string().describe('Why this record was chosen'),
+            }),
+            func: undefined,
+        });
+        const messages = [
+            this.buildContextMessage(),
+            new ai_proxy_1.SystemMessage(SELECT_RECORD_SYSTEM_PROMPT),
+            new ai_proxy_1.SystemMessage(`Candidates:\n${lines.join('\n')}`),
+            new ai_proxy_1.HumanMessage(`**Request**: ${prompt ?? 'Select the most relevant record.'}`),
+        ];
+        const { recordIndex } = await this.invokeWithTool(messages, tool);
+        // NOTE: The Zod schema's .min(0).max(maxIndex) shapes the tool prompt only — it is NOT
+        // validated against the AI response. This guard is the sole runtime enforcement.
+        if (!Number.isInteger(recordIndex) || recordIndex < 0 || recordIndex > maxIndex) {
+            throw new errors_1.InvalidAIResponseError(`AI selected record index ${recordIndex} which is out of range (0-${maxIndex}) or not an integer`);
+        }
+        return recordIndex;
+    }
+    toRecordRef(data) {
+        return {
+            collectionName: data.collectionName,
+            recordId: data.recordId,
+            stepIndex: this.context.stepIndex,
+        };
+    }
+}
+exports.default = LoadRelatedRecordStepExecutor;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"load-related-record-step-executor.js","sourceRoot":"","sources":["../../src/executors/load-related-record-step-executor.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,22 @@
+import type { ExecutionContext, StepExecutionResult } from '../types/execution-context';
+import type { McpStepDefinition } from '../types/validated/step-definition';
+import type { RecordStepStatus } from '../types/validated/step-outcome';
+import type { RemoteTool } from '@forestadmin/ai-proxy';
+import BaseStepExecutor from './base-step-executor';
+export default class McpStepExecutor extends BaseStepExecutor<McpStepDefinition> {
+    private readonly remoteTools;
+    private readonly mcpServerName?;
+    constructor(context: ExecutionContext<McpStepDefinition>, remoteTools: readonly RemoteTool[], mcpServerName?: string);
+    protected getExtraLogContext(): Record<string, unknown>;
+    protected buildOutcomeResult(outcome: {
+        status: RecordStepStatus;
+        error?: string;
+    }): StepExecutionResult;
+    protected checkIdempotency(): Promise<StepExecutionResult | null>;
+    protected doExecute(): Promise<StepExecutionResult>;
+    private executeToolAndPersist;
+    private formatToolResult;
+    private selectTool;
+    private requireTools;
+}
+//# sourceMappingURL=mcp-step-executor.d.ts.map