@forestadmin/workflow-executor 1.0.0

package/dist/adapters/forest-server-workflow-port.js

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const forestadmin_client_1 = require("@forestadmin/forestadmin-client");
+const zod_1 = require("zod");
+const console_logger_1 = __importDefault(require("./console-logger"));
+const run_to_available_step_mapper_1 = __importDefault(require("./run-to-available-step-mapper"));
+const step_outcome_to_update_step_mapper_1 = __importDefault(require("./step-outcome-to-update-step-mapper"));
+const with_retry_1 = __importDefault(require("./with-retry"));
+const errors_1 = require("../errors");
+const collection_1 = require("../types/validated/collection");
+const ROUTES = {
+    pendingRuns: '/api/workflow-orchestrator/pending-run',
+    availableRun: (runId) => `/api/workflow-orchestrator/available-run/${encodeURIComponent(runId)}`,
+    updateStep: '/api/workflow-orchestrator/update-step',
+    collectionSchema: (collectionName, runId) => `/api/workflow-orchestrator/collection-schema/${encodeURIComponent(collectionName)}?runId=${encodeURIComponent(runId)}`,
+    accessCheck: (runId, userId) => `/api/workflow-orchestrator/run/${encodeURIComponent(runId)}/access-check?userId=${userId}`,
+    mcpServerConfigs: '/liana/mcp-server-configs-with-details',
+};
+// Forest sends relatedCollectionName as a `collection.targetKey` reference (e.g. "store.id");
+// normalize it to a plain collection name (the related PK comes from the schema's primaryKeyFields).
+function stripReferenceKey(name) {
+    return name?.includes('.') ? name.slice(0, name.lastIndexOf('.')) : name;
+}
+class ForestServerWorkflowPort {
+    constructor(params) {
+        this.options = { envSecret: params.envSecret, forestServerUrl: params.forestServerUrl };
+        this.logger = params.logger ?? new console_logger_1.default();
+    }
+    async getAvailableRuns() {
+        const runs = await this.callPort('getAvailableRuns', () => forestadmin_client_1.ServerUtils.query(this.options, 'get', ROUTES.pendingRuns));
+        const pending = [];
+        const malformed = [];
+        for (const run of runs) {
+            try {
+                const dispatch = this.toDispatch(run);
+                if (dispatch)
+                    pending.push(dispatch);
+            }
+            catch (error) {
+                if (error instanceof errors_1.WorkflowExecutorError) {
+                    malformed.push(this.toMalformedInfo(run, error));
+                }
+                else {
+                    this.logger.error('Failed to hydrate pending run — unexpected error', {
+                        runId: run.id,
+                        error: (0, errors_1.extractErrorMessage)(error),
+                    });
+                }
+            }
+        }
+        return { pending, malformed };
+    }
+    async getAvailableRun(runId) {
+        const run = await this.callPort('getAvailableRun', () => forestadmin_client_1.ServerUtils.query(this.options, 'get', ROUTES.availableRun(runId)));
+        if (!run)
+            return null;
+        try {
+            return this.toDispatch(run);
+        }
+        catch (error) {
+            if (error instanceof errors_1.WorkflowExecutorError) {
+                throw new errors_1.MalformedRunError(this.toMalformedInfo(run, error));
+            }
+            /* istanbul ignore next — defensive fallback for unexpected non-domain errors */
+            throw error;
+        }
+    }
+    // Validates userProfile + serverToken at the adapter boundary. Split into two checks so an
+    // operator can diagnose "userProfile missing" vs "serverToken missing" from the error alone.
+    toDispatch(run) {
+        if (!run.userProfile) {
+            throw new errors_1.InvalidStepDefinitionError(`Run ${run.id} is missing required field userProfile — ` +
+                `the orchestrator must include it in the run payload`);
+        }
+        const token = run.userProfile.serverToken;
+        if (typeof token !== 'string' || !token) {
+            throw new errors_1.InvalidStepDefinitionError(`Run ${run.id} userProfile is missing serverToken — ` +
+                `the orchestrator must include it in the run payload`);
+        }
+        const step = (0, run_to_available_step_mapper_1.default)(run);
+        if (!step)
+            return null;
+        return { step, auth: { forestServerToken: token } };
+    }
+    toMalformedInfo(run, err) {
+        const pending = run.workflowHistory.at(-1) ?? null;
+        return {
+            runId: String(run.id),
+            stepId: pending?.stepName ?? null,
+            stepIndex: pending?.stepIndex ?? null,
+            userMessage: err.userMessage,
+            technicalMessage: err.message,
+        };
+    }
+    async updateStepExecution(runId, stepOutcome) {
+        return this.callPort('updateStepExecution', async () => {
+            const body = (0, step_outcome_to_update_step_mapper_1.default)(runId, stepOutcome);
+            const run = await forestadmin_client_1.ServerUtils.query(this.options, 'post', ROUTES.updateStep, {}, body);
+            if (!run)
+                return null;
+            try {
+                return this.toDispatch(run);
+            }
+            catch (error) {
+                // The outcome was recorded server-side; only the chain parse failed. Fall back to the
+                // next poll cycle — don't let a malformed chain response mask the successful update.
+                this.logger.error('Failed to parse chained next step from /update-step response', {
+                    runId: String(run.id),
+                    error: (0, errors_1.extractErrorMessage)(error),
+                });
+                return null;
+            }
+        }, { retry: true });
+    }
+    async getCollectionSchema(collectionName, runId) {
+        return this.callPort('getCollectionSchema', async () => {
+            const response = await forestadmin_client_1.ServerUtils.query(this.options, 'get', ROUTES.collectionSchema(collectionName, runId));
+            try {
+                const schema = collection_1.CollectionSchemaSchema.parse(response);
+                return {
+                    ...schema,
+                    fields: schema.fields.map(field => ({
+                        ...field,
+                        relatedCollectionName: stripReferenceKey(field.relatedCollectionName),
+                    })),
+                };
+            }
+            catch (err) {
+                if (err instanceof zod_1.z.ZodError) {
+                    // runId is passed for observability — the schema call is scoped to a run.
+                    throw new errors_1.DomainValidationError(Number(runId) || 0, err);
+                }
+                /* istanbul ignore next — zod.parse only throws ZodError; defensive fallback */
+                throw err;
+            }
+        }, { retry: true });
+    }
+    async getMcpServerConfigs() {
+        return this.callPort('getMcpServerConfigs', () => forestadmin_client_1.ServerUtils.query(this.options, 'get', ROUTES.mcpServerConfigs), { retry: true });
+    }
+    async hasRunAccess(runId, user) {
+        return this.callPort('hasRunAccess', async () => {
+            const { hasAccess } = await forestadmin_client_1.ServerUtils.query(this.options, 'get', ROUTES.accessCheck(runId, user.id));
+            return hasAccess === true;
+        });
+    }
+    async callPort(operation, fn, options) {
+        const run = options?.retry ? () => (0, with_retry_1.default)(operation, fn, { logger: this.logger }) : fn;
+        try {
+            return await run();
+        }
+        catch (cause) {
+            if (cause instanceof errors_1.WorkflowExecutorError)
+                throw cause;
+            throw new errors_1.WorkflowPortError(operation, cause);
+        }
+    }
+}
+exports.default = ForestServerWorkflowPort;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/adapters/forestadmin-client-activity-log-port-factory.d.ts

