@octaviaflow/flow-rules 0.1.0

package/dist/catalog/index.js

@@ -0,0 +1,168 @@
+/**
+ * Actions Registry
+ *
+ * Central registry for all built-in actions
+ * Each action is self-contained with its own configuration, UI, and metadata
+ */
+import { ActionCategory } from './types';
+// Trigger actions
+import { manualTriggerDefinition } from './triggers/manual-trigger';
+import { scheduleTriggerDefinition } from './triggers/schedule-trigger';
+import { webhookTriggerDefinition } from './triggers/webhook-trigger';
+import { connectorTriggerDefinition } from './triggers/connector-trigger';
+// Action actions
+import { httpRequestDefinition } from './actions/http-request';
+import { consoleLogDefinition } from './actions/console-log';
+import { delayDefinition } from './actions/delay';
+// Logic actions
+import { conditionDefinition } from './logic/condition';
+import { forEachDefinition } from './logic/for-each';
+import { groupDefinition } from './logic/group';
+// Transform actions
+// General actions (work across all platforms)
+import { queryDefinition } from './general/query';
+import { transformDefinition } from './general/transform';
+// `data_replication` was removed — it now lives as its own platform
+//. Workflows
+// that referenced it will fail with `unknown_action_type`; there is
+// no in-place migration by design.
+// Storage / File actions
+import { csvActionDefinition } from './storage/csv-action';
+import { jsonActionDefinition } from './storage/json-action';
+import { xmlActionDefinition } from './storage/xml-action';
+import { excelActionDefinition } from './storage/excel-action';
+import { s3ActionDefinition } from './storage/s3-action';
+import { ftpActionDefinition } from './storage/ftp-action';
+import { googleDriveActionDefinition } from './storage/google-drive-action';
+import { dropboxActionDefinition } from './storage/dropbox-action';
+import { onedriveActionDefinition } from './storage/onedrive-action';
+import { storageActionDefinition } from './storage/storage-action';
+// Communication actions
+import { emailDefinition } from './communication/email-send';
+import { slackMessageDefinition } from './communication/slack-message';
+import { whatsappSendDefinition } from './communication/whatsapp-send';
+import { teamsMessageDefinition } from './communication/teams-message';
+import { googleChatDefinition } from './communication/google-chat';
+import { webhookCallDefinition } from './communication/webhook-call';
+// Utility actions
+import { debugDefinition } from './utility/debug';
+import { errorDefinition } from './utility/error';
+import { variablesDefinition } from './utility/variables';
+// API actions
+import { graphqlQueryDefinition } from './api/graphql-query';
+// AI actions
+//
+// The only generic AI workflow action is `ai_agent` — a first-class Agent
+// reference (DEV-85, see the platform documentation).
+// The legacy `llm_chat` action was removed in DEV-93; any workflows that
+// referenced it fail with `unknown_action_type` (no migration, per user direction).
+//
+// Other removals (DEV-14 reshape):
+//   - llm_completion, classification, sentiment, summarization, translation,
+//     extraction, ml_inference — prompt-template wrappers with no engine impl.
+//   - embedding, vector_search — replaced by the Knowledge Bases app (DEV-16).
+//   - image_analysis, image_generation, speech_to_text, text_to_speech —
+//     niche; users hit the provider through HTTP Request.
+//
+// Document parsing belongs to the IDP app,
+// not a workflow action — except for `idp_extract` which orchestrates the IDP
+// service from inside a workflow.
+import { aiAgentDefinition } from './ai/ai-agent';
+import { idpExtractDefinition } from './ai/idp-extract';
+/**
+ * Registry of all available actions
+ * Organized by category for easy lookup and management
+ */
+export const actionsRegistry = {
+    [ActionCategory.Trigger]: {
+        manual_trigger: manualTriggerDefinition,
+        schedule_trigger: scheduleTriggerDefinition,
+        webhook_trigger: webhookTriggerDefinition,
+        connector_trigger: connectorTriggerDefinition,
+    },
+    [ActionCategory.Action]: {
+        http_request: httpRequestDefinition,
+        console_log: consoleLogDefinition,
+        delay: delayDefinition,
+        query: queryDefinition,
+        transform: transformDefinition,
+    },
+    [ActionCategory.Logic]: {
+        condition: conditionDefinition,
+        for_each: forEachDefinition,
+        group: groupDefinition,
+    },
+    [ActionCategory.Transform]: {
+    // Format action will be added when implemented
+    },
+    [ActionCategory.Database]: {},
+    [ActionCategory.Storage]: {
+        csv_action: csvActionDefinition,
+        json_action: jsonActionDefinition,
+        excel_action: excelActionDefinition,
+        xml_action: xmlActionDefinition,
+        // Unified Cloud Storage action — the one users add. The five per-provider
+        // actions below are kept registered (so existing nodes still resolve +
+        // edit + execute) but marked deprecated → hidden from the add-palette.
+        storage_action: storageActionDefinition,
+        s3_action: { ...s3ActionDefinition, deprecated: true, replacedBy: 'storage_action' },
+        ftp_action: { ...ftpActionDefinition, deprecated: true, replacedBy: 'storage_action' },
+        google_drive_action: { ...googleDriveActionDefinition, deprecated: true, replacedBy: 'storage_action' },
+        dropbox_action: { ...dropboxActionDefinition, deprecated: true, replacedBy: 'storage_action' },
+        onedrive_action: { ...onedriveActionDefinition, deprecated: true, replacedBy: 'storage_action' },
+    },
+    [ActionCategory.Communication]: {
+        email: emailDefinition,
+        slack_message: slackMessageDefinition,
+        whatsapp_send: whatsappSendDefinition,
+        teams_message: teamsMessageDefinition,
+        google_chat: googleChatDefinition,
+        webhook_call: webhookCallDefinition,
+    },
+    [ActionCategory.Utility]: {
+        variables: variablesDefinition,
+        debug: debugDefinition,
+    },
+    [ActionCategory.Ecommerce]: {},
+    [ActionCategory.API]: {
+    // GraphQL action will be added when implemented
+    },
+    [ActionCategory.AI]: {
+        ai_agent: aiAgentDefinition,
+        idp_extract: idpExtractDefinition,
+    },
+};
+/**
+ * Get all actions as a flat array
+ */
+export const getAllActions = () => {
+    const allActions = [];
+    for (const category of Object.values(actionsRegistry)) {
+        allActions.push(...Object.values(category).filter((action) => action !== undefined));
+    }
+    return allActions;
+};
+/**
+ * Get action by ID
+ */
+export const getActionById = (id) => {
+    for (const category of Object.values(actionsRegistry)) {
+        for (const action of Object.values(category)) {
+            if (action.id === id) {
+                return action;
+            }
+        }
+    }
+    return undefined;
+};
+/**
+ * Get actions by category
+ */
+export const getActionsByCategory = (category) => {
+    const categoryActions = actionsRegistry[category];
+    if (!categoryActions)
+        return [];
+    return Object.values(categoryActions);
+};
+// Export individual action definitions for direct imports
+export { csvActionDefinition, jsonActionDefinition, xmlActionDefinition, excelActionDefinition, s3ActionDefinition, ftpActionDefinition, googleDriveActionDefinition, dropboxActionDefinition, onedriveActionDefinition, manualTriggerDefinition, scheduleTriggerDefinition, webhookTriggerDefinition, httpRequestDefinition, consoleLogDefinition, delayDefinition, conditionDefinition, forEachDefinition, groupDefinition, queryDefinition, transformDefinition, debugDefinition, errorDefinition, variablesDefinition, graphqlQueryDefinition, emailDefinition, slackMessageDefinition, whatsappSendDefinition, teamsMessageDefinition, googleChatDefinition, webhookCallDefinition, aiAgentDefinition, idpExtractDefinition, };

