@lowdefy/build 5.1.0 → 5.3.0

package/dist/build/buildAgents.js

@@ -0,0 +1,249 @@
+/* eslint-disable no-param-reassign */ /*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import path from 'path';
+import fs from 'fs';
+import { type } from '@lowdefy/helpers';
+import { ConfigError, ConfigWarning } from '@lowdefy/errors';
+import { RESERVED_PLATFORM_TOOL_NAMES } from '@lowdefy/ai-utils';
+import countOperators from '../utils/countOperators.js';
+import createCheckDuplicateId from '../utils/createCheckDuplicateId.js';
+function detectCycles(agents) {
+    const graph = {};
+    for (const agent of agents){
+        graph[agent.agentId] = (agent.agents ?? []).map((ref)=>ref.agentId);
+    }
+    const visited = new Set();
+    const inStack = new Set();
+    function dfs(id) {
+        if (inStack.has(id)) return id;
+        if (visited.has(id)) return null;
+        visited.add(id);
+        inStack.add(id);
+        for (const neighbor of graph[id] ?? []){
+            const cycleNode = dfs(neighbor);
+            if (cycleNode !== null) return cycleNode;
+        }
+        inStack.delete(id);
+        return null;
+    }
+    for (const id of Object.keys(graph)){
+        const cycleNode = dfs(id);
+        if (cycleNode !== null) {
+            return cycleNode;
+        }
+    }
+    return null;
+}
+function buildAgents({ components, context }) {
+    if (!type.isArray(components.agents)) {
+        return components;
+    }
+    context.agentIds = new Set();
+    const checkDuplicateAgentId = createCheckDuplicateId({
+        message: 'Duplicate agentId "{{ id }}".'
+    });
+    components.agents.forEach((agent)=>{
+        const configKey = agent['~k'];
+        // Check duplicates
+        checkDuplicateAgentId({
+            id: agent.id,
+            configKey
+        });
+        // Track type usage for buildTypes validation
+        context.typeCounters.agents.increment(agent.type, configKey);
+        // Validate connectionId is provided
+        if (type.isNone(agent.connectionId)) {
+            throw new ConfigError(`Agent connectionId is not defined at "${agent.id}".`, {
+                configKey
+            });
+        }
+        // Validate connectionId references an existing connection
+        // Connections may have been renamed by buildConnections:
+        //   connection.connectionId = original id, connection.id = 'connection:' + original id
+        const connectionExists = (components.connections ?? []).some((c)=>c.id === agent.connectionId || c.connectionId === agent.connectionId);
+        if (!connectionExists) {
+            throw new ConfigError(`Agent "${agent.id}" references connectionId "${agent.connectionId}" which does not exist.`, {
+                configKey
+            });
+        }
+        // Validate model is defined
+        if (type.isNone(agent.properties?.model)) {
+            throw new ConfigError(`Agent "model" is not defined at "${agent.id}".`, {
+                configKey
+            });
+        }
+        // Normalize tool strings to objects
+        agent.tools = (agent.tools ?? []).map((tool)=>{
+            if (type.isString(tool)) {
+                return {
+                    endpointId: tool
+                };
+            }
+            return tool;
+        });
+        // Validate tools reference existing API endpoints with required tool metadata
+        agent.tools.forEach((toolConfig)=>{
+            if (RESERVED_PLATFORM_TOOL_NAMES.includes(toolConfig.endpointId)) {
+                throw new ConfigError(`Agent "${agent.id}" tool "${toolConfig.endpointId}" uses a reserved platform tool name. Reserved: ${RESERVED_PLATFORM_TOOL_NAMES.join(', ')}.`, {
+                    configKey
+                });
+            }
+            const endpoint = (components.api ?? []).find((e)=>e.id === toolConfig.endpointId || e.endpointId === toolConfig.endpointId);
+            if (!endpoint) {
+                throw new ConfigError(`Agent "${agent.id}" references tool endpoint "${toolConfig.endpointId}" which does not exist.`, {
+                    configKey
+                });
+            }
+            if (type.isNone(endpoint.description)) {
+                throw new ConfigError(`Endpoint "${toolConfig.endpointId}" is used as an agent tool but does not have a "description".`, {
+                    configKey: endpoint['~k']
+                });
+            }
+            if (type.isNone(endpoint.payloadSchema)) {
+                throw new ConfigError(`Endpoint "${toolConfig.endpointId}" is used as an agent tool but does not have a "payloadSchema".`, {
+                    configKey: endpoint['~k']
+                });
+            }
+        });
+        // Normalize MCP string shorthand to connectionId objects (same pattern as tools)
+        agent.mcp = (agent.mcp ?? []).map((mcp)=>{
+            if (type.isString(mcp)) {
+                return {
+                    connectionId: mcp
+                };
+            }
+            return mcp;
+        });
+        // Validate MCP sources
+        agent.mcp.forEach((mcpSource, index)=>{
+            if (!type.isNone(mcpSource.connectionId)) {
+                // Validate connectionId references an existing connection
+                const mcpConnectionExists = (components.connections ?? []).some((c)=>c.id === mcpSource.connectionId || c.connectionId === mcpSource.connectionId);
+                if (!mcpConnectionExists) {
+                    throw new ConfigError(`Agent "${agent.id}" "mcp" source at index ${index} references connection "${mcpSource.connectionId}" which does not exist.`, {
+                        configKey
+                    });
+                }
+            } else if (mcpSource.transport === 'stdio') {
+                if (type.isNone(mcpSource.command)) {
+                    throw new ConfigError(`Agent "${agent.id}" "mcp" source at index ${index} uses stdio transport but is missing "command".`, {
+                        configKey
+                    });
+                }
+            } else {
+                if (type.isNone(mcpSource.url)) {
+                    throw new ConfigError(`Agent "${agent.id}" "mcp" source at index ${index} is missing "url".`, {
+                        configKey
+                    });
+                }
+            }
+        });
+        // Validate hooks reference existing API endpoints
+        const hookNames = [
+            'onStart',
+            'onStepStart',
+            'onToolCallStart',
+            'onToolCallFinish',
+            'onStepFinish',
+            'onFinish'
+        ];
+        hookNames.forEach((hookName)=>{
+            (agent.hooks?.[hookName] ?? []).forEach((endpointId)=>{
+                const endpoint = (components.api ?? []).find((e)=>e.id === endpointId || e.endpointId === endpointId);
+                if (!endpoint) {
+                    throw new ConfigError(`Agent "${agent.id}" hook "${hookName}" references endpoint "${endpointId}" which does not exist.`, {
+                        configKey
+                    });
+                }
+            });
+        });
+        // Normalize sub-agent strings to objects (same pattern as tools/mcp)
+        agent.agents = (agent.agents ?? []).map((ref)=>{
+            if (type.isString(ref)) {
+                return {
+                    agentId: ref
+                };
+            }
+            return ref;
+        });
+        // Validate fileSystem basePath if present
+        if (agent.properties?.fileSystem) {
+            const basePath = agent.properties.fileSystem.basePath;
+            if (!type.isString(basePath)) {
+                throw new ConfigError(`Agent "${agent.id}" fileSystem.basePath is not a string.`, {
+                    received: basePath,
+                    configKey
+                });
+            }
+            const resolved = path.resolve(context.directories.config, basePath);
+            if (!fs.existsSync(resolved)) {
+                throw new ConfigError(`Agent "${agent.id}" fileSystem.basePath "${basePath}" does not exist.`, {
+                    configKey
+                });
+            }
+        }
+        // Rename id to internal format
+        agent.agentId = agent.id;
+        context.agentIds.add(agent.agentId);
+        agent.id = `agent:${agent.agentId}`;
+        // Count server operators in properties
+        countOperators(agent.properties ?? {}, {
+            counter: context.typeCounters.operators.server
+        });
+    });
+    // Second pass: validate sub-agent references (needs all agentIds collected)
+    components.agents.forEach((agent)=>{
+        const configKey = agent['~k'];
+        agent.agents.forEach((subAgentRef)=>{
+            // Validate sub-agent reference exists
+            if (!context.agentIds.has(subAgentRef.agentId)) {
+                throw new ConfigError(`Agent "${agent.agentId}" references sub-agent "${subAgentRef.agentId}" which does not exist.`, {
+                    configKey
+                });
+            }
+            // Reserved platform tool name guard for sub-agents
+            if (RESERVED_PLATFORM_TOOL_NAMES.includes(subAgentRef.agentId)) {
+                throw new ConfigError(`Agent "${agent.agentId}" sub-agent "${subAgentRef.agentId}" uses a reserved platform tool name. Reserved: ${RESERVED_PLATFORM_TOOL_NAMES.join(', ')}.`, {
+                    configKey
+                });
+            }
+            // Check for name collision with endpoint tools
+            const hasToolCollision = agent.tools.some((toolConfig)=>toolConfig.endpointId === subAgentRef.agentId);
+            if (hasToolCollision) {
+                throw new ConfigError(`Agent "${agent.agentId}" sub-agent "${subAgentRef.agentId}" conflicts with an endpoint tool of the same name.`, {
+                    configKey
+                });
+            }
+            // Warn if sub-agent has tools with confirm: true (unsupported in sub-agent context)
+            const subAgent = components.agents.find((a)=>a.agentId === subAgentRef.agentId);
+            const hasConfirmTools = (subAgent?.tools ?? []).some((t)=>t.confirm);
+            if (hasConfirmTools) {
+                context.handleWarning(new ConfigWarning(`Agent "${subAgentRef.agentId}" has tools with confirm: true, but tool approval is not supported in sub-agent context. Tools will auto-execute when called as a sub-agent.`, {
+                    configKey
+                }));
+            }
+        });
+    });
+    // Detect circular sub-agent references
+    const cycleNode = detectCycles(components.agents);
+    if (cycleNode !== null) {
+        const agent = components.agents.find((a)=>a.agentId === cycleNode);
+        throw new ConfigError(`Circular sub-agent reference detected involving "${cycleNode}".`, {
+            configKey: agent?.['~k']
+        });
+    }
+    return components;
+}
+export default buildAgents;

package/dist/build/buildApi/buildRoutine/countStepTypes.js

@@ -13,6 +13,9 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ function countStepTypes(step, { typeCounters }) {
+    if (step.type === 'CallApi') {
+        return;
+    }
     typeCounters.requests.increment(step.type, step['~k']);
 }
 export default countStepTypes;

package/dist/build/buildApi/buildRoutine/setStepId.js

@@ -13,8 +13,9 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ function setStepId(step, { endpointId }) {
-    step.requestId = step.id;
+    step.stepId = step.id;
     step.endpointId = endpointId;
-    step.id = `request:${endpointId}:${step.requestId}`;
+    const prefix = step.type === 'CallApi' ? 'endpoint' : 'request';
+    step.id = `${prefix}:${endpointId}:${step.stepId}`;
 }
 export default setStepId;

package/dist/build/buildApi/buildRoutine/validateStep.js

@@ -50,6 +50,25 @@ function validateStep(step, { endpointId }) {
             configKey
         });
     }
+    if (step.type === 'CallApi') {
+        if (type.isNone(step.properties?.endpointId)) {
+            throw new ConfigError(`Endpoint step "${step.id}" at endpoint "${endpointId}" requires properties.endpointId.`, {
+                configKey
+            });
+        }
+        if (!type.isString(step.properties.endpointId) && !type.isObject(step.properties.endpointId)) {
+            throw new ConfigError(`Endpoint step "${step.id}" at endpoint "${endpointId}" properties.endpointId is not a string.`, {
+                received: step.properties.endpointId,
+                configKey
+            });
+        }
+        if (!type.isNone(step.connectionId)) {
+            throw new ConfigError(`Endpoint step "${step.id}" at endpoint "${endpointId}" should not have a connectionId.`, {
+                configKey
+            });
+        }
+        return;
+    }
     if (type.isUndefined(step.connectionId)) {
         throw new ConfigError(`Step connectionId missing at endpoint "${endpointId}".`, {
             configKey

package/dist/build/buildApi/validateEndpoint.js

@@ -44,6 +44,16 @@ function validateEndpoint({ endpoint, index, checkDuplicateEndpointId }) {
             configKey
         });
     }
+    const validEndpointTypes = [
+        'Api',
+        'InternalApi'
+    ];
+    if (!validEndpointTypes.includes(endpoint.type)) {
+        throw new ConfigError(`Endpoint type "${endpoint.type}" is not valid at "${endpoint.id}". Must be one of: ${validEndpointTypes.join(', ')}.`, {
+            received: endpoint.type,
+            configKey
+        });
+    }
     checkDuplicateEndpointId({
         id: endpoint.id,
         configKey

package/dist/build/buildApi/validateStepReferences.js

@@ -17,16 +17,16 @@ import { type } from '@lowdefy/helpers';
 import extractOperatorKey from '../../utils/extractOperatorKey.js';
 import traverseConfig from '../../utils/traverseConfig.js';
 // Collect all step IDs from a routine (including nested control structures)
-// Note: After buildRoutine, steps have requestId (original id) and id is modified
+// Note: After buildRoutine, steps have stepId (original id) and id is modified
 function collectStepIds(routine, stepIds) {
     if (type.isArray(routine)) {
         routine.forEach((item)=>collectStepIds(item, stepIds));
         return;
     }
     if (type.isObject(routine)) {
-        // Check if this is a step (has requestId after build, or id before build)
-        if (routine.requestId) {
-            stepIds.add(routine.requestId);
+        // Check if this is a step (has stepId after build, or id before build)
+        if (routine.stepId) {
+            stepIds.add(routine.stepId);
         }
         // Recurse into all values (handles control structures like :then, :else, :try, :catch)
         Object.values(routine).forEach((value)=>collectStepIds(value, stepIds));

package/dist/build/buildAuth/buildApiAuth.js

@@ -16,6 +16,7 @@
 import { ConfigError } from '@lowdefy/errors';
 import getApiRoles from './getApiRoles.js';
 import getProtectedApi from './getProtectedApi.js';
+import { isInPatternList } from './matchPattern.js';
 function buildApiAuth({ components, context }) {
     const protectedApiEndpoints = getProtectedApi({
         components
@@ -29,7 +30,7 @@ function buildApiAuth({ components, context }) {
     }
     (components.api || []).forEach((endpoint)=>{
         if (apiRoles[endpoint.id]) {
-            if (configPublicApi.includes(endpoint.id)) {
+            if (isInPatternList(endpoint.id, configPublicApi)) {
                 throw new ConfigError(`Endpoint "${endpoint.id}" is both protected by roles and public.`, {
                     received: apiRoles[endpoint.id],
                     configKey: endpoint['~k']

package/dist/build/buildAuth/buildPageAuth.js

@@ -16,6 +16,7 @@
 import { ConfigError } from '@lowdefy/errors';
 import getPageRoles from './getPageRoles.js';
 import getProtectedPages from './getProtectedPages.js';
+import { isInPatternList } from './matchPattern.js';
 function buildPageAuth({ components, context }) {
     const protectedPages = getProtectedPages({
         components
@@ -36,7 +37,7 @@ function buildPageAuth({ components, context }) {
             return;
         }
         if (pageRoles[page.id]) {
-            if (configPublicPages.includes(page.id)) {
+            if (isInPatternList(page.id, configPublicPages)) {
                 throw new ConfigError(`Page "${page.id}" is both protected by roles and public.`, {
                     received: pageRoles[page.id],
                     configKey: page['~k']

package/dist/build/buildAuth/getApiRoles.js

@@ -12,15 +12,21 @@
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-*/ function getApiRoles({ components }) {
+*/ import { matchesPattern } from './matchPattern.js';
+function getApiRoles({ components }) {
     const roles = components.auth.api.roles;
+    const endpointIds = (components.api ?? []).map((e)=>e.id);
     const apiRoles = {};
     Object.keys(roles).forEach((roleName)=>{
-        roles[roleName].forEach((endpointId)=>{
-            if (!apiRoles[endpointId]) {
-                apiRoles[endpointId] = new Set();
-            }
-            apiRoles[endpointId].add(roleName);
+        roles[roleName].forEach((pattern)=>{
+            endpointIds.forEach((endpointId)=>{
+                if (matchesPattern(endpointId, pattern)) {
+                    if (!apiRoles[endpointId]) {
+                        apiRoles[endpointId] = new Set();
+                    }
+                    apiRoles[endpointId].add(roleName);
+                }
+            });
         });
     });
     Object.keys(apiRoles).forEach((endpointId)=>{

package/dist/build/buildAuth/getPageRoles.js

@@ -12,15 +12,21 @@
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-*/ function getPageRoles({ components }) {
+*/ import { matchesPattern } from './matchPattern.js';
+function getPageRoles({ components }) {
     const roles = components.auth.pages.roles;
+    const pageIds = (components.pages ?? []).map((p)=>p.id);
     const pageRoles = {};
     Object.keys(roles).forEach((roleName)=>{
-        roles[roleName].forEach((pageId)=>{
-            if (!pageRoles[pageId]) {
-                pageRoles[pageId] = new Set();
-            }
-            pageRoles[pageId].add(roleName);
+        roles[roleName].forEach((pattern)=>{
+            pageIds.forEach((pageId)=>{
+                if (matchesPattern(pageId, pattern)) {
+                    if (!pageRoles[pageId]) {
+                        pageRoles[pageId] = new Set();
+                    }
+                    pageRoles[pageId].add(roleName);
+                }
+            });
         });
     });
     Object.keys(pageRoles).forEach((pageId)=>{

package/dist/build/buildAuth/getProtectedApi.js

@@ -13,15 +13,16 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { type } from '@lowdefy/helpers';
+import { isInPatternList } from './matchPattern.js';
 function getProtectedApi({ components }) {
     const endpointIds = (components.api || []).map((endpoint)=>endpoint.id);
     let protectedApi = [];
     if (type.isArray(components.auth.api.public)) {
-        protectedApi = endpointIds.filter((endpointId)=>!components.auth.api.public.includes(endpointId));
+        protectedApi = endpointIds.filter((endpointId)=>!isInPatternList(endpointId, components.auth.api.public));
     } else if (components.auth.api.protected === true) {
         protectedApi = endpointIds;
     } else if (type.isArray(components.auth.api.protected)) {
-        protectedApi = components.auth.api.protected;
+        protectedApi = endpointIds.filter((endpointId)=>isInPatternList(endpointId, components.auth.api.protected));
     }
     return protectedApi;
 }

package/dist/build/buildAuth/getProtectedPages.js

@@ -13,15 +13,16 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { type } from '@lowdefy/helpers';
+import { isInPatternList } from './matchPattern.js';
 function getProtectedPages({ components }) {
     const pageIds = (components.pages || []).map((page)=>page.id);
     let protectedPages = [];
     if (type.isArray(components.auth.pages.public)) {
-        protectedPages = pageIds.filter((pageId)=>!components.auth.pages.public.includes(pageId));
+        protectedPages = pageIds.filter((pageId)=>!isInPatternList(pageId, components.auth.pages.public));
     } else if (components.auth.pages.protected === true) {
         protectedPages = pageIds;
     } else if (type.isArray(components.auth.pages.protected)) {
-        protectedPages = components.auth.pages.protected;
+        protectedPages = pageIds.filter((pageId)=>isInPatternList(pageId, components.auth.pages.protected));
     }
     return protectedPages;
 }

package/dist/build/buildAuth/matchPattern.js

@@ -0,0 +1,22 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import picomatch from 'picomatch';
+function matchesPattern(id, pattern) {
+    return picomatch.isMatch(id, pattern);
+}
+function isInPatternList(id, patternList) {
+    return patternList.some((pattern)=>matchesPattern(id, pattern));
+}
+export { matchesPattern, isInPatternList };

package/dist/build/buildConnections.js

@@ -12,20 +12,58 @@
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-*/ import countOperators from '../utils/countOperators.js';
+*/ import { type } from '@lowdefy/helpers';
+import { ConfigError } from '@lowdefy/errors';
+import collectExceptions from '../utils/collectExceptions.js';
+import countOperators from '../utils/countOperators.js';
 import createCheckDuplicateId from '../utils/createCheckDuplicateId.js';
 import validateId from '../utils/validateId.js';
+function validateConnection(connection, context) {
+    const configKey = connection?.['~k'];
+    if (!type.isObject(connection)) {
+        collectExceptions(context, new ConfigError('Connection should be an object.', {
+            received: connection,
+            configKey
+        }));
+        return false;
+    }
+    if (type.isUndefined(connection.id)) {
+        collectExceptions(context, new ConfigError('Connection id missing.', {
+            configKey
+        }));
+        return false;
+    }
+    if (!type.isString(connection.id)) {
+        collectExceptions(context, new ConfigError('Connection id is not a string.', {
+            received: connection.id,
+            configKey
+        }));
+        return false;
+    }
+    if (type.isNone(connection.type)) {
+        collectExceptions(context, new ConfigError(`Connection type is not defined at connection "${connection.id}".`, {
+            configKey
+        }));
+        return false;
+    }
+    if (!type.isString(connection.type)) {
+        collectExceptions(context, new ConfigError(`Connection type is not a string at connection "${connection.id}".`, {
+            received: connection.type,
+            configKey
+        }));
+        return false;
+    }
+    return true;
+}
 function buildConnections({ components, context }) {
     // Store connection IDs for validation in buildRequests
     context.connectionIds = new Set();
-    // Schema validates: id required, id is string, type is string
-    // Only check for duplicates here (schema can't do that)
     const checkDuplicateConnectionId = createCheckDuplicateId({
         message: 'Duplicate connectionId "{{ id }}".'
     });
     (components.connections ?? []).forEach((connection)=>{
+        if (!validateConnection(connection, context)) return;
         const configKey = connection['~k'];
-        // Check duplicates (schema can't validate this)
         checkDuplicateConnectionId({
             id: connection.id,
             configKey

package/dist/build/buildImports/buildImportsDev.js

@@ -22,6 +22,7 @@ function getPluginPackages({ components }) {
         });
     }
     getPackages(components.types.actions);
+    getPackages(components.types.agents);
     getPackages(components.types.auth.adapters);
     getPackages(components.types.auth.callbacks);
     getPackages(components.types.auth.events);
@@ -53,6 +54,10 @@ function buildImportsDev({ components, context }) {
             pluginPackages,
             map: context.typesMap.actions
         }),
+        agents: buildImportClassDev({
+            pluginPackages,
+            map: context.typesMap.agents
+        }),
         auth: {
             adapters: buildImportClassDev({
                 pluginPackages,

package/dist/build/buildImports/buildImportsProd.js

@@ -25,6 +25,7 @@ function buildImportsProd({ components, context }) {
     const blocks = buildImportClassProd(components.types.blocks);
     return {
         actions: buildImportClassProd(components.types.actions),
+        agents: buildImportClassProd(components.types.agents),
         auth: {
             adapters: buildImportClassProd(components.types.auth.adapters),
             callbacks: buildImportClassProd(components.types.auth.callbacks),

package/dist/build/buildJs/jsMapParser.js

@@ -15,12 +15,10 @@
 */ import { ConfigError } from '@lowdefy/errors';
 import { serializer, type } from '@lowdefy/helpers';
 import crypto from 'crypto';
-function makeHash({ jsMap, env, value }) {
+function hashFn({ jsMap, env, value }) {
     const hash = crypto.createHash('sha1').update(value).digest('base64');
     jsMap[env][hash] = value;
-    return {
-        _js: hash
-    };
+    return hash;
 }
 function JsMapParser({ input, jsMap, env }) {
     if (!jsMap[env]) {
@@ -31,15 +29,30 @@ function JsMapParser({ input, jsMap, env }) {
         if (Object.keys(value).length !== 1) return value;
         const key = Object.keys(value)[0];
         if (key !== '_js') return value;
-        if (!type.isString(value[key])) {
-            throw new ConfigError(`_js operator expects the JavaScript definition as a string. Received ${JSON.stringify(value[key])}.`, {
-                configKey: value['~k']
-            });
+        const inner = value[key];
+        if (type.isString(inner)) {
+            return {
+                _js: hashFn({
+                    jsMap,
+                    env,
+                    value: inner
+                })
+            };
+        }
+        if (type.isObject(inner) && type.isString(inner.fn)) {
+            return {
+                _js: {
+                    fn: hashFn({
+                        jsMap,
+                        env,
+                        value: inner.fn
+                    }),
+                    args: inner.args
+                }
+            };
         }
-        return makeHash({
-            jsMap,
-            env,
-            value: value[key]
+        throw new ConfigError(`_js operator expects a JavaScript string or { fn: string, args?: object }. Received ${JSON.stringify(inner)}.`, {
+            configKey: value['~k']
         });
     };
     return serializer.copy(input, {

package/dist/build/buildJs/writeJs.js

@@ -16,11 +16,11 @@
 async function writeJs({ context }) {
     await context.writeBuildArtifact('plugins/operators/clientJsMap.js', generateJsFile({
         map: context.jsMap.client,
-        functionPrototype: `{ actions, event, input, location, lowdefyGlobal, request, state, urlQuery, user }`
+        functionPrototype: `{ actions, args, event, input, location, lowdefyGlobal, request, state, urlQuery, user }`
     }));
     await context.writeBuildArtifact('plugins/operators/serverJsMap.js', generateJsFile({
         map: context.jsMap.server,
-        functionPrototype: `{ item, payload, secrets, state, step, user }`
+        functionPrototype: `{ args, item, payload, secrets, state, step, user }`
     }));
 }
 export default writeJs;