@@ -0,0 +1,12 @@
+import type { ActivityLogPort, ActivityLogPortFactory } from '../ports/activity-log-port';
+import type { Logger } from '../ports/logger-port';
+import type { ActivityLogsServiceInterface } from '@forestadmin/forestadmin-client';
+export default class ForestadminClientActivityLogPortFactory implements ActivityLogPortFactory {
+    private readonly service;
+    private readonly logger;
+    private readonly drainer;
+    constructor(service: ActivityLogsServiceInterface, logger: Logger);
+    forRun(forestServerToken: string): ActivityLogPort;
+    drain(): Promise<void>;
+}
+//# sourceMappingURL=forestadmin-client-activity-log-port-factory.d.ts.map

package/dist/adapters/forestadmin-client-activity-log-port-factory.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const activity_log_drainer_1 = __importDefault(require("./activity-log-drainer"));
+const forestadmin_client_activity_log_port_1 = __importDefault(require("./forestadmin-client-activity-log-port"));
+class ForestadminClientActivityLogPortFactory {
+    constructor(service, logger) {
+        this.service = service;
+        this.logger = logger;
+        this.drainer = new activity_log_drainer_1.default();
+    }
+    forRun(forestServerToken) {
+        return new forestadmin_client_activity_log_port_1.default(this.service, this.logger, forestServerToken, this.drainer);
+    }
+    async drain() {
+        return this.drainer.drain();
+    }
+}
+exports.default = ForestadminClientActivityLogPortFactory;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9yZXN0YWRtaW4tY2xpZW50LWFjdGl2aXR5LWxvZy1wb3J0LWZhY3RvcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYWRhcHRlcnMvZm9yZXN0YWRtaW4tY2xpZW50LWFjdGl2aXR5LWxvZy1wb3J0LWZhY3RvcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFJQSxrRkFBd0Q7QUFDeEQsa0hBQXNGO0FBRXRGLE1BQXFCLHVDQUF1QztJQUcxRCxZQUNtQixPQUFxQyxFQUNyQyxNQUFjO1FBRGQsWUFBTyxHQUFQLE9BQU8sQ0FBOEI7UUFDckMsV0FBTSxHQUFOLE1BQU0sQ0FBUTtRQUpoQixZQUFPLEdBQUcsSUFBSSw4QkFBa0IsRUFBRSxDQUFDO0lBS2pELENBQUM7SUFFSixNQUFNLENBQUMsaUJBQXlCO1FBQzlCLE9BQU8sSUFBSSw4Q0FBZ0MsQ0FDekMsSUFBSSxDQUFDLE9BQU8sRUFDWixJQUFJLENBQUMsTUFBTSxFQUNYLGlCQUFpQixFQUNqQixJQUFJLENBQUMsT0FBTyxDQUNiLENBQUM7SUFDSixDQUFDO0lBRUQsS0FBSyxDQUFDLEtBQUs7UUFDVCxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDOUIsQ0FBQztDQUNGO0FBcEJELDBEQW9CQyJ9

