@lowdefy/api 5.3.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/routes/agent/callAgent.js

@@ -45,6 +45,7 @@ async function callAgent(context, { agentId, pageId, messages, conversationId, u
         input: agentConfig.properties ?? {},
         location: agentConfig.agentId,
         payload: agentContext,
+        state: {},
         steps: {}
     });
     // Load connection config from build artifacts using agent's connectionId
@@ -61,6 +62,7 @@ async function callAgent(context, { agentId, pageId, messages, conversationId, u
         input: connectionConfig.properties || {},
         location: connectionConfig.connectionId,
         payload: {},
+        state: {},
         steps: {}
     });
     // Create connection instance (e.g., Anthropic provider)
@@ -74,10 +76,12 @@ async function callAgent(context, { agentId, pageId, messages, conversationId, u
     // 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 })=>{
@@ -92,6 +96,7 @@ async function callAgent(context, { agentId, pageId, messages, conversationId, u
                 payload: payload ?? {},
                 arrayIndices: [],
                 items: {},
+                state: {},
                 endpointDepth: 0
             };
             const { error, response, status } = await runRoutine(context, routineContext, {
@@ -130,6 +135,7 @@ async function callAgent(context, { agentId, pageId, messages, conversationId, u
                 input: subConnectionConfig.properties || {},
                 location: subConnectionConfig.connectionId,
                 payload: {},
+                state: {},
                 steps: {}
             });
             return subConnection.create({
@@ -151,6 +157,7 @@ async function callAgent(context, { agentId, pageId, messages, conversationId, u
                         input: mcpConnConfig.properties || {},
                         location: mcpConnConfig.connectionId,
                         payload: {},
+                        state: {},
                         steps: {}
                     });
                     const mcpConfig = mcpConnection.create({
@@ -185,6 +192,7 @@ async function callAgent(context, { agentId, pageId, messages, conversationId, u
                 input: mcpConnConfig.properties || {},
                 location: mcpConnConfig.connectionId,
                 payload: {},
+                state: {},
                 steps: {}
             });
             const mcpConfig = mcpConnection.create({

package/dist/routes/agent/getAgentConfig.js

@@ -13,10 +13,17 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { ConfigError } from '@lowdefy/errors';
-async function getAgentConfig({ logger, readConfigFile }, { agentId }) {
+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(`Agent "${agentId}" does not exist.`);
+        const err = new ConfigError(translate({
+            key: 'agent.runtime.agentNotFound',
+            values: {
+                agentId
+            },
+            i18n
+        }));
         logger.debug({
             params: {
                 agentId

package/dist/routes/agent/getAgentResolver.js

@@ -13,10 +13,17 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { ConfigError } from '@lowdefy/errors';
-function getAgentResolver({ agents, logger }, { agentConfig }) {
+import { translate } from '@lowdefy/helpers';
+function getAgentResolver({ agents, i18n, logger }, { agentConfig }) {
     const agentType = agents[agentConfig.type];
     if (!agentType) {
-        const err = new ConfigError(`Agent type "${agentConfig.type}" can not be found.`, {
+        const err = new ConfigError(translate({
+            key: 'agent.runtime.agentTypeNotFound',
+            values: {
+                type: agentConfig.type
+            },
+            i18n
+        }), {
             configKey: agentConfig['~k']
         });
         logger.debug({

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/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

@@ -45,6 +45,7 @@ async function handleRequest(context, routineContext, { request }) {
         items,
         payload: routineContext.payload,
         requestConfig,
+        state: routineContext.state,
         steps: routineContext.steps
     });
     checkConnectionRead(context, {
@@ -68,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

@@ -60,6 +60,7 @@ async function callRequest(context, { blockId, pageId, payload, requestId }) {
         connectionConfig,
         payload: requestPayload,
         requestConfig,
+        state: {},
         steps: {}
     });
     checkConnectionRead(context, {
@@ -83,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.3.0",
+  "version": "5.4.0",
   "license": "Apache-2.0",
   "description": "",
   "homepage": "https://lowdefy.com",
@@ -34,13 +34,13 @@
     "dist/*"
   ],
   "dependencies": {
-    "@lowdefy/ajv": "5.3.0",
-    "@lowdefy/errors": "5.3.0",
-    "@lowdefy/helpers": "5.3.0",
-    "@lowdefy/node-utils": "5.3.0",
-    "@lowdefy/nunjucks": "5.3.0",
-    "@lowdefy/operators": "5.3.0",
-    "@lowdefy/operators-js": "5.3.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",