@forestadmin/workflow-executor 1.0.0

package/dist/errors.js

@@ -0,0 +1,327 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MalformedRunError = exports.DomainValidationError = exports.InvalidStepDefinitionError = exports.RecordIdSerializationError = exports.UnsupportedStepTypeError = exports.AgentProbeError = exports.InvalidPreRecordedArgsError = exports.InvalidPendingDataError = exports.PendingDataNotFoundError = exports.RunAlreadyInFlightError = exports.UserMismatchError = exports.RunNotFoundError = exports.ConfigurationError = exports.McpToolInvocationError = exports.AiModelPortError = exports.WorkflowPortError = exports.SchemaNotCachedError = exports.AgentPortError = exports.McpToolNotFoundError = exports.NoMcpToolsError = exports.AiInvokeTimeoutError = exports.StepTimeoutError = exports.ActivityLogCreationError = exports.StepStateError = exports.ActionNotFoundError = exports.FieldTypeMissingError = exports.FieldNotFoundError = exports.RelationNotFoundError = exports.InvalidAiRequestError = exports.InvalidAIResponseError = exports.RelatedRecordNotFoundError = exports.NoRelationshipFieldsError = exports.RunStorePortError = exports.UnsupportedActionFormError = exports.NoActionsError = exports.NoWritableFieldsError = exports.NoResolvedFieldsError = exports.NoReadableFieldsError = exports.NoRecordsError = exports.RecordNotFoundError = exports.MalformedToolCallError = exports.MissingToolCallError = exports.WorkflowExecutorError = void 0;
+exports.causeMessage = causeMessage;
+exports.extractErrorMessage = extractErrorMessage;
+function causeMessage(error) {
+    const { cause } = error;
+    return cause instanceof Error ? cause.message : undefined;
+}
+// Cascades through err.message → err.parent.message (Sequelize) → err.cause.message → err.name,
+// so wrapped infra errors (SequelizeConnectionRefusedError has an empty .message) don't log as empty.
+function extractErrorMessage(err) {
+    if (err === undefined)
+        return undefined;
+    if (!(err instanceof Error))
+        return String(err);
+    if (err.message)
+        return err.message;
+    const { parent } = err;
+    if (parent instanceof Error && parent.message)
+        return parent.message;
+    const { cause } = err;
+    if (cause instanceof Error && cause.message)
+        return cause.message;
+    return err.name || 'Unknown error';
+}
+class WorkflowExecutorError extends Error {
+    constructor(message, userMessage) {
+        super(message);
+        this.name = this.constructor.name;
+        this.userMessage = userMessage ?? message;
+    }
+}
+exports.WorkflowExecutorError = WorkflowExecutorError;
+class MissingToolCallError extends WorkflowExecutorError {
+    constructor() {
+        super('AI did not return a tool call', "The AI couldn't decide what to do. Try rephrasing the step's prompt.");
+    }
+}
+exports.MissingToolCallError = MissingToolCallError;
+class MalformedToolCallError extends WorkflowExecutorError {
+    constructor(toolName, details) {
+        super(`AI returned a malformed tool call for "${toolName}": ${details}`, "The AI returned an unexpected response. Try rephrasing the step's prompt.");
+        this.toolName = toolName;
+    }
+}
+exports.MalformedToolCallError = MalformedToolCallError;
+class RecordNotFoundError extends WorkflowExecutorError {
+    constructor(collectionName, recordId) {
+        super(`Record not found: collection "${collectionName}", id "${recordId.join('|')}"`, 'The record no longer exists. It may have been deleted.');
+    }
+}
+exports.RecordNotFoundError = RecordNotFoundError;
+class NoRecordsError extends WorkflowExecutorError {
+    constructor() {
+        super('No records available');
+    }
+}
+exports.NoRecordsError = NoRecordsError;
+class NoReadableFieldsError extends WorkflowExecutorError {
+    constructor(collectionName) {
+        super(`No readable fields on record from collection "${collectionName}"`, 'This record type has no readable fields configured in Forest Admin.');
+    }
+}
+exports.NoReadableFieldsError = NoReadableFieldsError;
+class NoResolvedFieldsError extends WorkflowExecutorError {
+    constructor(fieldNames) {
+        super(`None of the requested fields could be resolved: ${fieldNames.join(', ')}`, "The AI selected fields that don't exist on this record. Try rephrasing the step's prompt.");
+    }
+}
+exports.NoResolvedFieldsError = NoResolvedFieldsError;
+class NoWritableFieldsError extends WorkflowExecutorError {
+    constructor(collectionName) {
+        super(`No writable fields on record from collection "${collectionName}"`, 'This record type has no editable fields configured in Forest Admin.');
+    }
+}
+exports.NoWritableFieldsError = NoWritableFieldsError;
+class NoActionsError extends WorkflowExecutorError {
+    constructor(collectionName) {
+        super(`No actions available on collection "${collectionName}"`, 'No actions are available on this record.');
+    }
+}
+exports.NoActionsError = NoActionsError;
+class UnsupportedActionFormError extends WorkflowExecutorError {
+    constructor(actionDisplayName) {
+        super(`Action "${actionDisplayName}" requires a form which is not supported by the executor`, 'This action requires user input via a form, which is not yet supported in workflows.');
+    }
+}
+exports.UnsupportedActionFormError = UnsupportedActionFormError;
+class RunStorePortError extends WorkflowExecutorError {
+    constructor(operation, cause) {
+        super(`Run store "${operation}" failed: ${cause instanceof Error ? cause.message : String(cause)}`, 'The step state could not be accessed. Please retry.');
+        this.cause = cause;
+    }
+}
+exports.RunStorePortError = RunStorePortError;
+class NoRelationshipFieldsError extends WorkflowExecutorError {
+    constructor(collectionName) {
+        super(`No relationship fields on record from collection "${collectionName}"`, 'This record type has no relations configured in Forest Admin.');
+    }
+}
+exports.NoRelationshipFieldsError = NoRelationshipFieldsError;
+class RelatedRecordNotFoundError extends WorkflowExecutorError {
+    constructor(collectionName, relationName) {
+        super(`No related record found for relation "${relationName}" on collection "${collectionName}"`, 'The related record could not be found. It may have been deleted.');
+    }
+}
+exports.RelatedRecordNotFoundError = RelatedRecordNotFoundError;
+class InvalidAIResponseError extends WorkflowExecutorError {
+    constructor(message) {
+        super(message, "The AI made an unexpected choice. Try rephrasing the step's prompt.");
+    }
+}
+exports.InvalidAIResponseError = InvalidAIResponseError;
+class InvalidAiRequestError extends WorkflowExecutorError {
+    constructor(message) {
+        super(message, 'Step configuration error — please contact your administrator.');
+    }
+}
+exports.InvalidAiRequestError = InvalidAiRequestError;
+class RelationNotFoundError extends WorkflowExecutorError {
+    constructor(name, collectionName) {
+        super(`Relation "${name}" not found in collection "${collectionName}"`, "The AI selected a relation that doesn't exist on this record. Try rephrasing the step's prompt.");
+    }
+}
+exports.RelationNotFoundError = RelationNotFoundError;
+class FieldNotFoundError extends WorkflowExecutorError {
+    constructor(name, collectionName) {
+        super(`Field "${name}" not found in collection "${collectionName}"`, "The AI selected a field that doesn't exist on this record. Try rephrasing the step's prompt.");
+    }
+}
+exports.FieldNotFoundError = FieldNotFoundError;
+class FieldTypeMissingError extends WorkflowExecutorError {
+    constructor(name, collectionName) {
+        super(`Field "${name}" in collection "${collectionName}" has no column type`, "This field can't be updated because its type is missing from the schema. " +
+            'Contact your administrator if the problem persists.');
+    }
+}
+exports.FieldTypeMissingError = FieldTypeMissingError;
+class ActionNotFoundError extends WorkflowExecutorError {
+    constructor(name, collectionName) {
+        super(`Action "${name}" not found in collection "${collectionName}"`, "The AI selected an action that doesn't exist on this record. Try rephrasing the step's prompt.");
+    }
+}
+exports.ActionNotFoundError = ActionNotFoundError;
+class StepStateError extends WorkflowExecutorError {
+    constructor(message) {
+        super(message, 'An unexpected error occurred while processing this step.');
+    }
+}
+exports.StepStateError = StepStateError;
+// Bubbles from base-step-executor, which converts it to a step error — no step runs without an audit log.
+class ActivityLogCreationError extends WorkflowExecutorError {
+    constructor(cause) {
+        super('Failed to create activity log', 'Could not record this step in the audit log. Please try again, or contact your administrator if the problem persists.');
+        this.cause = cause;
+    }
+}
+exports.ActivityLogCreationError = ActivityLogCreationError;
+class StepTimeoutError extends WorkflowExecutorError {
+    constructor(timeoutMs) {
+        super(`Step execution exceeded timeout of ${timeoutMs}ms`, 'The step took too long to complete. Please try again, or contact your administrator if the problem persists.');
+    }
+}
+exports.StepTimeoutError = StepTimeoutError;
+// Thrown when the AI provider does not respond within the configured timeout — distinct from
+// StepTimeoutError so we can surface a provider-specific message and tune the AI timeout
+// independently of the step timeout (AI hangs are common; record fetches are not).
+class AiInvokeTimeoutError extends WorkflowExecutorError {
+    constructor(timeoutMs) {
+        super(`AI provider did not respond within ${timeoutMs}ms`, 'The AI provider did not respond in time. Please try again, or contact your administrator if the problem persists.');
+    }
+}
+exports.AiInvokeTimeoutError = AiInvokeTimeoutError;
+class NoMcpToolsError extends WorkflowExecutorError {
+    constructor(requestedMcpServerId) {
+        super(`No MCP tools available for mcpServerId="${requestedMcpServerId}"`, 'Tools could not be loaded for the targeted server. Please try again, or contact your administrator if the problem persists.');
+    }
+}
+exports.NoMcpToolsError = NoMcpToolsError;
+class McpToolNotFoundError extends WorkflowExecutorError {
+    constructor(name) {
+        super(`MCP tool "${name}" not found`, "The AI selected a tool that doesn't exist. Try rephrasing the step's prompt.");
+    }
+}
+exports.McpToolNotFoundError = McpToolNotFoundError;
+class AgentPortError extends WorkflowExecutorError {
+    constructor(operation, cause) {
+        super(`Agent port "${operation}" failed: ${cause instanceof Error ? cause.message : String(cause)}`, 'An error occurred while accessing your data. Please try again.');
+        this.cause = cause;
+    }
+}
+exports.AgentPortError = AgentPortError;
+// Invariant guard: the agent port reads a collection's schema (for its primary keys) from the
+// cache, which the executor must populate via getCollectionSchema before any record access.
+class SchemaNotCachedError extends WorkflowExecutorError {
+    constructor(collectionName) {
+        super(`Collection schema for "${collectionName}" was not loaded before access — call getCollectionSchema first`, 'An error occurred while accessing your data. Please try again.');
+    }
+}
+exports.SchemaNotCachedError = SchemaNotCachedError;
+class WorkflowPortError extends WorkflowExecutorError {
+    constructor(operation, cause) {
+        super(`Workflow port "${operation}" failed: ${cause instanceof Error ? cause.message : String(cause)}`, "This step couldn't be completed. Please try again, and contact your administrator if the problem continues.");
+        this.cause = cause;
+    }
+}
+exports.WorkflowPortError = WorkflowPortError;
+class AiModelPortError extends WorkflowExecutorError {
+    constructor(operation, cause) {
+        super(`AI model "${operation}" failed: ${cause instanceof Error ? cause.message : String(cause)}`, 'The AI service is unavailable. Please try again or contact your administrator.');
+        this.cause = cause;
+    }
+}
+exports.AiModelPortError = AiModelPortError;
+class McpToolInvocationError extends WorkflowExecutorError {
+    constructor(toolName, cause) {
+        super(`MCP tool "${toolName}" invocation failed: ${cause instanceof Error ? cause.message : String(cause)}`, 'The tool failed to execute. Please try again or contact your administrator.');
+        this.cause = cause;
+    }
+}
+exports.McpToolInvocationError = McpToolInvocationError;
+class ConfigurationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ConfigurationError';
+    }
+}
+exports.ConfigurationError = ConfigurationError;
+class RunNotFoundError extends Error {
+    constructor(runId, cause) {
+        super(`Run "${runId}" not found or unavailable`);
+        this.name = 'RunNotFoundError';
+        if (cause !== undefined)
+            this.cause = cause;
+    }
+}
+exports.RunNotFoundError = RunNotFoundError;
+class UserMismatchError extends Error {
+    constructor(runId) {
+        super(`User not authorized for run "${runId}"`);
+        this.name = 'UserMismatchError';
+    }
+}
+exports.UserMismatchError = UserMismatchError;
+class RunAlreadyInFlightError extends Error {
+    constructor(runId) {
+        super(`Run "${runId}" is already being processed`);
+        this.name = 'RunAlreadyInFlightError';
+    }
+}
+exports.RunAlreadyInFlightError = RunAlreadyInFlightError;
+class PendingDataNotFoundError extends Error {
+    constructor(runId, stepIndex) {
+        super(`Step ${stepIndex} in run "${runId}" not found or has no pending data`);
+        this.name = 'PendingDataNotFoundError';
+    }
+}
+exports.PendingDataNotFoundError = PendingDataNotFoundError;
+class InvalidPendingDataError extends WorkflowExecutorError {
+    constructor(issues) {
+        super('Invalid pending data', 'The request body is invalid.');
+        this.issues = issues;
+    }
+}
+exports.InvalidPendingDataError = InvalidPendingDataError;
+class InvalidPreRecordedArgsError extends WorkflowExecutorError {
+    constructor(detail) {
+        super(`Invalid pre-recorded args: ${detail}`, 'The pre-configured step parameters are invalid');
+    }
+}
+exports.InvalidPreRecordedArgsError = InvalidPreRecordedArgsError;
+// Boundary error — surfaces from Runner.start() and is caught at the CLI/HTTP layer, not by step executors.
+class AgentProbeError extends Error {
+    constructor(message, options) {
+        super(`Agent probe failed: ${message}`);
+        this.name = 'AgentProbeError';
+        if (options?.cause !== undefined)
+            this.cause = options.cause;
+    }
+}
+exports.AgentProbeError = AgentProbeError;
+class UnsupportedStepTypeError extends WorkflowExecutorError {
+    constructor(stepType) {
+        super(`Step type "${stepType}" is not supported by the executor`, 'This step type is not yet supported.');
+    }
+}
+exports.UnsupportedStepTypeError = UnsupportedStepTypeError;
+class RecordIdSerializationError extends WorkflowExecutorError {
+    constructor(part) {
+        super(`Composite record id part "${part}" cannot contain the "|" separator`, 'A record identifier contains an unsupported character and cannot be processed.');
+    }
+}
+exports.RecordIdSerializationError = RecordIdSerializationError;
+class InvalidStepDefinitionError extends WorkflowExecutorError {
+    constructor(detail) {
+        super(`Invalid step definition: ${detail}`, 'The workflow step configuration is invalid. Please check the workflow designer.');
+    }
+}
+exports.InvalidStepDefinitionError = InvalidStepDefinitionError;
+// Thrown when zod validation fails on a domain object produced internally (e.g. by the
+// run-to-pending-step mapper). Distinct from InvalidStepDefinitionError (which flags wire-format
+// bugs coming from the orchestrator) so the two can be triaged separately in Sentry.
+class DomainValidationError extends WorkflowExecutorError {
+    constructor(runId, zodError) {
+        const issues = zodError.issues.map(i => ({
+            path: i.path.join('.') || '(root)',
+            message: i.message,
+        }));
+        const summary = issues.length
+            ? issues.map(i => `${i.path}: ${i.message}`).join('; ')
+            : '(no zod issues reported — unexpected empty ZodError)';
+        super(`Run ${runId} mapper produced invalid AvailableStepExecution — ${summary}`, 'Internal validation error occurred while preparing the step. Please contact support.');
+        this.cause = zodError;
+        this.issues = issues;
+    }
+}
+exports.DomainValidationError = DomainValidationError;
+// Carries MalformedRunInfo so the Runner can report the run without re-parsing the message.
+class MalformedRunError extends WorkflowExecutorError {
+    constructor(info) {
+        super(info.technicalMessage, info.userMessage);
+        this.info = info;
+    }
+}
+exports.MalformedRunError = MalformedRunError;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"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"}