package/dist/adapters/forestadmin-client-activity-log-port.d.ts

@@ -0,0 +1,15 @@
+import type ActivityLogDrainer from './activity-log-drainer';
+import type { ActivityLogHandle, ActivityLogPort, CreateActivityLogArgs } from '../ports/activity-log-port';
+import type { Logger } from '../ports/logger-port';
+import type { ActivityLogsServiceInterface } from '@forestadmin/forestadmin-client';
+export default class ForestadminClientActivityLogPort implements ActivityLogPort {
+    private readonly service;
+    private readonly logger;
+    private readonly forestServerToken;
+    private readonly drainer;
+    constructor(service: ActivityLogsServiceInterface, logger: Logger, forestServerToken: string, drainer: ActivityLogDrainer);
+    createPending(args: CreateActivityLogArgs): Promise<ActivityLogHandle>;
+    markSucceeded(handle: ActivityLogHandle): Promise<void>;
+    markFailed(handle: ActivityLogHandle): Promise<void>;
+}
+//# sourceMappingURL=forestadmin-client-activity-log-port.d.ts.map

package/dist/adapters/forestadmin-client-activity-log-port.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const record_id_serializer_1 = require("./record-id-serializer");
+const with_retry_1 = __importDefault(require("./with-retry"));
+const errors_1 = require("../errors");
+class ForestadminClientActivityLogPort {
+    constructor(service, logger, forestServerToken, drainer) {
+        this.service = service;
+        this.logger = logger;
+        this.forestServerToken = forestServerToken;
+        this.drainer = drainer;
+    }
+    async createPending(args) {
+        try {
+            const response = await (0, with_retry_1.default)('activity log create', () => this.service.createActivityLog({
+                forestServerToken: this.forestServerToken,
+                renderingId: String(args.renderingId),
+                action: args.action,
+                type: args.type,
+                // The lib writes this value verbatim into relationships.collection.data.id
+                // (JSON:API). The Forest server audit-trail API expects the numeric collectionId.
+                collectionName: args.collectionId,
+                // Record ids are serialized to the pipe wire format here, never in the executor.
+                recordId: args.recordId?.length ? (0, record_id_serializer_1.serializeRecordId)(args.recordId) : undefined,
+                label: args.label,
+            }), { logger: this.logger });
+            return { id: response.id, index: response.attributes.index };
+        }
+        catch (cause) {
+            this.logger.error('activity log create failed', {
+                action: args.action,
+                collectionId: args.collectionId,
+                status: cause.status,
+                error: (0, errors_1.extractErrorMessage)(cause),
+            });
+            throw new errors_1.ActivityLogCreationError(cause);
+        }
+    }
+    async markSucceeded(handle) {
+        return this.drainer.track(async () => {
+            try {
+                await (0, with_retry_1.default)('activity log mark-as-completed', () => this.service.updateActivityLogStatus({
+                    forestServerToken: this.forestServerToken,
+                    activityLog: { id: handle.id, attributes: { index: handle.index } },
+                    status: 'completed',
+                }), { logger: this.logger, extraRetryStatuses: [404] });
+            }
+            catch (err) {
+                this.logger.error('activity log mark-as-completed failed', {
+                    handleId: handle.id,
+                    error: (0, errors_1.extractErrorMessage)(err),
+                });
+            }
+        });
+    }
+    async markFailed(handle) {
+        return this.drainer.track(async () => {
+            try {
+                await (0, with_retry_1.default)('activity log mark-as-failed', () => this.service.updateActivityLogStatus({
+                    forestServerToken: this.forestServerToken,
+                    activityLog: { id: handle.id, attributes: { index: handle.index } },
+                    status: 'failed',
+                }), { logger: this.logger, extraRetryStatuses: [404] });
+            }
+            catch (err) {
+                this.logger.error('activity log mark-as-failed failed', {
+                    handleId: handle.id,
+                    error: (0, errors_1.extractErrorMessage)(err),
+                });
+            }
+        });
+    }
+}
+exports.default = ForestadminClientActivityLogPort;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/adapters/pretty-logger.d.ts