package/dist/catalog/logic/condition/config.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Condition Configuration
+ *
+ * Defines the configuration structure and default values for the Condition action.
+ * Supports two modes:
+ *   - visual: a list of field/operator/value filter rows joined by AND/OR
+ *   - expression: a raw JavaScript expression
+ */
+export type ConditionOperator = 'equals' | 'not_equals' | 'greater_than' | 'greater_than_equals' | 'less_than' | 'less_than_equals' | 'like' | 'is_null' | 'is_not_null' | 'is_empty' | 'contains' | 'starts_with' | 'ends_with';
+export declare const CONDITION_OPERATORS: {
+    id: ConditionOperator;
+    label: string;
+    needsValue: boolean;
+}[];
+export interface ConditionFilter {
+    id: string;
+    field: string;
+    operator: ConditionOperator;
+    value: string;
+    logicalOperator?: 'and' | 'or';
+}
+export interface ConditionConfigType {
+    mode: 'visual' | 'expression';
+    filters: ConditionFilter[];
+    condition: string;
+    /** Auto-generated display name for the node */
+    name?: string;
+}
+export declare const ConditionConfig: {
+    defaults: ConditionConfigType;
+    schema: {
+        mode: {
+            type: string;
+            required: boolean;
+        };
+        filters: {
+            type: string;
+            required: boolean;
+        };
+        condition: {
+            type: string;
+            required: boolean;
+        };
+    };
+    validate: (config: Partial<ConditionConfigType>) => {
+        valid: boolean;
+        errors: string[];
+    };
+    merge: (userConfig: Partial<ConditionConfigType>) => ConditionConfigType;
+    /** Build a human-readable summary from visual filters */
+    generateName: (filters: ConditionFilter[]) => string;
+    getLabel: (config: ConditionConfigType) => string;
+    createFilterId: () => string;
+};

