@forestadmin/workflow-executor 1.0.0

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

@@ -0,0 +1,188 @@
+"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 step_definition_1 = require("../types/validated/step-definition");
+const MCP_TASK_SYSTEM_PROMPT = `You are an AI agent selecting and executing a tool to fulfill a user request.
+Select the most appropriate tool and fill in its parameters precisely.
+
+Important rules:
+- Select only the tool directly relevant to the request.
+- Final answer is definitive, you won't receive any other input from the user.`;
+class McpStepExecutor extends base_step_executor_1.default {
+    constructor(context, remoteTools, mcpServerName) {
+        super(context);
+        this.remoteTools = remoteTools;
+        this.mcpServerName = mcpServerName;
+    }
+    getExtraLogContext() {
+        return {
+            mcpServerId: this.context.stepDefinition.mcpServerId,
+            mcpServerName: this.mcpServerName,
+        };
+    }
+    buildOutcomeResult(outcome) {
+        return {
+            stepOutcome: {
+                type: 'mcp',
+                stepId: this.context.stepId,
+                stepIndex: this.context.stepIndex,
+                ...outcome,
+            },
+        };
+    }
+    async checkIdempotency() {
+        const existing = await this.findPendingExecution('mcp');
+        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, execution => this.executeToolAndPersist(execution.pendingData, execution));
+        }
+        // Branches B & C -- First call
+        const tools = this.requireTools();
+        const { toolName, args } = await this.selectTool(tools);
+        const selectedTool = tools.find(t => t.base.name === toolName);
+        if (!selectedTool)
+            throw new errors_1.McpToolNotFoundError(toolName);
+        const target = { name: toolName, sourceId: selectedTool.sourceId, input: args };
+        if (this.context.stepDefinition.executionType === step_definition_1.StepExecutionMode.FullyAutomated) {
+            // Branch B -- direct execution
+            return this.executeToolAndPersist(target);
+        }
+        // Branch C -- Awaiting confirmation
+        await this.context.runStore.saveStepExecution(this.context.runId, {
+            type: 'mcp',
+            stepIndex: this.context.stepIndex,
+            pendingData: target,
+        });
+        return this.buildOutcomeResult({ status: 'awaiting-input' });
+    }
+    async executeToolAndPersist(target, existingExecution) {
+        const tools = this.requireTools();
+        const tool = tools.find(t => t.base.name === target.name && t.sourceId === target.sourceId);
+        if (!tool)
+            throw new errors_1.McpToolNotFoundError(target.name);
+        const toolResult = await this.context.activityLog.track({
+            action: 'action',
+            type: 'write',
+            label: this.context.stepDefinition.mcpServerId,
+            collectionId: this.context.collectionId,
+            recordId: this.context.baseRecordRef.recordId,
+        }, {
+            operation: async () => {
+                try {
+                    return await tool.base.invoke(target.input);
+                }
+                catch (cause) {
+                    throw new errors_1.McpToolInvocationError(target.name, cause);
+                }
+            },
+            beforeCall: () => this.context.runStore.saveStepExecution(this.context.runId, {
+                ...existingExecution,
+                type: 'mcp',
+                stepIndex: this.context.stepIndex,
+                idempotencyPhase: 'executing',
+            }),
+        });
+        // 1. Persist raw result immediately — safe state before any further network calls
+        const baseExecutionResult = { success: true, toolResult };
+        const baseData = {
+            ...existingExecution,
+            type: 'mcp',
+            stepIndex: this.context.stepIndex,
+            executionParams: { name: target.name, sourceId: target.sourceId, input: target.input },
+            executionResult: baseExecutionResult,
+            idempotencyPhase: 'done',
+        };
+        await this.context.runStore.saveStepExecution(this.context.runId, baseData);
+        // 2. AI formatting — non-blocking; errors are logged but do not fail the step
+        let formattedResponse = null;
+        try {
+            formattedResponse = await this.formatToolResult(target, toolResult);
+        }
+        catch (cause) {
+            this.context.logger.error('Failed to format MCP tool result, persisting raw result without summary', {
+                runId: this.context.runId,
+                stepIndex: this.context.stepIndex,
+                toolName: target.name,
+                cause: cause instanceof Error ? cause.message : String(cause),
+            });
+        }
+        if (formattedResponse) {
+            try {
+                await this.context.runStore.saveStepExecution(this.context.runId, {
+                    ...baseData,
+                    executionResult: { ...baseExecutionResult, formattedResponse },
+                });
+            }
+            catch (cause) {
+                this.context.logger.error('MCP tool result formatted but enriched state could not be persisted', {
+                    runId: this.context.runId,
+                    stepIndex: this.context.stepIndex,
+                    toolName: target.name,
+                    cause: cause instanceof Error ? cause.message : String(cause),
+                });
+            }
+        }
+        return this.buildOutcomeResult({ status: 'success' });
+    }
+    async formatToolResult(tool, toolResult) {
+        if (toolResult === null || toolResult === undefined)
+            return null;
+        const resultStr = typeof toolResult === 'string' ? toolResult : JSON.stringify(toolResult);
+        const truncatedResult = resultStr.length > 20000 ? `${resultStr.slice(0, 20000)}\n... [truncated]` : resultStr;
+        const summaryTool = new ai_proxy_1.DynamicStructuredTool({
+            name: 'summarize-result',
+            description: 'Provides a human-readable summary of the tool execution result.',
+            schema: zod_1.z.object({
+                summary: zod_1.z.string().min(1).describe('Concise human-readable summary of the tool result.'),
+            }),
+            func: undefined,
+        });
+        const messages = [
+            this.buildContextMessage(),
+            new ai_proxy_1.SystemMessage('You are summarizing the result of a workflow tool execution for the end user. ' +
+                'Be concise and factual. Do not include raw JSON or technical identifiers.'),
+            new ai_proxy_1.HumanMessage(`Tool "${tool.name}" was executed with input: ${JSON.stringify(tool.input)}.\n` +
+                `Result: ${truncatedResult}\n\n` +
+                `Provide a concise human-readable summary.`),
+        ];
+        const { summary } = await this.invokeWithTool(messages, summaryTool);
+        return summary || null;
+    }
+    async selectTool(tools) {
+        const messages = [
+            this.buildContextMessage(),
+            ...(await this.buildPreviousStepsMessages()),
+            new ai_proxy_1.SystemMessage(MCP_TASK_SYSTEM_PROMPT),
+            new ai_proxy_1.HumanMessage(`**Request**: ${this.context.stepDefinition.prompt ?? 'Execute the relevant tool.'}`),
+        ];
+        return this.invokeWithTools(messages, tools.map(t => t.base));
+    }
+    // Tools are pre-scoped to step.mcpServerId upstream. An empty list means either no config
+    // matched, or the per-server connection failed at load time (McpClient swallows per-server
+    // errors). RemoteToolFetcher emits the diagnostic upstream; here we just surface the empty
+    // case as a domain error so BaseStepExecutor turns it into a step outcome.
+    requireTools() {
+        if (this.remoteTools.length === 0) {
+            throw new errors_1.NoMcpToolsError(this.context.stepDefinition.mcpServerId);
+        }
+        return [...this.remoteTools];
+    }
+}
+exports.default = McpStepExecutor;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mcp-step-executor.js","sourceRoot":"","sources":["../../src/executors/mcp-step-executor.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,10 @@
+import type { StepExecutionResult } from '../types/execution-context';
+import type { ReadRecordStepDefinition } from '../types/validated/step-definition';
+import RecordStepExecutor from './record-step-executor';
+export default class ReadRecordStepExecutor extends RecordStepExecutor<ReadRecordStepDefinition> {
+    protected doExecute(): Promise<StepExecutionResult>;
+    private selectFields;
+    private buildReadFieldTool;
+    private formatFieldResults;
+}
+//# sourceMappingURL=read-record-step-executor.d.ts.map

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