package/dist/executors/activity-log.d.ts

@@ -0,0 +1,14 @@
+import type { ActivityLogPort, CreateActivityLogArgs } from '../ports/activity-log-port';
+import type { StepUser } from '../types/execution-context';
+export type AuditTarget = Omit<CreateActivityLogArgs, 'renderingId'>;
+export type TrackOptions<T> = {
+    operation: () => Promise<T>;
+    beforeCall?: () => Promise<void>;
+};
+export default class ActivityLog {
+    private readonly activityLogPort;
+    private readonly user;
+    constructor(activityLogPort: ActivityLogPort, user: StepUser);
+    track<T>(target: AuditTarget, { operation, beforeCall }: TrackOptions<T>): Promise<T>;
+}
+//# sourceMappingURL=activity-log.d.ts.map

package/dist/executors/activity-log.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Runs an operation while recording an activity-log entry around it (pending → success/failed).
+// It both executes `operation` and owns the activity-log transitions, so callers never touch the
+// ActivityLogPort directly. `beforeCall` runs after createPending, just before the operation, so
+// an audit-creation failure never leaves an orphan write-ahead marker.
+class ActivityLog {
+    constructor(activityLogPort, user) {
+        this.activityLogPort = activityLogPort;
+        this.user = user;
+    }
+    async track(target, { operation, beforeCall }) {
+        const handle = await this.activityLogPort.createPending({
+            renderingId: this.user.renderingId,
+            ...target,
+        });
+        try {
+            if (beforeCall)
+                await beforeCall();
+            const result = await operation();
+            void this.activityLogPort.markSucceeded(handle);
+            return result;
+        }
+        catch (err) {
+            // The step error is logged/surfaced by base-step-executor when rethrown, so the audit
+            // transition only needs the handle.
+            void this.activityLogPort.markFailed(handle);
+            throw err;
+        }
+    }
+}
+exports.default = ActivityLog;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aXZpdHktbG9nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2V4ZWN1dG9ycy9hY3Rpdml0eS1sb2cudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFhQSxnR0FBZ0c7QUFDaEcsaUdBQWlHO0FBQ2pHLGlHQUFpRztBQUNqRyx1RUFBdUU7QUFDdkUsTUFBcUIsV0FBVztJQUs5QixZQUFZLGVBQWdDLEVBQUUsSUFBYztRQUMxRCxJQUFJLENBQUMsZUFBZSxHQUFHLGVBQWUsQ0FBQztRQUN2QyxJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQztJQUNuQixDQUFDO0lBRUQsS0FBSyxDQUFDLEtBQUssQ0FBSSxNQUFtQixFQUFFLEVBQUUsU0FBUyxFQUFFLFVBQVUsRUFBbUI7UUFDNUUsTUFBTSxNQUFNLEdBQUcsTUFBTSxJQUFJLENBQUMsZUFBZSxDQUFDLGFBQWEsQ0FBQztZQUN0RCxXQUFXLEVBQUUsSUFBSSxDQUFDLElBQUksQ0FBQyxXQUFXO1lBQ2xDLEdBQUcsTUFBTTtTQUNWLENBQUMsQ0FBQztRQUVILElBQUksQ0FBQztZQUNILElBQUksVUFBVTtnQkFBRSxNQUFNLFVBQVUsRUFBRSxDQUFDO1lBQ25DLE1BQU0sTUFBTSxHQUFHLE1BQU0sU0FBUyxFQUFFLENBQUM7WUFDakMsS0FBSyxJQUFJLENBQUMsZUFBZSxDQUFDLGFBQWEsQ0FBQyxNQUFNLENBQUMsQ0FBQztZQUVoRCxPQUFPLE1BQU0sQ0FBQztRQUNoQixDQUFDO1FBQUMsT0FBTyxHQUFHLEVBQUUsQ0FBQztZQUNiLHNGQUFzRjtZQUN0RixvQ0FBb0M7WUFDcEMsS0FBSyxJQUFJLENBQUMsZUFBZSxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsQ0FBQztZQUM3QyxNQUFNLEdBQUcsQ0FBQztRQUNaLENBQUM7SUFDSCxDQUFDO0NBQ0Y7QUE3QkQsOEJBNkJDIn0=