package/dist/catalog/logic/condition/config.js

@@ -0,0 +1,93 @@
+/**
+ * Condition Configuration
+ *
+ * Defines the configuration structure and default values for the Condition action.
+ * Supports two modes:
+ *   - visual: a list of field/operator/value filter rows joined by AND/OR
+ *   - expression: a raw JavaScript expression
+ */
+import { randomSuffix } from '../../../ids';
+export const CONDITION_OPERATORS = [
+    { id: 'equals', label: 'Equals', needsValue: true },
+    { id: 'not_equals', label: 'Not Equals', needsValue: true },
+    { id: 'greater_than', label: 'Greater Than', needsValue: true },
+    { id: 'greater_than_equals', label: 'Greater Than or Equals', needsValue: true },
+    { id: 'less_than', label: 'Less Than', needsValue: true },
+    { id: 'less_than_equals', label: 'Less Than or Equals', needsValue: true },
+    { id: 'like', label: 'Like', needsValue: true },
+    { id: 'contains', label: 'Contains', needsValue: true },
+    { id: 'starts_with', label: 'Starts With', needsValue: true },
+    { id: 'ends_with', label: 'Ends With', needsValue: true },
+    { id: 'is_null', label: 'Is Null', needsValue: false },
+    { id: 'is_not_null', label: 'Is Not Null', needsValue: false },
+    { id: 'is_empty', label: 'Is Empty', needsValue: false },
+];
+export const ConditionConfig = {
+    defaults: {
+        mode: 'visual',
+        filters: [],
+        condition: '',
+    },
+    schema: {
+        mode: { type: 'select', required: true },
+        filters: { type: 'array', required: false },
+        condition: { type: 'expression', required: false },
+    },
+    validate: (config) => {
+        const errors = [];
+        if (config.mode === 'expression') {
+            if (!config.condition) {
+                errors.push('Condition expression is required');
+            }
+            else {
+                try {
+                    new Function(`return ${config.condition}`);
+                }
+                catch (e) {
+                    errors.push(`Invalid expression: ${e instanceof Error ? e.message : 'Unknown error'}`);
+                }
+            }
+        }
+        else {
+            // Visual mode
+            if (!config.filters || config.filters.length === 0) {
+                errors.push('At least one condition filter is required');
+            }
+            else {
+                config.filters.forEach((f, i) => {
+                    if (!f.field)
+                        errors.push(`Filter ${i + 1}: Field is required`);
+                    if (!f.operator)
+                        errors.push(`Filter ${i + 1}: Operator is required`);
+                    const opDef = CONDITION_OPERATORS.find(o => o.id === f.operator);
+                    if (opDef?.needsValue && !f.value) {
+                        errors.push(`Filter ${i + 1}: Value is required`);
+                    }
+                });
+            }
+        }
+        return { valid: errors.length === 0, errors };
+    },
+    merge: (userConfig) => {
+        return { ...ConditionConfig.defaults, ...userConfig };
+    },
+    /** Build a human-readable summary from visual filters */
+    generateName: (filters) => {
+        if (filters.length === 0)
+            return 'If …';
+        const parts = filters.map((f, i) => {
+            const opLabel = CONDITION_OPERATORS.find(o => o.id === f.operator)?.label || f.operator;
+            const base = `${f.field || '?'} ${opLabel}${f.value ? ` ${f.value}` : ''}`;
+            if (i === 0)
+                return base;
+            return `${(f.logicalOperator || 'and').toUpperCase()} ${base}`;
+        });
+        return `If ${parts.join(' ')}`;
+    },
+    getLabel: (config) => {
+        if (config.mode === 'expression')
+            return `If ${config.condition || '…'}`;
+        return ConditionConfig.generateName(config.filters);
+    },
+    createFilterId: () => `cond_${Date.now()}_${randomSuffix(5)}`,
+};