@@ -0,0 +1,100 @@
+"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 READ_RECORD_SYSTEM_PROMPT = `You are an AI agent reading fields from a record to answer a user request.
+Select the field(s) that best answer the request. You can read one field or multiple fields at once.
+
+Important rules:
+- Be precise: only read fields that are 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 ReadRecordStepExecutor extends record_step_executor_1.default {
+    async doExecute() {
+        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 fieldNames = preRecordedArgs?.fieldNames ?? (await this.selectFields(schema, step.prompt));
+        const selectedFields = fieldNames.map(requested => ({
+            requested,
+            field: this.findFieldByTechnicalName(schema, requested),
+        }));
+        const resolvedFieldNames = selectedFields
+            .map(s => s.field?.fieldName)
+            .filter((name) => name !== undefined);
+        if (resolvedFieldNames.length === 0) {
+            throw new errors_1.NoResolvedFieldsError(selectedFields.map(s => s.requested));
+        }
+        const recordData = await this.context.agent.getRecord({
+            collection: selectedRecordRef.collectionName,
+            id: selectedRecordRef.recordId,
+            fields: resolvedFieldNames,
+        });
+        const fieldResults = this.formatFieldResults(recordData.values, selectedFields);
+        await this.context.runStore.saveStepExecution(this.context.runId, {
+            type: 'read-record',
+            stepIndex: this.context.stepIndex,
+            executionParams: {
+                fields: fieldResults.map(({ name, displayName }) => ({ name, displayName })),
+            },
+            executionResult: { fields: fieldResults },
+            selectedRecordRef,
+        });
+        return this.buildOutcomeResult({ status: 'success' });
+    }
+    async selectFields(schema, prompt) {
+        const tool = this.buildReadFieldTool(schema);
+        const messages = [
+            this.buildContextMessage(),
+            ...(await this.buildPreviousStepsMessages()),
+            new ai_proxy_1.SystemMessage(READ_RECORD_SYSTEM_PROMPT),
+            new ai_proxy_1.SystemMessage(`The selected record belongs to the "${schema.collectionDisplayName}" collection.`),
+            new ai_proxy_1.HumanMessage(`**Request**: ${prompt ?? 'Read the relevant fields.'}`),
+        ];
+        const { fieldNames } = await this.invokeWithTool(messages, tool);
+        return fieldNames.map(name => this.resolveAiFieldName(schema, name));
+    }
+    buildReadFieldTool(schema) {
+        const nonRelationFields = schema.fields.filter(f => !f.isRelationship);
+        if (nonRelationFields.length === 0) {
+            throw new errors_1.NoReadableFieldsError(schema.collectionName);
+        }
+        const displayNames = nonRelationFields.map(f => f.displayName);
+        return new ai_proxy_1.DynamicStructuredTool({
+            name: 'read-selected-record-fields',
+            description: 'Read one or more fields from the selected record.',
+            schema: zod_1.z.object({
+                // z.string() (not z.enum) intentionally: an invalid field name in the array
+                // does not fail the whole tool call — per-field errors are handled in formatFieldResults.
+                // This matches the frontend implementation (ISO frontend).
+                fieldNames: zod_1.z
+                    .array(zod_1.z.string())
+                    .describe(`Names of the fields to read, possible values are: ${displayNames
+                    .map(n => `"${n}"`)
+                    .join(', ')}`),
+            }),
+            func: undefined,
+        });
+    }
+    formatFieldResults(values, selected) {
+        return selected.map(({ requested, field }) => {
+            if (!field) {
+                return { error: `Field not found: ${requested}`, name: requested, displayName: requested };
+            }
+            return {
+                value: values[field.fieldName],
+                name: field.fieldName,
+                displayName: field.displayName,
+            };
+        });
+    }
+}
+exports.default = ReadRecordStepExecutor;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVhZC1yZWNvcmQtc3RlcC1leGVjdXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9leGVjdXRvcnMvcmVhZC1yZWNvcmQtc3RlcC1leGVjdXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUtBLG9EQUEyRjtBQUMzRiw2QkFBd0I7QUFFeEIsc0NBQXlFO0FBQ3pFLGtGQUF3RDtBQUV4RCxNQUFNLHlCQUF5QixHQUFHOzs7Ozs7c0ZBTW9ELENBQUM7QUFFdkYsTUFBcUIsc0JBQXVCLFNBQVEsOEJBQTRDO0lBQ3BGLEtBQUssQ0FBQyxTQUFTO1FBQ3ZCLE1BQU0sRUFBRSxjQUFjLEVBQUUsSUFBSSxFQUFFLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FBQztRQUM5QyxNQUFNLEVBQUUsZUFBZSxFQUFFLEdBQUcsSUFBSSxDQUFDO1FBQ2pDLE1BQU0sT0FBTyxHQUFHLE1BQU0sSUFBSSxDQUFDLHNCQUFzQixFQUFFLENBQUM7UUFFcEQsTUFBTSxpQkFBaUIsR0FBRyxNQUFNLElBQUksQ0FBQyxnQkFBZ0IsQ0FDbkQsT0FBTyxFQUNQLElBQUksQ0FBQyxNQUFNLEVBQ1gsZUFBZSxFQUFFLHVCQUF1QixDQUN6QyxDQUFDO1FBQ0YsTUFBTSxNQUFNLEdBQUcsTUFBTSxJQUFJLENBQUMsbUJBQW1CLENBQUMsaUJBQWlCLENBQUMsY0FBYyxDQUFDLENBQUM7UUFDaEYsTUFBTSxVQUFVLEdBQ2QsZUFBZSxFQUFFLFVBQVUsSUFBSSxDQUFDLE1BQU0sSUFBSSxDQUFDLFlBQVksQ0FBQyxNQUFNLEVBQUUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUM7UUFDaEYsTUFBTSxjQUFjLEdBQUcsVUFBVSxDQUFDLEdBQUcsQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDLENBQUM7WUFDbEQsU0FBUztZQUNULEtBQUssRUFBRSxJQUFJLENBQUMsd0JBQXdCLENBQUMsTUFBTSxFQUFFLFNBQVMsQ0FBQztTQUN4RCxDQUFDLENBQUMsQ0FBQztRQUVKLE1BQU0sa0JBQWtCLEdBQUcsY0FBYzthQUN0QyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsS0FBSyxFQUFFLFNBQVMsQ0FBQzthQUM1QixNQUFNLENBQUMsQ0FBQyxJQUFJLEVBQWtCLEVBQUUsQ0FBQyxJQUFJLEtBQUssU0FBUyxDQUFDLENBQUM7UUFFeEQsSUFBSSxrQkFBa0IsQ0FBQyxNQUFNLEtBQUssQ0FBQyxFQUFFLENBQUM7WUFDcEMsTUFBTSxJQUFJLDhCQUFxQixDQUFDLGNBQWMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQztRQUN4RSxDQUFDO1FBRUQsTUFBTSxVQUFVLEdBQUcsTUFBTSxJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUM7WUFDcEQsVUFBVSxFQUFFLGlCQUFpQixDQUFDLGNBQWM7WUFDNUMsRUFBRSxFQUFFLGlCQUFpQixDQUFDLFFBQVE7WUFDOUIsTUFBTSxFQUFFLGtCQUFrQjtTQUMzQixDQUFDLENBQUM7UUFDSCxNQUFNLFlBQVksR0FBRyxJQUFJLENBQUMsa0JBQWtCLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxjQUFjLENBQUMsQ0FBQztRQUVoRixNQUFNLElBQUksQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLGlCQUFpQixDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsS0FBSyxFQUFFO1lBQ2hFLElBQUksRUFBRSxhQUFhO1lBQ25CLFNBQVMsRUFBRSxJQUFJLENBQUMsT0FBTyxDQUFDLFNBQVM7WUFDakMsZUFBZSxFQUFFO2dCQUNmLE1BQU0sRUFBRSxZQUFZLENBQUMsR0FBRyxDQUFDLENBQUMsRUFBRSxJQUFJLEVBQUUsV0FBVyxFQUFFLEVBQUUsRUFBRSxDQUFDLENBQUMsRUFBRSxJQUFJLEVBQUUsV0FBVyxFQUFFLENBQUMsQ0FBQzthQUM3RTtZQUNELGVBQWUsRUFBRSxFQUFFLE1BQU0sRUFBRSxZQUFZLEVBQUU7WUFDekMsaUJBQWlCO1NBQ2xCLENBQUMsQ0FBQztRQUVILE9BQU8sSUFBSSxDQUFDLGtCQUFrQixDQUFDLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFBRSxDQUFDLENBQUM7SUFDeEQsQ0FBQztJQUVPLEtBQUssQ0FBQyxZQUFZLENBQ3hCLE1BQXdCLEVBQ3hCLE1BQTBCO1FBRTFCLE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUM3QyxNQUFNLFFBQVEsR0FBRztZQUNmLElBQUksQ0FBQyxtQkFBbUIsRUFBRTtZQUMxQixHQUFHLENBQUMsTUFBTSxJQUFJLENBQUMsMEJBQTBCLEVBQUUsQ0FBQztZQUM1QyxJQUFJLHdCQUFhLENBQUMseUJBQXlCLENBQUM7WUFDNUMsSUFBSSx3QkFBYSxDQUNmLHVDQUF1QyxNQUFNLENBQUMscUJBQXFCLGVBQWUsQ0FDbkY7WUFDRCxJQUFJLHVCQUFZLENBQUMsZ0JBQWdCLE1BQU0sSUFBSSwyQkFBMkIsRUFBRSxDQUFDO1NBQzFFLENBQUM7UUFFRixNQUFNLEVBQUUsVUFBVSxFQUFFLEdBQUcsTUFBTSxJQUFJLENBQUMsY0FBYyxDQUEyQixRQUFRLEVBQUUsSUFBSSxDQUFDLENBQUM7UUFFM0YsT0FBTyxVQUFVLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLGtCQUFrQixDQUFDLE1BQU0sRUFBRSxJQUFJLENBQUMsQ0FBQyxDQUFDO0lBQ3ZFLENBQUM7SUFFTyxrQkFBa0IsQ0FBQyxNQUF3QjtRQUNqRCxNQUFNLGlCQUFpQixHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUMsY0FBYyxDQUFDLENBQUM7UUFFdkUsSUFBSSxpQkFBaUIsQ0FBQyxNQUFNLEtBQUssQ0FBQyxFQUFFLENBQUM7WUFDbkMsTUFBTSxJQUFJLDhCQUFxQixDQUFDLE1BQU0sQ0FBQyxjQUFjLENBQUMsQ0FBQztRQUN6RCxDQUFDO1FBRUQsTUFBTSxZQUFZLEdBQUcsaUJBQWlCLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLFdBQVcsQ0FBMEIsQ0FBQztRQUV4RixPQUFPLElBQUksZ0NBQXFCLENBQUM7WUFDL0IsSUFBSSxFQUFFLDZCQUE2QjtZQUNuQyxXQUFXLEVBQUUsbURBQW1EO1lBQ2hFLE1BQU0sRUFBRSxPQUFDLENBQUMsTUFBTSxDQUFDO2dCQUNmLDRFQUE0RTtnQkFDNUUsMEZBQTBGO2dCQUMxRiwyREFBMkQ7Z0JBQzNELFVBQVUsRUFBRSxPQUFDO3FCQUNWLEtBQUssQ0FBQyxPQUFDLENBQUMsTUFBTSxFQUFFLENBQUM7cUJBQ2pCLFFBQVEsQ0FDUCxxREFBcUQsWUFBWTtxQkFDOUQsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQztxQkFDbEIsSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQ2hCO2FBQ0osQ0FBQztZQUNGLElBQUksRUFBRSxTQUFTO1NBQ2hCLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFTyxrQkFBa0IsQ0FDeEIsTUFBK0IsRUFDL0IsUUFBc0U7UUFFdEUsT0FBTyxRQUFRLENBQUMsR0FBRyxDQUFDLENBQUMsRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLEVBQUUsRUFBRTtZQUMzQyxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUM7Z0JBQ1gsT0FBTyxFQUFFLEtBQUssRUFBRSxvQkFBb0IsU0FBUyxFQUFFLEVBQUUsSUFBSSxFQUFFLFNBQVMsRUFBRSxXQUFXLEVBQUUsU0FBUyxFQUFFLENBQUM7WUFDN0YsQ0FBQztZQUVELE9BQU87Z0JBQ0wsS0FBSyxFQUFFLE1BQU0sQ0FBQyxLQUFLLENBQUMsU0FBUyxDQUFDO2dCQUM5QixJQUFJLEVBQUUsS0FBSyxDQUFDLFNBQVM7Z0JBQ3JCLFdBQVcsRUFBRSxLQUFLLENBQUMsV0FBVzthQUMvQixDQUFDO1FBQ0osQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDO0NBQ0Y7QUEvR0QseUNBK0dDIn0=

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