package/dist/executors/agent-with-log.d.ts

@@ -0,0 +1,33 @@
+import type ActivityLog from './activity-log';
+import type { AgentPort, ExecuteActionQuery, GetActionFormInfoQuery, GetRecordQuery, GetRelatedDataQuery, GetSingleRelatedDataQuery, UpdateRecordQuery } from '../ports/agent-port';
+import type SchemaResolver from '../schema-resolver';
+import type { StepUser } from '../types/execution-context';
+import type { RecordData } from '../types/validated/collection';
+type WriteOptions = {
+    beforeCall: () => Promise<void>;
+};
+export interface AgentWithLogDeps {
+    agentPort: AgentPort;
+    schemaResolver: SchemaResolver;
+    user: StepUser;
+    activityLog: ActivityLog;
+}
+export default class AgentWithLog {
+    private readonly agentPort;
+    private readonly schemaResolver;
+    private readonly user;
+    private readonly activityLog;
+    constructor(deps: AgentWithLogDeps);
+    getRecord(query: GetRecordQuery): Promise<RecordData>;
+    getRelatedData(query: GetRelatedDataQuery): Promise<RecordData[]>;
+    getSingleRelatedData(query: GetSingleRelatedDataQuery): Promise<RecordData | null>;
+    updateRecord(query: UpdateRecordQuery, opts: WriteOptions): Promise<RecordData>;
+    executeAction(query: ExecuteActionQuery, opts: WriteOptions): Promise<unknown>;
+    getActionFormInfo(query: GetActionFormInfoQuery): Promise<{
+        hasForm: boolean;
+    }>;
+    private relationLabel;
+    private resolveSchema;
+}
+export {};
+//# sourceMappingURL=agent-with-log.d.ts.map