@@ -0,0 +1,9 @@
+import type { Logger } from '../ports/logger-port';
+export default class PrettyLogger implements Logger {
+    info(message: string, context: Record<string, unknown>): void;
+    warn(message: string, context: Record<string, unknown>): void;
+    error(message: string, context: Record<string, unknown>): void;
+    private format;
+    private formatContext;
+}
+//# sourceMappingURL=pretty-logger.d.ts.map

package/dist/adapters/pretty-logger.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const picocolors_1 = __importDefault(require("picocolors"));
+// Colorized logger for TTY/dev. Pair with ConsoleLogger for piped output.
+// CLI auto-picks via process.stdout.isTTY + --pretty/--json flags. NO_COLOR is honored.
+class PrettyLogger {
+    info(message, context) {
+        // eslint-disable-next-line no-console
+        console.info(this.format(picocolors_1.default.cyan('info '), message, context));
+    }
+    warn(message, context) {
+        // eslint-disable-next-line no-console
+        console.warn(this.format(picocolors_1.default.yellow('warn '), message, context));
+    }
+    error(message, context) {
+        // eslint-disable-next-line no-console
+        console.error(this.format(picocolors_1.default.red('error'), message, context));
+    }
+    format(level, message, context) {
+        const timestamp = picocolors_1.default.dim(new Date().toISOString().substring(11, 19));
+        const contextStr = this.formatContext(context);
+        return contextStr
+            ? `${timestamp} ${level} ${message} ${contextStr}`
+            : `${timestamp} ${level} ${message}`;
+    }
+    formatContext(context) {
+        const parts = Object.entries(context).map(([key, value]) => `${key}=${JSON.stringify(value)}`);
+        if (parts.length === 0)
+            return '';
+        return picocolors_1.default.dim(parts.join(' '));
+    }
+}
+exports.default = PrettyLogger;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJldHR5LWxvZ2dlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hZGFwdGVycy9wcmV0dHktbG9nZ2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBRUEsNERBQTRCO0FBRTVCLDBFQUEwRTtBQUMxRSx3RkFBd0Y7QUFDeEYsTUFBcUIsWUFBWTtJQUMvQixJQUFJLENBQUMsT0FBZSxFQUFFLE9BQWdDO1FBQ3BELHNDQUFzQztRQUN0QyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsb0JBQUUsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLEVBQUUsT0FBTyxFQUFFLE9BQU8sQ0FBQyxDQUFDLENBQUM7SUFDaEUsQ0FBQztJQUVELElBQUksQ0FBQyxPQUFlLEVBQUUsT0FBZ0M7UUFDcEQsc0NBQXNDO1FBQ3RDLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxvQkFBRSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsRUFBRSxPQUFPLEVBQUUsT0FBTyxDQUFDLENBQUMsQ0FBQztJQUNsRSxDQUFDO0lBRUQsS0FBSyxDQUFDLE9BQWUsRUFBRSxPQUFnQztRQUNyRCxzQ0FBc0M7UUFDdEMsT0FBTyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLG9CQUFFLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxFQUFFLE9BQU8sRUFBRSxPQUFPLENBQUMsQ0FBQyxDQUFDO0lBQ2hFLENBQUM7SUFFTyxNQUFNLENBQUMsS0FBYSxFQUFFLE9BQWUsRUFBRSxPQUFnQztRQUM3RSxNQUFNLFNBQVMsR0FBRyxvQkFBRSxDQUFDLEdBQUcsQ0FBQyxJQUFJLElBQUksRUFBRSxDQUFDLFdBQVcsRUFBRSxDQUFDLFNBQVMsQ0FBQyxFQUFFLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQztRQUNyRSxNQUFNLFVBQVUsR0FBRyxJQUFJLENBQUMsYUFBYSxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBRS9DLE9BQU8sVUFBVTtZQUNmLENBQUMsQ0FBQyxHQUFHLFNBQVMsSUFBSSxLQUFLLElBQUksT0FBTyxJQUFJLFVBQVUsRUFBRTtZQUNsRCxDQUFDLENBQUMsR0FBRyxTQUFTLElBQUksS0FBSyxJQUFJLE9BQU8sRUFBRSxDQUFDO0lBQ3pDLENBQUM7SUFFTyxhQUFhLENBQUMsT0FBZ0M7UUFDcEQsTUFBTSxLQUFLLEdBQUcsTUFBTSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEdBQUcsRUFBRSxLQUFLLENBQUMsRUFBRSxFQUFFLENBQUMsR0FBRyxHQUFHLElBQUksSUFBSSxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDL0YsSUFBSSxLQUFLLENBQUMsTUFBTSxLQUFLLENBQUM7WUFBRSxPQUFPLEVBQUUsQ0FBQztRQUVsQyxPQUFPLG9CQUFFLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztJQUNqQyxDQUFDO0NBQ0Y7QUEvQkQsK0JBK0JDIn0=