@@ -0,0 +1,19 @@
+import type { StepExecutionResult } from '../types/execution-context';
+import type { CollectionSchema, FieldSchema, RecordRef } from '../types/validated/collection';
+import type { StepDefinition } from '../types/validated/step-definition';
+import type { RecordStepStatus } from '../types/validated/step-outcome';
+import BaseStepExecutor from './base-step-executor';
+export default abstract class RecordStepExecutor<TStep extends StepDefinition = StepDefinition> extends BaseStepExecutor<TStep> {
+    protected buildOutcomeResult(outcome: {
+        status: RecordStepStatus;
+        error?: string;
+    }): StepExecutionResult;
+    protected resolveRecordRef(records: RecordRef[], prompt: string | undefined, preRecordedStepIndex?: number): Promise<RecordRef>;
+    protected getAvailableRecordRefs(): Promise<RecordRef[]>;
+    protected getCollectionSchema(collectionName: string): Promise<CollectionSchema>;
+    protected findFieldByTechnicalName(schema: CollectionSchema, name: string | undefined): FieldSchema | undefined;
+    protected resolveAiFieldName(schema: CollectionSchema, name: string): string;
+    private toRecordIdentifier;
+    private selectRecordRef;
+}
+//# sourceMappingURL=record-step-executor.d.ts.map