package/dist/catalog/logic/condition/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Condition Action
+ *
+ * Branch workflow execution based on conditions
+ */
+import { ActionDefinition } from '../../types';
+export declare const conditionDefinition: ActionDefinition;

package/dist/catalog/logic/condition/index.js

@@ -0,0 +1,64 @@
+/**
+ * Condition Action
+ *
+ * Branch workflow execution based on conditions
+ */
+import { ActionCategory, ActionType, ActionStatus, FieldType } from '../../types';
+export const conditionDefinition = {
+    id: 'condition',
+    name: 'Condition',
+    description: 'Branch workflow execution based on conditions',
+    category: ActionCategory.Logic,
+    type: ActionType.Condition,
+    tags: ['logic', 'condition', 'branching', 'built-in'],
+    status: ActionStatus.Stable,
+    icon: 'DecisionTree',
+    color: '#f1c21b',
+    // NOTE: the Condition node renders via its custom ConditionConfigPanel
+    // (visual builder only), so these fallback fields aren't shown in the
+    // editor. Kept minimal + consistent with the visual-only authoring model.
+    inputSchema: {
+        fields: [
+            {
+                key: 'mode',
+                label: 'Mode',
+                type: FieldType.String,
+                description: 'Authoring mode (visual builder).',
+                defaultValue: 'visual',
+                validation: { required: true },
+            },
+            {
+                key: 'filters',
+                label: 'Condition Filters',
+                type: FieldType.Array,
+                description: 'Visual condition filters (field / operator / value rows)',
+                validation: { required: false },
+            },
+        ],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: [
+            {
+                key: 'result',
+                type: FieldType.Boolean,
+                description: 'Result of the condition evaluation',
+            },
+            {
+                key: 'branch',
+                type: FieldType.String,
+                description: 'Which branch was taken (true or false)',
+            },
+        ],
+        sampleOutput: {
+            result: true,
+            branch: 'true',
+        },
+    },
+    version: '1.0.0',
+    createdAt: '2025-01-01T00:00:00Z',
+    updatedAt: '2025-12-15T00:00:00Z',
+    createdBy: 'system',
+    isOfficial: true,
+    testable: true,
+};

package/dist/catalog/logic/for-each/config.d.ts