package/dist/adapters/record-id-serializer.d.ts

@@ -0,0 +1,4 @@
+import type { RecordId } from '../types/validated/collection';
+export declare function serializeRecordId(recordId: RecordId): string;
+export declare function deserializeRecordId(value: string): string[];
+//# sourceMappingURL=record-id-serializer.d.ts.map

package/dist/adapters/record-id-serializer.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeRecordId = serializeRecordId;
+exports.deserializeRecordId = deserializeRecordId;
+const errors_1 = require("../errors");
+function serializeRecordId(recordId) {
+    return recordId
+        .map(part => {
+        const serialized = String(part);
+        if (serialized.includes('|')) {
+            throw new errors_1.RecordIdSerializationError(serialized);
+        }
+        return serialized;
+    })
+        .join('|');
+}
+function deserializeRecordId(value) {
+    return value.split('|');
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVjb3JkLWlkLXNlcmlhbGl6ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYWRhcHRlcnMvcmVjb3JkLWlkLXNlcmlhbGl6ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFJQSw4Q0FZQztBQUVELGtEQUVDO0FBbEJELHNDQUF1RDtBQUV2RCxTQUFnQixpQkFBaUIsQ0FBQyxRQUFrQjtJQUNsRCxPQUFPLFFBQVE7U0FDWixHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUU7UUFDVixNQUFNLFVBQVUsR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUM7UUFFaEMsSUFBSSxVQUFVLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUM7WUFDN0IsTUFBTSxJQUFJLG1DQUEwQixDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBQ25ELENBQUM7UUFFRCxPQUFPLFVBQVUsQ0FBQztJQUNwQixDQUFDLENBQUM7U0FDRCxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7QUFDZixDQUFDO0FBRUQsU0FBZ0IsbUJBQW1CLENBQUMsS0FBYTtJQUMvQyxPQUFPLEtBQUssQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUM7QUFDMUIsQ0FBQyJ9

package/dist/adapters/run-to-available-step-mapper.d.ts

@@ -0,0 +1,4 @@
+import type { ServerHydratedWorkflowRun } from './server-types';
+import { type AvailableStepExecution } from '../types/validated/execution';
+export default function toAvailableStepExecution(run: ServerHydratedWorkflowRun): AvailableStepExecution | null;
+//# sourceMappingURL=run-to-available-step-mapper.d.ts.map

package/dist/adapters/run-to-available-step-mapper.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = toAvailableStepExecution;
+const zod_1 = require("zod");
+const record_id_serializer_1 = require("./record-id-serializer");
+const step_definition_mapper_1 = __importDefault(require("./step-definition-mapper"));
+const errors_1 = require("../errors");
+const execution_1 = require("../types/validated/execution");
+const step_outcome_1 = require("../types/validated/step-outcome");
+function toRecordStatus(ctxStatus) {
+    if (ctxStatus === 'error')
+        return 'error';
+    if (ctxStatus === 'awaiting-input')
+        return 'awaiting-input';
+    return 'success';
+}
+// `context` may come from the executor (our StepOutcome, stored verbatim) or the legacy frontend
+// (free-form). We whitelist known fields per type to avoid leaking legacy ones back to the
+// orchestrator and to enforce the discriminated-union shape.
+function toStepOutcome(s) {
+    const stepDef = (0, step_definition_mapper_1.default)(s.stepDefinition);
+    const outcomeType = (0, step_outcome_1.stepTypeToOutcomeType)(stepDef.type);
+    const ctx = (s.context ?? {});
+    const baseFromCtx = {
+        stepId: s.stepName,
+        stepIndex: s.stepIndex,
+        error: typeof ctx.error === 'string' ? ctx.error : undefined,
+    };
+    if (outcomeType === 'condition') {
+        const status = toRecordStatus(ctx.status);
+        const selectedOption = typeof ctx.selectedOption === 'string' ? ctx.selectedOption : undefined;
+        return {
+            type: 'condition',
+            ...baseFromCtx,
+            status,
+            ...(selectedOption !== undefined && { selectedOption }),
+        };
+    }
+    if (outcomeType === 'guidance') {
+        const status = ctx.status === 'error' ? 'error' : 'success';
+        return { type: 'guidance', ...baseFromCtx, status };
+    }
+    const status = toRecordStatus(ctx.status);
+    if (outcomeType === 'mcp') {
+        return { type: 'mcp', ...baseFromCtx, status };
+    }
+    return { type: 'record', ...baseFromCtx, status };
+}
+function tryMapStep(s) {
+    try {
+        return {
+            stepDefinition: (0, step_definition_mapper_1.default)(s.stepDefinition),
+            stepOutcome: toStepOutcome(s),
+            ...(s.originalStepIndex !== undefined && { originalStepIndex: s.originalStepIndex }),
+        };
+    }
+    catch (err) {
+        // Sub-workflow navigation steps (start-sub-workflow, close-sub-workflow) are not
+        // meaningful for AI context — skip them rather than failing the whole run.
+        if (err instanceof errors_1.UnsupportedStepTypeError)
+            return null;
+        throw err;
+    }
+}
+// Mirrors the orchestrator's own read filter: revised and cancelled entries are not on the
+// live path.
+function toPreviousSteps(history, pendingStepIndex) {
+    return history
+        .filter(s => s.done && !s.revised && !s.cancelled && s.stepIndex < pendingStepIndex)
+        .map(s => tryMapStep(s))
+        .filter((s) => s !== null);
+}
+function toStepUser(runId, profile) {
+    // renderingId is stringified into the activity-log payload — reject non-finite so we don't
+    // silently post "undefined"/"NaN" to the audit trail.
+    if (typeof profile.renderingId !== 'number' || !Number.isFinite(profile.renderingId)) {
+        throw new errors_1.InvalidStepDefinitionError(`Run ${runId} userProfile has no valid renderingId (got "${String(profile.renderingId)}")`);
+    }
+    return {
+        id: profile.id,
+        email: profile.email,
+        firstName: profile.firstName ?? '',
+        lastName: profile.lastName ?? '',
+        team: profile.team ?? '',
+        renderingId: profile.renderingId,
+        role: profile.role ?? '',
+        permissionLevel: profile.permissionLevel ?? '',
+        tags: profile.tags,
+    };
+}
+// Returns null when the run has no available step (terminal state or all done/cancelled).
+// Throws InvalidStepDefinitionError on missing required fields (collectionId, collectionName,
+// userProfile) or an unmappable step definition.
+function toAvailableStepExecution(run) {
+    if (!run.collectionName) {
+        throw new errors_1.InvalidStepDefinitionError(`Run ${run.id} has no collectionName — cannot build baseRecordRef`);
+    }
+    if (!run.collectionId) {
+        throw new errors_1.InvalidStepDefinitionError(`Run ${run.id} has no collectionId — cannot build baseRecordRef`);
+    }
+    if (!run.selectedRecordId) {
+        throw new errors_1.InvalidStepDefinitionError(`Run ${run.id} has no selectedRecordId — cannot build baseRecordRef`);
+    }
+    const pending = run.workflowHistory.at(-1) ?? null;
+    if (!pending || pending.done)
+        return null;
+    const result = {
+        runId: String(run.id),
+        stepId: pending.stepName,
+        stepIndex: pending.stepIndex,
+        collectionId: run.collectionId,
+        baseRecordRef: {
+            collectionName: run.collectionName,
+            recordId: (0, record_id_serializer_1.deserializeRecordId)(run.selectedRecordId),
+            stepIndex: 0,
+        },
+        stepDefinition: (0, step_definition_mapper_1.default)(pending.stepDefinition),
+        previousSteps: toPreviousSteps(run.workflowHistory, pending.stepIndex),
+        user: toStepUser(run.id, run.userProfile),
+    };
+    // Defense against mapper bugs: zod asserts the shape we produce is what the domain expects,
+    // before any executor consumes it. Fails loudly with a typed error instead of crashing deep.
+    try {
+        return execution_1.AvailableStepExecutionSchema.parse(result);
+    }
+    catch (err) {
+        if (err instanceof zod_1.z.ZodError) {
+            throw new errors_1.DomainValidationError(run.id, err);
+        }
+        /* istanbul ignore next — zod.parse only throws ZodError; defensive fallback */
+        throw err;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/adapters/server-ai-adapter.d.ts

@@ -0,0 +1,16 @@
+import type { AiModelPort } from '../ports/ai-model-port';
+import type { BaseChatModel, RemoteTool, ToolConfig } from '@forestadmin/ai-proxy';
+export interface ServerAiAdapterOptions {
+    forestServerUrl: string;
+    envSecret: string;
+}
+export default class ServerAiAdapter implements AiModelPort {
+    private readonly aiClient;
+    constructor(options: ServerAiAdapterOptions);
+    getModel(): BaseChatModel;
+    loadRemoteTools(configs: Record<string, ToolConfig>): Promise<RemoteTool[]>;
+    closeConnections(): Promise<void>;
+    private static buildProxyConfiguration;
+    private callPort;
+}
+//# sourceMappingURL=server-ai-adapter.d.ts.map

package/dist/adapters/server-ai-adapter.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ai_proxy_1 = require("@forestadmin/ai-proxy");
+const errors_1 = require("../errors");
+class ServerAiAdapter {
+    constructor(options) {
+        this.aiClient = new ai_proxy_1.AiClient({
+            aiConfigurations: [ServerAiAdapter.buildProxyConfiguration(options)],
+        });
+    }
+    getModel() {
+        try {
+            return this.aiClient.getModel();
+        }
+        catch (cause) {
+            if (cause instanceof errors_1.WorkflowExecutorError)
+                throw cause;
+            throw new errors_1.AiModelPortError('getModel', cause);
+        }
+    }
+    loadRemoteTools(configs) {
+        return this.callPort('loadRemoteTools', () => this.aiClient.loadRemoteTools(configs));
+    }
+    closeConnections() {
+        return this.callPort('closeConnections', () => this.aiClient.closeConnections());
+    }
+    // Every call is routed to the Forest server's AI proxy, which picks the real provider/model.
+    // The model name is therefore a placeholder, and fetch is rewritten to hit the proxy with the
+    // env secret instead of an OpenAI Authorization header.
+    static buildProxyConfiguration({ forestServerUrl, envSecret, }) {
+        const aiProxyUrl = `${forestServerUrl}/liana/v1/ai-proxy`;
+        return {
+            name: 'forest-server',
+            provider: 'openai',
+            model: 'gpt-4.1',
+            maxRetries: 2,
+            configuration: {
+                apiKey: 'unused',
+                fetch: (_url, init) => {
+                    const headers = new Headers(init?.headers);
+                    headers.delete('authorization');
+                    headers.set('forest-secret-key', envSecret);
+                    return fetch(aiProxyUrl, { ...init, headers });
+                },
+            },
+        };
+    }
+    async callPort(operation, fn) {
+        try {
+            return await fn();
+        }
+        catch (cause) {
+            if (cause instanceof errors_1.WorkflowExecutorError)
+                throw cause;
+            throw new errors_1.AiModelPortError(operation, cause);
+        }
+    }
+}
+exports.default = ServerAiAdapter;
+//# sourceMappingURL=data:application/json;base64,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