package/dist/executors/record-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 step_definition_1 = require("../types/validated/step-definition");
+class RecordStepExecutor extends base_step_executor_1.default {
+    buildOutcomeResult(outcome) {
+        return {
+            stepOutcome: {
+                type: 'record',
+                stepId: this.context.stepId,
+                stepIndex: this.context.stepIndex,
+                ...outcome,
+            },
+        };
+    }
+    async resolveRecordRef(records, prompt, preRecordedStepIndex) {
+        if (preRecordedStepIndex !== undefined) {
+            const match = records.find(r => r.stepIndex === preRecordedStepIndex);
+            if (!match) {
+                throw new errors_1.InvalidPreRecordedArgsError(`No record found at step index ${preRecordedStepIndex}`);
+            }
+            return match;
+        }
+        return this.selectRecordRef(records, prompt);
+    }
+    // Candidate sources for the AI: the base record plus the record each live prior
+    // load-related step resolved — own stepIndex first, falling back to a clone's
+    // originalStepIndex.
+    async getAvailableRecordRefs() {
+        const stepExecutions = await this.context.runStore.getStepExecutions(this.context.runId);
+        const relatedRecords = this.context.previousSteps.flatMap(step => {
+            if (step.stepDefinition.type !== step_definition_1.StepType.LoadRelatedRecord)
+                return [];
+            const execution = this.resolveStepExecution(step, stepExecutions);
+            if (execution?.type === 'load-related-record' &&
+                execution.executionResult !== undefined &&
+                'record' in execution.executionResult) {
+                return [execution.executionResult.record];
+            }
+            return [];
+        });
+        return [this.context.baseRecordRef, ...relatedRecords];
+    }
+    getCollectionSchema(collectionName) {
+        return this.context.schemaResolver.resolve(collectionName);
+    }
+    findFieldByTechnicalName(schema, name) {
+        if (name === undefined)
+            return undefined;
+        return schema.fields.find(f => f.fieldName === name);
+    }
+    // Map an AI-returned displayName back to its technical fieldName. LLMs occasionally return
+    // formatting variants (e.g. "first_name" for "firstname", "full-name" for "Full Name"), so fall
+    // back to a normalized comparison. On a miss, returns the raw name — the exact lookup downstream
+    // turns it into a loud error.
+    resolveAiFieldName(schema, name) {
+        const exact = schema.fields.find(f => f.displayName === name) ??
+            schema.fields.find(f => f.fieldName === name);
+        if (exact)
+            return exact.fieldName;
+        const normalize = (s) => s.toLowerCase().replace(/[\s_-]/g, '');
+        const normalized = normalize(name);
+        const fuzzy = schema.fields.filter(f => normalize(f.displayName) === normalized || normalize(f.fieldName) === normalized);
+        return fuzzy.length === 1 ? fuzzy[0].fieldName : name;
+    }
+    async toRecordIdentifier(record) {
+        const schema = await this.getCollectionSchema(record.collectionName);
+        return `Step ${record.stepIndex} - ${schema.collectionDisplayName} #${record.recordId}`;
+    }
+    async selectRecordRef(records, prompt) {
+        if (records.length === 0)
+            throw new errors_1.NoRecordsError();
+        if (records.length === 1)
+            return records[0];
+        const identifiers = await Promise.all(records.map(r => this.toRecordIdentifier(r)));
+        const identifierTuple = identifiers;
+        const tool = new ai_proxy_1.DynamicStructuredTool({
+            name: 'select-record',
+            description: 'Select the most relevant record for this workflow step.',
+            schema: zod_1.z.object({
+                recordIdentifier: zod_1.z.enum(identifierTuple),
+            }),
+            func: undefined,
+        });
+        const messages = [
+            this.buildContextMessage(),
+            ...(await this.buildPreviousStepsMessages()),
+            new ai_proxy_1.SystemMessage('You are an AI agent selecting the most relevant record for a workflow step.\n' +
+                'Choose the record whose collection best matches the user request.\n' +
+                'Pay attention to the collection name of each record.'),
+            new ai_proxy_1.HumanMessage(prompt ?? 'Select the most relevant record.'),
+        ];
+        const { recordIdentifier } = await this.invokeWithTool(messages, tool);
+        const selectedIndex = identifiers.indexOf(recordIdentifier);
+        if (selectedIndex === -1) {
+            throw new errors_1.InvalidAIResponseError(`AI selected record "${recordIdentifier}" which does not match any available record`);
+        }
+        return records[selectedIndex];
+    }
+}
+exports.default = RecordStepExecutor;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,24 @@
+import type { ActivityLogPort } from '../ports/activity-log-port';
+import type { AgentPort } from '../ports/agent-port';
+import type { AiModelPort } from '../ports/ai-model-port';
+import type { Logger } from '../ports/logger-port';
+import type { RunStore } from '../ports/run-store';
+import type { WorkflowPort } from '../ports/workflow-port';
+import type { FetchRemoteToolsResult } from '../remote-tool-fetcher';
+import type SchemaCache from '../schema-cache';
+import type { AvailableStepExecution, IStepExecutor } from '../types/execution-context';
+export interface StepContextConfig {
+    aiModelPort: AiModelPort;
+    agentPort: AgentPort;
+    workflowPort: WorkflowPort;
+    runStore: RunStore;
+    schemaCache: SchemaCache;
+    logger: Logger;
+    stepTimeoutMs?: number;
+    aiInvokeTimeoutMs?: number;
+}
+export default class StepExecutorFactory {
+    static create(step: AvailableStepExecution, contextConfig: StepContextConfig, activityLogPort: ActivityLogPort, fetchRemoteTools: (mcpServerId: string) => Promise<FetchRemoteToolsResult>, incomingPendingData?: unknown): Promise<IStepExecutor>;
+    private static buildContext;
+}
+//# sourceMappingURL=step-executor-factory.d.ts.map

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