@@ -0,0 +1,100 @@
+/**
+ * ForEach Configuration
+ *
+ * A general, mode-based iteration primitive for ETL + agentic-ETL flows.
+ * The iteration mode is the core config axis; execution, resilience and
+ * output controls layer on top of any mode.
+ */
+export type ForEachMode = 'records' | 'fields' | 'range' | 'nested' | 'batch' | 'cursor' | 'while' | 'array';
+export interface ForEachConfigType {
+    /** Variable name exposed for each item (default: "item"). */
+    itemVariable: string;
+    /** Variable name exposed for the index (default: "index"). */
+    indexVariable: string;
+    /** Dot-path to the array in upstream data (e.g. "Account", "data.items"). */
+    arrayPath: string;
+    /** What to iterate over. Defaults to 'records'. */
+    iterationMode?: ForEachMode;
+    /** range mode — number of iterations (0..count-1). */
+    count?: number;
+    /** nested mode — dot-path to the sub-array inside each record. */
+    nestedPath?: string;
+    /** fields mode — allow-list of field names. Empty/absent → every field. */
+    fields?: string[];
+    /** sequential (default) or parallel. */
+    concurrency?: 'sequential' | 'parallel';
+    /** parallel cap (default 5). Never unbounded. */
+    maxConcurrency?: number;
+    /** batch mode — chunk size. */
+    batchSize: number;
+    /** throttle: max iteration launches per minute. */
+    rateLimitPerMinute?: number;
+    /** agentic throttle: max estimated tokens per minute. */
+    tokensPerMinute?: number;
+    /** continue past per-item failures (maps to onItemError: 'continue'). */
+    continueOnError: boolean;
+    /** explicit per-item failure policy (overrides continueOnError when set). */
+    onItemError?: 'fail-fast' | 'continue';
+    /** per-item retries (default 0). */
+    retryCount?: number;
+    /** base backoff between retries, doubled each attempt (default 250ms). */
+    retryBackoffMs?: number;
+    /** per-item timeout in ms (0/absent = none). */
+    itemTimeoutMs?: number;
+    /** abort once failed/processed exceeds this % (0-100). */
+    toleratedFailurePercentage?: number;
+    /** abort once this many items have failed. */
+    toleratedFailureCount?: number;
+    /** hard runaway cap for cursor/while (default 10000). */
+    maxIterations?: number;
+    /** dot-path on each item; items whose key was already seen are skipped. */
+    idempotencyKeyPath?: string;
+    /** how per-item results are collected (default 'array'). */
+    collect?: 'array' | 'none' | 'groupBy' | 'reduce';
+    /** groupBy — dot-path on each result used as the group key. */
+    groupByPath?: string;
+    /** reduce — built-in reduction over successful results. */
+    reduceOp?: 'sum' | 'count' | 'concat' | 'merge';
+    /** reduce — dot-path on each result to feed the reduction. */
+    reducePath?: string;
+    /** Per-item source schema captured for the FieldMapper (records/fields modes). */
+    _outputSchema?: unknown;
+    /** Auto-generated display name for the node. */
+    name?: string;
+}
+export declare const ForEachConfig: {
+    defaults: ForEachConfigType;
+    schema: {
+        arrayPath: {
+            type: string;
+            required: boolean;
+        };
+        iterationMode: {
+            type: string;
+            required: boolean;
+        };
+        itemVariable: {
+            type: string;
+            required: boolean;
+        };
+        indexVariable: {
+            type: string;
+            required: boolean;
+        };
+        batchSize: {
+            type: string;
+            required: boolean;
+        };
+        continueOnError: {
+            type: string;
+            required: boolean;
+        };
+    };
+    validate: (config: Partial<ForEachConfigType>) => {
+        valid: boolean;
+        errors: string[];
+    };
+    merge: (userConfig: Partial<ForEachConfigType>) => ForEachConfigType;
+    getLabel: (config: ForEachConfigType) => string;
+    generateName: (arrayPath: string) => string;
+};

package/dist/catalog/logic/for-each/config.js

@@ -0,0 +1,75 @@
+/**
+ * ForEach Configuration
+ *
+ * A general, mode-based iteration primitive for ETL + agentic-ETL flows.
+ * The iteration mode is the core config axis; execution, resilience and
+ * output controls layer on top of any mode.
+ */
+/** Modes that don't iterate an upstream array (no arrayPath required). */
+const SOURCELESS_MODES = new Set(['range', 'cursor', 'while']);
+export const ForEachConfig = {
+    defaults: {
+        arrayPath: '',
+        iterationMode: 'records',
+        itemVariable: 'item',
+        indexVariable: 'index',
+        batchSize: 0,
+        continueOnError: false,
+        concurrency: 'sequential',
+        collect: 'array',
+    },
+    schema: {
+        arrayPath: { type: 'select', required: false },
+        iterationMode: { type: 'select', required: false },
+        itemVariable: { type: 'string', required: true },
+        indexVariable: { type: 'string', required: false },
+        batchSize: { type: 'number', required: false },
+        continueOnError: { type: 'boolean', required: false },
+    },
+    validate: (config) => {
+        const errors = [];
+        const mode = (config.iterationMode || 'records');
+        if (mode === 'range') {
+            if (!config.count || config.count <= 0) {
+                errors.push('Range mode needs a positive iteration count');
+            }
+        }
+        else if (mode === 'nested') {
+            if (!config.arrayPath)
+                errors.push('Select the records to drill into');
+            if (!config.nestedPath)
+                errors.push('Nested mode needs the sub-array path to iterate (e.g. "lineItems")');
+        }
+        else if (!SOURCELESS_MODES.has(mode)) {
+            if (!config.arrayPath) {
+                errors.push('Array path is required — select which records to iterate over');
+            }
+        }
+        if (config.concurrency === 'parallel' && config.maxConcurrency !== undefined && config.maxConcurrency < 1) {
+            errors.push('Max concurrency must be at least 1');
+        }
+        if (config.batchSize !== undefined && config.batchSize < 0) {
+            errors.push('Batch size must be 0 (all) or a positive number');
+        }
+        if (config.collect === 'groupBy' && !config.groupByPath) {
+            errors.push('Group-by collection needs a field path to group on');
+        }
+        return { valid: errors.length === 0, errors };
+    },
+    merge: (userConfig) => {
+        return { ...ForEachConfig.defaults, ...userConfig };
+    },
+    getLabel: (config) => {
+        const mode = (config.iterationMode || 'records');
+        if (mode === 'range')
+            return `ForEach ×${config.count ?? '…'}`;
+        if (mode === 'cursor')
+            return 'ForEach (paginate)';
+        if (mode === 'while')
+            return 'ForEach (while)';
+        return `ForEach in ${config.arrayPath || '…'}`;
+    },
+    generateName: (arrayPath) => {
+        return `ForEach in ${arrayPath || '…'}`;
+    },
+};