package/dist/executors/agent-with-log.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Wraps AgentPort and runs each data-access call through the ActivityLog so it records an
+// activity-log entry. The audit target is derived from the call: the numeric collectionId is
+// resolved from the call's collection name, the recordId from its id. Idempotency stays in the
+// executors: write methods forward a `beforeCall` thunk (the executor's write-ahead marker).
+class AgentWithLog {
+    constructor(deps) {
+        this.agentPort = deps.agentPort;
+        this.schemaResolver = deps.schemaResolver;
+        this.user = deps.user;
+        this.activityLog = deps.activityLog;
+    }
+    async getRecord(query) {
+        const { collectionId } = await this.resolveSchema(query.collection);
+        return this.activityLog.track({ action: 'index', type: 'read', collectionId, recordId: query.id }, { operation: () => this.agentPort.getRecord(query, this.user) });
+    }
+    async getRelatedData(query) {
+        const schema = await this.resolveSchema(query.collection);
+        return this.activityLog.track({
+            action: 'listRelatedData',
+            type: 'read',
+            collectionId: schema.collectionId,
+            recordId: query.id,
+            label: this.relationLabel(schema, query.relation),
+        }, { operation: () => this.agentPort.getRelatedData(query, this.user) });
+    }
+    async getSingleRelatedData(query) {
+        const schema = await this.resolveSchema(query.collection);
+        return this.activityLog.track({
+            action: 'listRelatedData',
+            type: 'read',
+            collectionId: schema.collectionId,
+            recordId: query.id,
+            label: this.relationLabel(schema, query.relation),
+        }, { operation: () => this.agentPort.getSingleRelatedData(query, this.user) });
+    }
+    async updateRecord(query, opts) {
+        const { collectionId } = await this.resolveSchema(query.collection);
+        return this.activityLog.track({ action: 'update', type: 'write', collectionId, recordId: query.id, label: 'updated' }, {
+            operation: () => this.agentPort.updateRecord(query, this.user),
+            beforeCall: opts.beforeCall,
+        });
+    }
+    async executeAction(query, opts) {
+        const { collectionId } = await this.resolveSchema(query.collection);
+        return this.activityLog.track({
+            action: 'action',
+            type: 'write',
+            collectionId,
+            recordId: query.id,
+            label: `triggered the action "${query.action}"`,
+        }, {
+            operation: () => this.agentPort.executeAction(query, this.user),
+            beforeCall: opts.beforeCall,
+        });
+    }
+    // Unaudited passthrough: form-info is a read-only probe (does this action have a form?),
+    // not a data access, so unlike the methods above it records NO activity-log entry.
+    getActionFormInfo(query) {
+        return this.agentPort.getActionFormInfo(query, this.user);
+    }
+    // ISO with the browser engine: `list relation "<displayName>"`. The query carries the technical
+    // relation name; resolve its displayName from the source schema, falling back to the technical
+    // name when the field is absent (resilient to orchestrator schema drift).
+    relationLabel(schema, relation) {
+        const displayName = schema.fields.filter(f => f.isRelationship).find(f => f.fieldName === relation)
+            ?.displayName ?? relation;
+        return `list relation "${displayName}"`;
+    }
+    resolveSchema(collectionName) {
+        return this.schemaResolver.resolve(collectionName);
+    }
+}
+exports.default = AgentWithLog;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,40 @@
+import type { ExecutionContext, IStepExecutor, StepExecutionResult } from '../types/execution-context';
+import type { ConfirmableStepExecutionData, StepExecutionData } from '../types/step-execution-data';
+import type { Step } from '../types/validated/execution';
+import type { StepDefinition } from '../types/validated/step-definition';
+import type { StepStatus } from '../types/validated/step-outcome';
+import type { BaseMessage, DynamicStructuredTool, StructuredToolInterface } from '@forestadmin/ai-proxy';
+import { SystemMessage } from '@forestadmin/ai-proxy';
+export default abstract class BaseStepExecutor<TStep extends StepDefinition = StepDefinition> implements IStepExecutor {
+    protected readonly context: ExecutionContext<TStep>;
+    constructor(context: ExecutionContext<TStep>);
+    execute(): Promise<StepExecutionResult>;
+    protected abstract doExecute(): Promise<StepExecutionResult>;
+    protected checkIdempotency(): Promise<StepExecutionResult | null>;
+    private runWithTimeout;
+    protected abstract buildOutcomeResult(outcome: {
+        status: StepStatus;
+        error?: string;
+    }): StepExecutionResult;
+    protected findPendingExecution<TExec extends ConfirmableStepExecutionData>(type: string): Promise<TExec | undefined>;
+    protected patchAndReloadPendingData<TExec extends ConfirmableStepExecutionData>(pendingData?: unknown): Promise<TExec | undefined>;
+    protected handleConfirmationFlow<TExec extends ConfirmableStepExecutionData>(execution: TExec, resolveAndExecute: (execution: TExec) => Promise<StepExecutionResult>): Promise<StepExecutionResult>;
+    protected buildContextMessage(): SystemMessage;
+    protected buildPreviousStepsMessages(): Promise<SystemMessage[]>;
+    protected resolveStepExecution(step: Step, executions: StepExecutionData[]): StepExecutionData | undefined;
+    private static mergeLeadingSystemMessages;
+    private static assertNoMidArraySystemMessages;
+    protected invokeWithTools<T = Record<string, unknown>>(messages: BaseMessage[], tools: StructuredToolInterface[]): Promise<{
+        toolName: string;
+        args: T;
+    }>;
+    protected invokeWithTool<T = Record<string, unknown>>(messages: BaseMessage[], tool: DynamicStructuredTool): Promise<T>;
+    protected getExtraLogContext(): Record<string, unknown>;
+    protected get logCtx(): {
+        runId: string;
+        stepId: string;
+        stepIndex: number;
+        stepType: import("../types/validated/step-definition").StepType;
+    };
+}
+//# sourceMappingURL=base-step-executor.d.ts.map