@@ -0,0 +1,99 @@
+"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 schema_resolver_1 = __importDefault(require("../schema-resolver"));
+const activity_log_1 = __importDefault(require("./activity-log"));
+const agent_with_log_1 = __importDefault(require("./agent-with-log"));
+const condition_step_executor_1 = __importDefault(require("./condition-step-executor"));
+const guidance_step_executor_1 = __importDefault(require("./guidance-step-executor"));
+const load_related_record_step_executor_1 = __importDefault(require("./load-related-record-step-executor"));
+const mcp_step_executor_1 = __importDefault(require("./mcp-step-executor"));
+const read_record_step_executor_1 = __importDefault(require("./read-record-step-executor"));
+const trigger_record_action_step_executor_1 = __importDefault(require("./trigger-record-action-step-executor"));
+const update_record_step_executor_1 = __importDefault(require("./update-record-step-executor"));
+const step_definition_1 = require("../types/validated/step-definition");
+const step_outcome_1 = require("../types/validated/step-outcome");
+class StepExecutorFactory {
+    static async create(step, contextConfig, activityLogPort, fetchRemoteTools, incomingPendingData) {
+        try {
+            const context = StepExecutorFactory.buildContext(step, contextConfig, activityLogPort, incomingPendingData);
+            switch (step.stepDefinition.type) {
+                case step_definition_1.StepType.Condition:
+                    return new condition_step_executor_1.default(context);
+                case step_definition_1.StepType.ReadRecord:
+                    return new read_record_step_executor_1.default(context);
+                case step_definition_1.StepType.UpdateRecord:
+                    return new update_record_step_executor_1.default(context);
+                case step_definition_1.StepType.TriggerAction:
+                    return new trigger_record_action_step_executor_1.default(context);
+                case step_definition_1.StepType.LoadRelatedRecord:
+                    return new load_related_record_step_executor_1.default(context);
+                case step_definition_1.StepType.Mcp: {
+                    const mcpContext = context;
+                    const { tools, mcpServerName } = await fetchRemoteTools(mcpContext.stepDefinition.mcpServerId);
+                    return new mcp_step_executor_1.default(mcpContext, tools, mcpServerName);
+                }
+                case step_definition_1.StepType.Guidance:
+                    return new guidance_step_executor_1.default(context);
+                default:
+                    throw new errors_1.StepStateError(`Unknown step type: ${step.stepDefinition.type}`);
+            }
+        }
+        catch (error) {
+            contextConfig.logger.error('Step execution failed unexpectedly', {
+                runId: step.runId,
+                stepId: step.stepId,
+                stepIndex: step.stepIndex,
+                error: (0, errors_1.extractErrorMessage)(error),
+                cause: (0, errors_1.causeMessage)(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            return {
+                execute: async () => ({
+                    stepOutcome: {
+                        type: (0, step_outcome_1.stepTypeToOutcomeType)(step.stepDefinition.type),
+                        stepId: step.stepId,
+                        stepIndex: step.stepIndex,
+                        status: 'error',
+                        error: error instanceof errors_1.WorkflowExecutorError
+                            ? error.userMessage
+                            : 'An unexpected error occurred.',
+                    },
+                }),
+            };
+        }
+    }
+    static buildContext(step, cfg, activityLogPort, incomingPendingData) {
+        const schemaResolver = new schema_resolver_1.default(cfg.schemaCache, cfg.workflowPort, step.runId);
+        const activityLog = new activity_log_1.default(activityLogPort, step.user);
+        return {
+            runId: step.runId,
+            stepId: step.stepId,
+            stepIndex: step.stepIndex,
+            collectionId: step.collectionId,
+            baseRecordRef: step.baseRecordRef,
+            stepDefinition: step.stepDefinition,
+            previousSteps: step.previousSteps,
+            user: step.user,
+            model: cfg.aiModelPort.getModel(step.stepDefinition.aiConfigName),
+            agent: new agent_with_log_1.default({
+                agentPort: cfg.agentPort,
+                schemaResolver,
+                user: step.user,
+                activityLog,
+            }),
+            activityLog,
+            runStore: cfg.runStore,
+            schemaResolver,
+            logger: cfg.logger,
+            incomingPendingData,
+            stepTimeoutMs: cfg.stepTimeoutMs,
+            aiInvokeTimeoutMs: cfg.aiInvokeTimeoutMs,
+        };
+    }
+}
+exports.default = StepExecutorFactory;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/executors/summary/step-execution-formatters.d.ts

@@ -0,0 +1,8 @@
+import type { StepExecutionData } from '../../types/step-execution-data';
+export default class StepExecutionFormatters {
+    static format(execution: StepExecutionData): string | null;
+    private static formatMcp;
+    private static formatGuidance;
+    private static formatLoadRelatedRecord;
+}
+//# sourceMappingURL=step-execution-formatters.d.ts.map