package/dist/catalog/logic/for-each/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * ForEach Action
+ *
+ * Iterate over array items and execute actions for each
+ */
+import { ActionDefinition } from '../../types';
+export declare const forEachDefinition: ActionDefinition;

package/dist/catalog/logic/for-each/index.js

@@ -0,0 +1,92 @@
+/**
+ * ForEach Action
+ *
+ * Iterate over array items and execute actions for each
+ */
+import { ActionCategory, ActionType, ActionStatus, FieldType } from '../../types';
+export const forEachDefinition = {
+    id: 'for_each',
+    name: 'ForEach',
+    description: 'Iterate over array items and execute actions for each',
+    category: ActionCategory.Logic,
+    type: ActionType.ForEach,
+    tags: ['logic', 'loop', 'iteration', 'array', 'built-in'],
+    status: ActionStatus.Stable,
+    icon: 'Repeat',
+    color: '#f1c21b',
+    inputSchema: {
+        fields: [
+            {
+                key: 'arrayPath',
+                label: 'Records in',
+                type: FieldType.Expression,
+                description: 'Path to the array to iterate over',
+                placeholder: 'e.g., Account, data.items',
+                // NOT required (DEV-220 rules-engine parity with config.ts): in
+                // records mode ForEach auto-iterates the upstream step's rows when
+                // no explicit path is set, and several modes (range/while/…) never
+                // use it. The per-mode validate() in config.ts enforces it for the
+                // modes that genuinely need it — an unconditional `required` here
+                // made the rules engine flag correctly-configured loops.
+                validation: { required: false },
+            },
+            {
+                key: 'itemVariable',
+                label: 'Item Variable Name',
+                type: FieldType.String,
+                description: 'Name of the variable for each item',
+                defaultValue: 'item',
+                validation: { required: true },
+            },
+            {
+                key: 'indexVariable',
+                label: 'Index Variable Name',
+                type: FieldType.String,
+                description: 'Name of the variable for the index',
+                defaultValue: 'index',
+                validation: { required: false },
+            },
+            {
+                key: 'batchSize',
+                label: 'Batch Size',
+                type: FieldType.Number,
+                description: 'Number of items to process per batch (0 = all at once)',
+                defaultValue: 0,
+                validation: { required: false },
+            },
+            {
+                key: 'continueOnError',
+                label: 'Continue on Error',
+                type: FieldType.Boolean,
+                description: 'Whether to continue processing remaining items if one fails',
+                defaultValue: false,
+                validation: { required: false },
+            },
+        ],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: [
+            {
+                key: 'itemsProcessed',
+                type: FieldType.Number,
+                description: 'Number of items processed',
+            },
+            {
+                key: 'results',
+                type: FieldType.Array,
+                description: 'Results from each iteration',
+            },
+        ],
+        sampleOutput: {
+            itemsProcessed: 5,
+            results: [{ item: 1 }, { item: 2 }],
+        },
+    },
+    version: '1.0.0',
+    createdAt: '2025-01-01T00:00:00Z',
+    updatedAt: '2025-12-15T00:00:00Z',
+    createdBy: 'system',
+    isOfficial: true,
+    testable: true,
+};