@lowdefy/api 5.2.0 → 5.4.0

package/dist/context/createApiContext.js

@@ -14,9 +14,21 @@
   limitations under the License.
 */ import createAuthorize from './createAuthorize.js';
 import createReadConfigFile from './createReadConfigFile.js';
+import resolveLocale from './resolveLocale.js';
 function createApiContext(context) {
-    context.state = {};
     context.user = context?.session?.user;
+    if (context.i18n?.defaultLocale) {
+        const active = resolveLocale({
+            i18n: context.i18n,
+            headers: context.headers
+        });
+        context.i18n = {
+            ...context.i18n,
+            active
+        };
+    } else {
+        context.i18n = undefined;
+    }
     context.authorize = createAuthorize(context);
     context.readConfigFile = createReadConfigFile(context);
 }

package/dist/context/createEvaluateOperators.js

@@ -14,20 +14,22 @@
   limitations under the License.
 */ import { ServerParser } from '@lowdefy/operators';
 function createEvaluateOperators(context) {
-    const { jsMap, operators, secrets, state, user } = context;
+    const { appMeta, i18n, jsMap, operators, secrets, user } = context;
     const operatorsParser = new ServerParser({
+        i18n,
         jsMap,
+        lowdefyApp: appMeta,
         operators,
         secrets,
-        state,
         user
     });
-    function evaluateOperators({ input, items, location, payload, steps }) {
+    function evaluateOperators({ input, items, location, payload, state, steps }) {
         const { output, errors } = operatorsParser.parse({
             input,
             items,
             location,
             payload,
+            state,
             steps
         });
         if (errors.length > 0) {

package/dist/context/resolveLocale.js

@@ -0,0 +1,47 @@
+/*
+  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 { type } from '@lowdefy/helpers';
+function parseAcceptLanguage(header) {
+    if (!type.isString(header)) return [];
+    return header.split(',').map((entry)=>{
+        const [code, ...params] = entry.trim().split(';').map((s)=>s.trim());
+        const qParam = params.find((p)=>p.startsWith('q='));
+        const q = qParam ? parseFloat(qParam.slice(2)) : 1;
+        return {
+            code,
+            q: Number.isFinite(q) ? q : 0
+        };
+    }).filter(({ code })=>code.length > 0).sort((a, b)=>b.q - a.q).map(({ code })=>code);
+}
+function pickBest(candidates, supported) {
+    for (const candidate of candidates){
+        if (supported.includes(candidate)) return candidate;
+        const primary = candidate.split('-')[0].toLowerCase();
+        const match = supported.find((code)=>code.split('-')[0].toLowerCase() === primary);
+        if (match) return match;
+    }
+    return undefined;
+}
+function resolveLocale({ i18n, headers }) {
+    if (!i18n || !type.isString(i18n.defaultLocale) || !type.isArray(i18n.locales)) {
+        return undefined;
+    }
+    const supportedCodes = i18n.locales.map((l)=>l.code);
+    const acceptLanguage = headers?.['accept-language'];
+    const candidates = parseAcceptLanguage(acceptLanguage);
+    const matched = pickBest(candidates, supportedCodes);
+    return matched ?? i18n.defaultLocale;
+}
+export default resolveLocale;

package/dist/index.js

@@ -12,7 +12,8 @@
   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 callEndpoint from './routes/endpoints/callEndpoint.js';
+*/ import callAgent from './routes/agent/callAgent.js';
+import callEndpoint from './routes/endpoints/callEndpoint.js';
 import callRequest from './routes/request/callRequest.js';
 import createApiContext from './context/createApiContext.js';
 import createSessionCallback from './routes/auth/callbacks/createSessionCallback.js';
@@ -21,4 +22,4 @@ import getNextAuthConfig from './routes/auth/getNextAuthConfig.js';
 import getPageConfig from './routes/page/getPageConfig.js';
 import getRootConfig from './routes/rootConfig/getRootConfig.js';
 import logClientError from './routes/log/logClientError.js';
-export { callEndpoint, callRequest, createApiContext, createSessionCallback, getHomeAndMenus, getNextAuthConfig, getPageConfig, getRootConfig, logClientError };
+export { callAgent, callEndpoint, callRequest, createApiContext, createSessionCallback, getHomeAndMenus, getNextAuthConfig, getPageConfig, getRootConfig, logClientError };

package/dist/routes/agent/callAgent.js

@@ -0,0 +1,225 @@
+/*
+  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 { serializer, type } from '@lowdefy/helpers';
+import createEvaluateOperators from '../../context/createEvaluateOperators.js';
+import authorizeApiEndpoint from '../endpoints/authorizeApiEndpoint.js';
+import getEndpointConfig from '../endpoints/getEndpointConfig.js';
+import runRoutine from '../endpoints/runRoutine.js';
+import getAgentConfig from './getAgentConfig.js';
+import getAgentResolver from './getAgentResolver.js';
+import getConnectionConfig from '../connections/getConnectionConfig.js';
+import getConnection from '../connections/getConnection.js';
+async function callAgent(context, { agentId, pageId, messages, conversationId, urlQuery, sharedState }) {
+    const { logger } = context;
+    context.pageId = pageId;
+    context.evaluateOperators = createEvaluateOperators(context);
+    logger.debug({
+        event: 'debug_agent',
+        agentId,
+        pageId
+    });
+    const agentConfig = await getAgentConfig(context, {
+        agentId
+    });
+    const agentContext = {
+        conversationId: conversationId ?? undefined,
+        pageId,
+        sharedState: sharedState ?? {},
+        urlQuery: urlQuery ?? {},
+        userId: context.user?.sub ?? context.user?.id ?? null
+    };
+    // Evaluate operators in agent properties (e.g. _user, _secret, _payload)
+    agentConfig.properties = context.evaluateOperators({
+        input: agentConfig.properties ?? {},
+        location: agentConfig.agentId,
+        payload: agentContext,
+        state: {},
+        steps: {}
+    });
+    // Load connection config from build artifacts using agent's connectionId
+    const connectionConfig = await getConnectionConfig(context, {
+        connectionId: agentConfig.connectionId,
+        configKey: agentConfig['~k']
+    });
+    // Get connection plugin from registry
+    const connection = getConnection(context, {
+        connectionConfig
+    });
+    // Evaluate operators in connection properties
+    const connectionProperties = context.evaluateOperators({
+        input: connectionConfig.properties || {},
+        location: connectionConfig.connectionId,
+        payload: {},
+        state: {},
+        steps: {}
+    });
+    // Create connection instance (e.g., Anthropic provider)
+    const connectionInstance = connection.create({
+        connection: connectionProperties
+    });
+    // Get agent type from plugin registry
+    const agentType = getAgentResolver(context, {
+        agentConfig
+    });
+    // Build resolver context with callEndpoint that allows InternalApi endpoints
+    const resolverContext = {
+        agentContext,
+        i18n: context.i18n,
+        evaluateOperators: (input)=>context.evaluateOperators({
+                input,
+                location: agentConfig.agentId,
+                payload: agentContext,
+                state: {},
+                steps: {}
+            }),
+        callEndpoint: async (endpointId, { payload, abortSignal })=>{
+            const endpointConfig = await getEndpointConfig(context, {
+                endpointId
+            });
+            authorizeApiEndpoint(context, {
+                endpointConfig
+            });
+            const routineContext = {
+                steps: {},
+                payload: payload ?? {},
+                arrayIndices: [],
+                items: {},
+                state: {},
+                endpointDepth: 0
+            };
+            const { error, response, status } = await runRoutine(context, routineContext, {
+                routine: endpointConfig.routine
+            });
+            const success = ![
+                'error',
+                'reject'
+            ].includes(status);
+            return {
+                error: serializer.serialize(error),
+                response: serializer.serialize(response),
+                status: success ? 'success' : status,
+                success
+            };
+        },
+        getEndpointConfig: async ({ endpointId })=>{
+            return getEndpointConfig(context, {
+                endpointId
+            });
+        },
+        getAgentConfig: async ({ agentId })=>{
+            return getAgentConfig(context, {
+                agentId
+            });
+        },
+        getConnectionForAgent: async ({ agentConfig: subAgentConfig })=>{
+            const subConnectionConfig = await getConnectionConfig(context, {
+                connectionId: subAgentConfig.connectionId,
+                configKey: subAgentConfig['~k']
+            });
+            const subConnection = getConnection(context, {
+                connectionConfig: subConnectionConfig
+            });
+            const subConnectionProperties = context.evaluateOperators({
+                input: subConnectionConfig.properties || {},
+                location: subConnectionConfig.connectionId,
+                payload: {},
+                state: {},
+                steps: {}
+            });
+            return subConnection.create({
+                connection: subConnectionProperties
+            });
+        },
+        resolveMcpSources: async ({ agentConfig: subAgentConfig })=>{
+            const resolvedMcp = [];
+            for (const mcpSource of subAgentConfig.mcp ?? []){
+                if (!type.isNone(mcpSource.connectionId)) {
+                    const mcpConnConfig = await getConnectionConfig(context, {
+                        connectionId: mcpSource.connectionId,
+                        configKey: subAgentConfig['~k']
+                    });
+                    const mcpConnection = getConnection(context, {
+                        connectionConfig: mcpConnConfig
+                    });
+                    const mcpConnProps = context.evaluateOperators({
+                        input: mcpConnConfig.properties || {},
+                        location: mcpConnConfig.connectionId,
+                        payload: {},
+                        state: {},
+                        steps: {}
+                    });
+                    const mcpConfig = mcpConnection.create({
+                        connection: mcpConnProps
+                    });
+                    const { connectionId: _, ...overrides } = mcpSource;
+                    resolvedMcp.push({
+                        ...mcpConfig,
+                        ...overrides
+                    });
+                } else {
+                    resolvedMcp.push(mcpSource);
+                }
+            }
+            return resolvedMcp;
+        }
+    };
+    // Resolve MCP connection references to inline config.
+    // Agent-level overrides (like confirm) may still contain operators —
+    // handleAgentChat evaluates those via its existing evaluateOperators call.
+    const resolvedMcp = [];
+    for (const mcpSource of agentConfig.mcp ?? []){
+        if (!type.isNone(mcpSource.connectionId)) {
+            const mcpConnConfig = await getConnectionConfig(context, {
+                connectionId: mcpSource.connectionId,
+                configKey: agentConfig['~k']
+            });
+            const mcpConnection = getConnection(context, {
+                connectionConfig: mcpConnConfig
+            });
+            const mcpConnProps = context.evaluateOperators({
+                input: mcpConnConfig.properties || {},
+                location: mcpConnConfig.connectionId,
+                payload: {},
+                state: {},
+                steps: {}
+            });
+            const mcpConfig = mcpConnection.create({
+                connection: mcpConnProps
+            });
+            // Merge: connection properties as base, agent-level overrides on top
+            const { connectionId: _, ...overrides } = mcpSource;
+            resolvedMcp.push({
+                ...mcpConfig,
+                ...overrides
+            });
+        } else {
+            resolvedMcp.push(mcpSource);
+        }
+    }
+    agentConfig.mcp = resolvedMcp;
+    // Call the agent resolver
+    const { response } = await agentType.resolver({
+        connection: connectionInstance,
+        properties: {
+            agent: agentConfig,
+            messages
+        },
+        context: resolverContext
+    });
+    return {
+        response
+    };
+}
+export default callAgent;

package/dist/routes/agent/getAgentConfig.js

@@ -0,0 +1,37 @@
+/*
+  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 { ConfigError } from '@lowdefy/errors';
+import { translate } from '@lowdefy/helpers';
+async function getAgentConfig({ i18n, logger, readConfigFile }, { agentId }) {
+    const agent = await readConfigFile(`agents/${agentId}.json`);
+    if (!agent) {
+        const err = new ConfigError(translate({
+            key: 'agent.runtime.agentNotFound',
+            values: {
+                agentId
+            },
+            i18n
+        }));
+        logger.debug({
+            params: {
+                agentId
+            },
+            err
+        }, err.message);
+        throw err;
+    }
+    return agent;
+}
+export default getAgentConfig;

package/dist/routes/agent/getAgentResolver.js

@@ -0,0 +1,40 @@
+/*
+  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 { ConfigError } from '@lowdefy/errors';
+import { translate } from '@lowdefy/helpers';
+function getAgentResolver({ agents, i18n, logger }, { agentConfig }) {
+    const agentType = agents[agentConfig.type];
+    if (!agentType) {
+        const err = new ConfigError(translate({
+            key: 'agent.runtime.agentTypeNotFound',
+            values: {
+                type: agentConfig.type
+            },
+            i18n
+        }), {
+            configKey: agentConfig['~k']
+        });
+        logger.debug({
+            params: {
+                id: agentConfig.agentId,
+                type: agentConfig.type
+            },
+            err
+        }, err.message);
+        throw err;
+    }
+    return agentType;
+}
+export default getAgentResolver;

package/dist/routes/auth/getNextAuthConfig.js

@@ -13,7 +13,7 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { ServerParser } from '@lowdefy/operators';
-import { _secret } from '@lowdefy/operators-js/operators/server';
+import { _app, _secret } from '@lowdefy/operators-js/operators/server';
 import createAdapter from './createAdapter.js';
 import createCallbacks from './callbacks/createCallbacks.js';
 import createEvents from './events/createEvents.js';
@@ -21,10 +21,12 @@ import createLogger from './createLogger.js';
 import createProviders from './createProviders.js';
 const nextAuthConfig = {};
 let initialized = false;
-function getNextAuthConfig({ authJson, logger, plugins, secrets }) {
+function getNextAuthConfig({ appMeta, authJson, logger, plugins, secrets }) {
     if (initialized) return nextAuthConfig;
     const operatorsParser = new ServerParser({
+        lowdefyApp: appMeta,
         operators: {
+            _app,
             _secret
         },
         secrets,

package/dist/routes/{request → connections}/getConnectionConfig.js

@@ -13,16 +13,15 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { ConfigError } from '@lowdefy/errors';
-async function getConnectionConfig({ logger, readConfigFile }, { requestConfig }) {
-    const { connectionId, requestId } = requestConfig;
+async function getConnectionConfig({ logger, readConfigFile }, { connectionId, configKey }) {
     let err;
     if (!connectionId) {
-        err = new ConfigError(`Request "${requestId}" does not specify a connection.`, {
-            configKey: requestConfig['~k']
+        err = new ConfigError('Connection id is missing.', {
+            configKey
         });
         logger.debug({
             params: {
-                requestId
+                connectionId
             },
             err
         }, err.message);
@@ -31,11 +30,11 @@ async function getConnectionConfig({ logger, readConfigFile }, { requestConfig }
     const connection = await readConfigFile(`connections/${connectionId}.json`);
     if (!connection) {
         err = new ConfigError(`Connection "${connectionId}" does not exist.`, {
-            configKey: requestConfig['~k']
+            configKey
         });
         logger.debug({
             params: {
-                requestId
+                connectionId
             },
             err
         }, err.message);

package/dist/routes/endpoints/callEndpoint.js

@@ -53,6 +53,7 @@ async function callEndpoint(context, { blockId, endpointId, pageId, payload }) {
         payload: serializer.deserialize(payload),
         arrayIndices: [],
         items: {},
+        state: {},
         endpointDepth: 0
     };
     const { error, response, status } = await runRoutine(context, routineContext, {

package/dist/routes/endpoints/control/controlFor.js

@@ -25,8 +25,9 @@ async function controlFor(context, routineContext, { control }) {
         input: control[':in'],
         items,
         location: control['~k'] ?? ':for',
-        steps: routineContext.steps,
-        payload: routineContext.payload
+        payload: routineContext.payload,
+        state: routineContext.state,
+        steps: routineContext.steps
     });
     logger.debug({
         event: 'debug_control_for',

package/dist/routes/endpoints/control/controlIf.js

@@ -20,8 +20,9 @@ async function controlIf(context, routineContext, { control }) {
         input: control[':if'],
         items,
         location: control['~k'] ?? ':if',
-        steps: routineContext.steps,
-        payload: routineContext.payload
+        payload: routineContext.payload,
+        state: routineContext.state,
+        steps: routineContext.steps
     });
     logger.debug({
         event: 'debug_control_if',

package/dist/routes/endpoints/control/controlLog.js

@@ -25,15 +25,17 @@ async function controlLog(context, routineContext, { control }) {
         input: control[':log'],
         items,
         location,
-        steps: routineContext.steps,
-        payload: routineContext.payload
+        payload: routineContext.payload,
+        state: routineContext.state,
+        steps: routineContext.steps
     });
     const logLevel = evaluateOperators({
         input: control[':level'],
         items,
         location,
-        steps: routineContext.steps,
-        payload: routineContext.payload
+        payload: routineContext.payload,
+        state: routineContext.state,
+        steps: routineContext.steps
     }) ?? 'info';
     if (!type.isString(logLevel)) {
         throw new ConfigError(`Invalid :log in endpoint "${endpointId}" - :level must be a string.`, {

package/dist/routes/endpoints/control/controlParallelFor.js

@@ -25,8 +25,9 @@ async function controlParallelFor(context, routineContext, { control }) {
         input: control[':in'],
         items,
         location: control['~k'] ?? ':parallel_for',
-        steps: routineContext.steps,
-        payload: routineContext.payload
+        payload: routineContext.payload,
+        state: routineContext.state,
+        steps: routineContext.steps
     });
     logger.debug({
         event: 'debug_control_parallel',

package/dist/routes/endpoints/control/controlReject.js

@@ -12,7 +12,8 @@
   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.
-*/ async function controlReject(context, routineContext, { control }) {
+*/ import { UserError } from '@lowdefy/errors';
+async function controlReject(context, routineContext, { control }) {
     const { evaluateOperators } = context;
     const { items } = routineContext;
     const location = control['~k'] ?? ':reject';
@@ -20,18 +21,21 @@
         input: control[':reject'],
         items,
         location,
-        steps: routineContext.steps,
-        payload: routineContext.payload
+        payload: routineContext.payload,
+        state: routineContext.state,
+        steps: routineContext.steps
     });
     const cause = evaluateOperators({
         input: control[':cause'],
         items,
         location,
-        steps: routineContext.steps,
-        payload: routineContext.payload
+        payload: routineContext.payload,
+        state: routineContext.state,
+        steps: routineContext.steps
     });
-    const error = new Error(message, {
-        cause
+    const error = new UserError(message, {
+        cause,
+        isReject: true
     });
     context.logger.warn({
         event: 'warn_control_reject',

package/dist/routes/endpoints/control/controlReturn.js

@@ -19,8 +19,9 @@
         input: control[':return'],
         items,
         location: control['~k'] ?? ':return',
-        steps: routineContext.steps,
-        payload: routineContext.payload
+        payload: routineContext.payload,
+        state: routineContext.state,
+        steps: routineContext.steps
     });
     context.logger.debug({
         event: 'debug_control_return',

package/dist/routes/endpoints/control/controlSetState.js

@@ -20,8 +20,9 @@ function controlSetState(context, routineContext, { control }) {
         input: control[':set_state'],
         items,
         location: control['~k'] ?? ':set_state',
-        steps: routineContext.steps,
-        payload: routineContext.payload
+        payload: routineContext.payload,
+        state: routineContext.state,
+        steps: routineContext.steps
     });
     logger.debug({
         event: 'debug_control_set_state',
@@ -29,7 +30,7 @@ function controlSetState(context, routineContext, { control }) {
         evaluated: evaluatedSetState
     });
     Object.entries(evaluatedSetState).forEach(([key, value])=>{
-        set(context.state, key, value);
+        set(routineContext.state, key, value);
     });
     return {
         status: 'continue'

package/dist/routes/endpoints/control/controlSwitch.js

@@ -25,8 +25,9 @@ async function controlSwitch(context, routineContext, { control }) {
             input: caseObj[':case'],
             items,
             location: caseObj['~k'] ?? control['~k'] ?? ':switch',
-            steps: routineContext.steps,
-            payload: routineContext.payload
+            payload: routineContext.payload,
+            state: routineContext.state,
+            steps: routineContext.steps
         });
         logger.debug({
             event: 'debug_control_switch_case',

package/dist/routes/endpoints/control/controlThrow.js

@@ -12,7 +12,8 @@
   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.
-*/ async function controlThrow(context, routineContext, { control }) {
+*/ import { UserError } from '@lowdefy/errors';
+async function controlThrow(context, routineContext, { control }) {
     const { evaluateOperators } = context;
     const { items } = routineContext;
     const location = control['~k'] ?? ':throw';
@@ -20,17 +21,19 @@
         input: control[':throw'],
         items,
         location,
-        steps: routineContext.steps,
-        payload: routineContext.payload
+        payload: routineContext.payload,
+        state: routineContext.state,
+        steps: routineContext.steps
     });
     const cause = evaluateOperators({
         input: control[':cause'],
         items,
         location,
-        steps: routineContext.steps,
-        payload: routineContext.payload
+        payload: routineContext.payload,
+        state: routineContext.state,
+        steps: routineContext.steps
     });
-    const error = new Error(message, {
+    const error = new UserError(message, {
         cause
     });
     context.logger.error({

package/dist/routes/endpoints/handleEndpointCall.js

@@ -12,11 +12,8 @@
   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 { ConfigError } from '@lowdefy/errors';
-import addStepResult from './addStepResult.js';
-import authorizeApiEndpoint from './authorizeApiEndpoint.js';
-import getEndpointConfig from './getEndpointConfig.js';
-import runRoutine from './runRoutine.js';
+*/ import addStepResult from './addStepResult.js';
+import invokeEndpoint from './invokeEndpoint.js';
 async function handleEndpointCall(context, routineContext, { step }) {
     const { logger, evaluateOperators } = context;
     logger.debug({
@@ -29,32 +26,13 @@ async function handleEndpointCall(context, routineContext, { step }) {
         items: routineContext.items,
         location: step.stepId,
         payload: routineContext.payload,
+        state: routineContext.state,
         steps: routineContext.steps
     });
-    // Check recursion depth
-    const currentDepth = routineContext.endpointDepth ?? 0;
-    if (currentDepth >= 10) {
-        throw new ConfigError('Endpoint call depth exceeded maximum of 10. Check for recursive endpoint calls.');
-    }
-    // Load target endpoint config
-    const endpointConfig = await getEndpointConfig(context, {
-        endpointId: evaluatedProperties.endpointId
-    });
-    // Authorize current user against target endpoint
-    authorizeApiEndpoint(context, {
-        endpointConfig
-    });
-    // Create isolated routineContext for the called endpoint
-    const childRoutineContext = {
-        steps: {},
-        payload: evaluatedProperties.payload ?? {},
-        arrayIndices: [],
-        items: {},
-        endpointDepth: currentDepth + 1
-    };
-    // Run the target endpoint's routine
-    const result = await runRoutine(context, childRoutineContext, {
-        routine: endpointConfig.routine
+    const result = await invokeEndpoint(context, {
+        endpointId: evaluatedProperties.endpointId,
+        payload: evaluatedProperties.payload,
+        endpointDepth: routineContext.endpointDepth
     });
     // Store the return value in the caller's steps
     const response = result.status === 'return' ? result.response : null;

package/dist/routes/endpoints/handleRequest.js

@@ -17,8 +17,8 @@ import callRequestResolver from '../request/callRequestResolver.js';
 import checkConnectionRead from '../request/checkConnectionRead.js';
 import checkConnectionWrite from '../request/checkConnectionWrite.js';
 import evaluateOperators from '../request/evaluateOperators.js';
-import getConnection from '../request/getConnection.js';
-import getConnectionConfig from '../request/getConnectionConfig.js';
+import getConnection from '../connections/getConnection.js';
+import getConnectionConfig from '../connections/getConnectionConfig.js';
 import getRequestResolver from '../request/getRequestResolver.js';
 import validateSchemas from '../request/validateSchemas.js';
 async function handleRequest(context, routineContext, { request }) {
@@ -30,7 +30,8 @@ async function handleRequest(context, routineContext, { request }) {
     });
     const requestConfig = request;
     const connectionConfig = await getConnectionConfig(context, {
-        requestConfig
+        connectionId: requestConfig.connectionId,
+        configKey: requestConfig['~k']
     });
     const connection = getConnection(context, {
         connectionConfig
@@ -44,6 +45,7 @@ async function handleRequest(context, routineContext, { request }) {
         items,
         payload: routineContext.payload,
         requestConfig,
+        state: routineContext.state,
         steps: routineContext.steps
     });
     checkConnectionRead(context, {
@@ -67,6 +69,7 @@ async function handleRequest(context, routineContext, { request }) {
     });
     const result = await callRequestResolver(context, {
         connectionProperties,
+        endpointDepth: routineContext.endpointDepth,
         requestConfig,
         requestProperties,
         requestResolver

package/dist/routes/endpoints/handleValidateSchema.js

@@ -0,0 +1,73 @@
+/*
+  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 { validate } from '@lowdefy/ajv';
+import addStepResult from './addStepResult.js';
+function buildErrorMessage(errors, stepId) {
+    const first = errors?.[0];
+    if (!first) return `ValidateSchema step "${stepId}" failed.`;
+    const path = first.instancePath || '(root)';
+    return `ValidateSchema step "${stepId}" failed at ${path}: ${first.message}.`;
+}
+async function handleValidateSchema(context, routineContext, { step }) {
+    const { logger, evaluateOperators } = context;
+    logger.debug({
+        event: 'debug_start_validate_schema',
+        step
+    });
+    const evaluatedProperties = evaluateOperators({
+        input: step.properties,
+        items: routineContext.items,
+        location: step.stepId,
+        payload: routineContext.payload,
+        steps: routineContext.steps
+    });
+    const { schema, data, throwOnInvalid = true } = evaluatedProperties;
+    const { valid, errors } = validate({
+        schema,
+        data,
+        returnErrors: true
+    });
+    const result = {
+        valid,
+        errors: errors ?? []
+    };
+    addStepResult(context, routineContext, {
+        result,
+        stepId: step.stepId
+    });
+    if (!valid && throwOnInvalid) {
+        const error = new Error(buildErrorMessage(result.errors, step.stepId), {
+            cause: result.errors
+        });
+        logger.error({
+            event: 'error_validate_schema',
+            stepId: step.stepId,
+            error
+        });
+        return {
+            status: 'error',
+            error
+        };
+    }
+    logger.debug({
+        event: 'debug_end_validate_schema',
+        stepId: step.stepId,
+        valid
+    });
+    return {
+        status: 'continue'
+    };
+}
+export default handleValidateSchema;

package/dist/routes/endpoints/invokeEndpoint.js

@@ -0,0 +1,41 @@
+/*
+  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 { ConfigError } from '@lowdefy/errors';
+import authorizeApiEndpoint from './authorizeApiEndpoint.js';
+import getEndpointConfig from './getEndpointConfig.js';
+import runRoutine from './runRoutine.js';
+async function invokeEndpoint(context, { endpointId, payload, endpointDepth }) {
+    if (endpointDepth >= 10) {
+        throw new ConfigError('Endpoint call depth exceeded maximum of 10. Check for recursive endpoint calls.');
+    }
+    const endpointConfig = await getEndpointConfig(context, {
+        endpointId
+    });
+    authorizeApiEndpoint(context, {
+        endpointConfig
+    });
+    const childRoutineContext = {
+        steps: {},
+        payload: payload ?? {},
+        arrayIndices: [],
+        items: {},
+        state: {},
+        endpointDepth: endpointDepth + 1
+    };
+    return runRoutine(context, childRoutineContext, {
+        routine: endpointConfig.routine
+    });
+}
+export default invokeEndpoint;

package/dist/routes/endpoints/runRoutine.js

@@ -16,6 +16,7 @@
 import handleControl from './control/handleControl.js';
 import handleEndpointCall from './handleEndpointCall.js';
 import handleRequest from './handleRequest.js';
+import handleValidateSchema from './handleValidateSchema.js';
 async function runRoutine(context, routineContext, { routine }) {
     try {
         if (type.isObject(routine)) {
@@ -29,6 +30,11 @@ async function runRoutine(context, routineContext, { routine }) {
                     step: routine
                 });
             }
+            if (routine.id?.startsWith?.('validate:')) {
+                return await handleValidateSchema(context, routineContext, {
+                    step: routine
+                });
+            }
             return await handleControl(context, routineContext, {
                 control: routine
             });
@@ -56,7 +62,16 @@ async function runRoutine(context, routineContext, { routine }) {
             }
         });
     } catch (error) {
-        await context.handleError(error);
+        if (error.isReject) {
+            return {
+                status: 'reject',
+                error
+            };
+        }
+        if (!error.handled) {
+            await context.handleError(error);
+            error.handled = true;
+        }
         return {
             status: 'error',
             error

package/dist/routes/endpoints/test/runTest.js

@@ -90,7 +90,9 @@ async function runTest({ routine, payload = {} }) {
         steps: {},
         payload,
         items: {},
-        arrayIndices: []
+        arrayIndices: [],
+        state: {},
+        endpointDepth: 0
     };
     const res = await runRoutine(context, routineContext, {
         routine

package/dist/routes/request/callRequest.js

@@ -18,8 +18,8 @@ import callRequestResolver from './callRequestResolver.js';
 import checkConnectionRead from './checkConnectionRead.js';
 import checkConnectionWrite from './checkConnectionWrite.js';
 import evaluateOperators from './evaluateOperators.js';
-import getConnection from './getConnection.js';
-import getConnectionConfig from './getConnectionConfig.js';
+import getConnection from '../connections/getConnection.js';
+import getConnectionConfig from '../connections/getConnectionConfig.js';
 import getRequestConfig from './getRequestConfig.js';
 import getRequestResolver from './getRequestResolver.js';
 import validateSchemas from './validateSchemas.js';
@@ -43,7 +43,8 @@ async function callRequest(context, { blockId, pageId, payload, requestId }) {
         requestId
     });
     const connectionConfig = await getConnectionConfig(context, {
-        requestConfig
+        connectionId: requestConfig.connectionId,
+        configKey: requestConfig['~k']
     });
     authorizeRequest(context, {
         requestConfig
@@ -59,6 +60,7 @@ async function callRequest(context, { blockId, pageId, payload, requestId }) {
         connectionConfig,
         payload: requestPayload,
         requestConfig,
+        state: {},
         steps: {}
     });
     checkConnectionRead(context, {
@@ -82,6 +84,7 @@ async function callRequest(context, { blockId, pageId, payload, requestId }) {
     });
     const response = await callRequestResolver(context, {
         connectionProperties,
+        endpointDepth: 0,
         requestConfig,
         requestProperties,
         requestResolver

package/dist/routes/request/callRequestResolver.js

@@ -12,16 +12,43 @@
   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 { ConfigError, RequestError, ServiceError } from '@lowdefy/errors';
-async function callRequestResolver({ blockId, endpointId, logger, pageId, payload }, { connectionProperties, requestConfig, requestProperties, requestResolver }) {
+*/ import { RequestError, ServiceError } from '@lowdefy/errors';
+import invokeEndpoint from '../endpoints/invokeEndpoint.js';
+async function callRequestResolver(context, { connectionProperties, endpointDepth, requestConfig, requestProperties, requestResolver }) {
+    const { blockId, endpointId, logger, pageId, payload } = context;
     // stepId for endpoint steps (after build), requestId for page requests
     const stepOrRequestId = requestConfig.stepId ?? requestConfig.requestId;
+    const callApi = async ({ endpointId: targetEndpointId, payload: targetPayload } = {})=>{
+        logger.debug({
+            event: 'debug_start_call_api',
+            connectionId: requestConfig.connectionId,
+            requestId: stepOrRequestId,
+            endpointId: targetEndpointId
+        });
+        const result = await invokeEndpoint(context, {
+            endpointId: targetEndpointId,
+            payload: targetPayload,
+            endpointDepth
+        });
+        if (result.status === 'error' || result.status === 'reject') {
+            throw result.error;
+        }
+        const response = result.status === 'return' ? result.response : null;
+        logger.debug({
+            event: 'debug_end_call_api',
+            connectionId: requestConfig.connectionId,
+            requestId: stepOrRequestId,
+            endpointId: targetEndpointId
+        });
+        return response;
+    };
     try {
         const response = await requestResolver({
             blockId,
-            endpointId,
+            callApi,
             connection: connectionProperties,
             connectionId: requestConfig.connectionId,
+            endpointId,
             pageId,
             payload,
             request: requestProperties,
@@ -33,7 +60,9 @@ async function callRequestResolver({ blockId, endpointId, logger, pageId, payloa
         if (!error.configKey) {
             error.configKey = requestConfig['~k'];
         }
-        if (error instanceof ConfigError) {
+        // Lowdefy errors pass through unchanged — re-wrapping every boundary would
+        // nest causes and truncate the deepest (most informative) frame.
+        if (error.isLowdefyError) {
             logger.debug({
                 params: {
                     id: stepOrRequestId,

package/dist/routes/request/evaluateOperators.js

@@ -12,11 +12,12 @@
   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 evaluateOperators({ evaluateOperators }, { connectionConfig, items, payload, requestConfig, steps }) {
+*/ function evaluateOperators({ evaluateOperators }, { connectionConfig, items, payload, requestConfig, state, steps }) {
     const connectionProperties = evaluateOperators({
         input: connectionConfig.properties || {},
         location: connectionConfig.connectionId,
         payload,
+        state,
         steps
     });
     const requestProperties = evaluateOperators({
@@ -24,6 +25,7 @@
         items,
         location: requestConfig.stepId ?? requestConfig.requestId,
         payload,
+        state,
         steps
     });
     return {

package/dist/routes/rootConfig/getLowdefyI18n.js

@@ -0,0 +1,19 @@
+/*
+  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.
+*/ async function getLowdefyI18n({ readConfigFile }) {
+    const i18n = await readConfigFile('i18n.json');
+    return i18n || {};
+}
+export default getLowdefyI18n;

package/dist/routes/rootConfig/getRootConfig.js

@@ -14,15 +14,19 @@
   limitations under the License.
 */ import getHomeAndMenus from './getHomeAndMenus.js';
 import getLowdefyGlobal from './getLowdefyGlobal.js';
+import getLowdefyI18n from './getLowdefyI18n.js';
 import getLowdefyTheme from './getLowdefyTheme.js';
 async function getRootConfig(context) {
-    const [lowdefyGlobal, theme, { home, menus }] = await Promise.all([
+    const [lowdefyGlobal, theme, i18n, { home, menus }] = await Promise.all([
         getLowdefyGlobal(context),
         getLowdefyTheme(context),
+        getLowdefyI18n(context),
         getHomeAndMenus(context)
     ]);
     return {
         home,
+        i18n,
+        lowdefyApp: context.appMeta,
         lowdefyGlobal,
         menus,
         theme

package/dist/routes/rootConfig/menus/filterMenuList.js

@@ -15,7 +15,7 @@
 */ import { get } from '@lowdefy/helpers';
 function filterMenuList(context, { menuList }) {
     const { authorize } = context;
-    return menuList.map((item)=>{
+    const filtered = menuList.map((item)=>{
         if (item.type === 'MenuLink') {
             if (authorize(item)) {
                 return item;
@@ -34,8 +34,19 @@ function filterMenuList(context, { menuList }) {
                     links: filteredSubItems
                 };
             }
+            return null;
+        }
+        if (item.type === 'MenuDivider') {
+            return item;
         }
         return null;
     }).filter((item)=>item !== null);
+    return filtered.filter((item, i, arr)=>{
+        if (item.type !== 'MenuDivider') return true;
+        if (i === 0) return false;
+        if (i === arr.length - 1) return false;
+        if (arr[i - 1].type === 'MenuDivider') return false;
+        return true;
+    });
 }
 export default filterMenuList;

package/dist/test/testContext.js

@@ -13,7 +13,7 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import createAuthorize from '../context/createAuthorize.js';
-function testContext({ config = {}, connections = {}, headers = {}, logger = {
+function testContext({ appMeta = {}, config = {}, connections = {}, headers = {}, logger = {
     debug: ()=>{},
     error: ()=>{},
     info: ()=>{},
@@ -22,6 +22,7 @@ function testContext({ config = {}, connections = {}, headers = {}, logger = {
     _test: ()=>'test'
 }, readConfigFile, secrets = {}, session } = {}) {
     return {
+        appMeta,
         authorize: createAuthorize({
             session
         }),
@@ -36,7 +37,6 @@ function testContext({ config = {}, connections = {}, headers = {}, logger = {
         readConfigFile,
         secrets,
         session,
-        state: {},
         steps: {},
         user: session?.user
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lowdefy/api",
-  "version": "5.2.0",
+  "version": "5.4.0",
   "license": "Apache-2.0",
   "description": "",
   "homepage": "https://lowdefy.com",
@@ -34,13 +34,13 @@
     "dist/*"
   ],
   "dependencies": {
-    "@lowdefy/ajv": "5.2.0",
-    "@lowdefy/errors": "5.2.0",
-    "@lowdefy/helpers": "5.2.0",
-    "@lowdefy/node-utils": "5.2.0",
-    "@lowdefy/nunjucks": "5.2.0",
-    "@lowdefy/operators": "5.2.0",
-    "@lowdefy/operators-js": "5.2.0"
+    "@lowdefy/ajv": "5.4.0",
+    "@lowdefy/errors": "5.4.0",
+    "@lowdefy/helpers": "5.4.0",
+    "@lowdefy/node-utils": "5.4.0",
+    "@lowdefy/nunjucks": "5.4.0",
+    "@lowdefy/operators": "5.4.0",
+    "@lowdefy/operators-js": "5.4.0"
   },
   "devDependencies": {
     "@jest/globals": "28.1.3",