@lowdefy/api 0.0.0-experimental-20260720072521 → 0.0.0-experimental-20260720135014

package/dist/context/createApiContext.js

@@ -14,11 +14,9 @@
   limitations under the License.
 */ import createAuthorize from './createAuthorize.js';
 import createReadConfigFile from './createReadConfigFile.js';
-import getOrganizationBinding from '../routes/auth/organizations/getOrganizationBinding.js';
 import resolveLocale from './resolveLocale.js';
 function createApiContext(context) {
-    // context.user is written by resolveAuthentication (or a pre-resolved
-    // dev/e2e caller) before this runs - never assigned here.
+    context.user = context?.session?.user;
     if (context.i18n?.defaultLocale) {
         const active = resolveLocale({
             i18n: context.i18n,
@@ -31,12 +29,6 @@ function createApiContext(context) {
     } else {
         context.i18n = undefined;
     }
-    // The retained organizations state ({ policy, pinned }) - read by the
-    // _organization operator and the org-scoped admin steps; null when auth
-    // (or organizations) is not configured.
-    context.organization = getOrganizationBinding({
-        auth: context.auth ?? null
-    });
     context.authorize = createAuthorize(context);
     context.readConfigFile = createReadConfigFile(context);
 }

package/dist/context/createAuthorize.js

@@ -12,29 +12,18 @@
   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';
-import { ConfigError } from '@lowdefy/errors';
-// createAuthorize is called with the context object on every path
-// (createApiContext, createSystemContext, and the runners), so `system` is read
-// straight off context.system - the single run-level trust marker every
-// authorization layer reads (Decisions 1, 2).
-function createAuthorize({ user, system }) {
-    // resolveAuthentication is the single writer of context.user - a resolved
-    // caller object when authenticated, else null.
-    const authenticated = !type.isNone(user);
-    const roles = user?.roles ?? [];
-    if (!Array.isArray(roles) || roles.some((role)=>!type.isString(role))) {
-        throw new ConfigError('user.roles must be an array of strings.', {
+*/ import { ConfigError } from '@lowdefy/errors';
+function createAuthorize({ session }) {
+    // Next-auth getSession provides a session object if the user is authenticated
+    // else session will be null
+    const authenticated = !!session;
+    const roles = session?.user?.roles ?? [];
+    if (!Array.isArray(roles)) {
+        throw new ConfigError('session.user.roles must be an array of strings.', {
             received: roles
         });
     }
     function authorize(config) {
-        // In a system context (context.system === true) there is no session and no
-        // caller, so `auth.public` / `auth.roles` - which ask "does this caller's
-        // session carry the required roles?" - is undefined, not denied. Endpoint
-        // role-authorization is skipped, not satisfied by a synthetic role:
-        // "system" is never a role, it is the absence of a principal (Decision 2).
-        if (system === true) return true;
         const { auth } = config;
         if (auth.public === true) return true;
         if (auth.public === false) {

package/dist/context/createEvaluateOperators.js

@@ -14,13 +14,12 @@
   limitations under the License.
 */ import { ServerParser } from '@lowdefy/operators';
 function createEvaluateOperators(context) {
-    const { appMeta, i18n, jsMap, operators, organization, secrets, user } = context;
+    const { appMeta, i18n, jsMap, operators, secrets, user } = context;
     const operatorsParser = new ServerParser({
         i18n,
         jsMap,
         lowdefyApp: appMeta,
         operators,
-        organization,
         secrets,
         user
     });

package/dist/index.js

@@ -14,22 +14,12 @@
   limitations under the License.
 */ import callAgent from './routes/agent/callAgent.js';
 import callEndpoint from './routes/endpoints/callEndpoint.js';
-import getEndpointConfig from './routes/endpoints/getEndpointConfig.js';
 import callRequest from './routes/request/callRequest.js';
 import createApiContext from './context/createApiContext.js';
-import createChannelRegistry from './routes/websocket/createChannelRegistry.js';
-import createSystemContext from './context/createSystemContext.js';
-import createWebSocketConnection from './routes/websocket/createWebSocketConnection.js';
-import getAuthStrategies from './routes/auth/strategies/getAuthStrategies.js';
-import getBetterAuth from './routes/auth/getBetterAuth.js';
+import createSessionCallback from './routes/auth/callbacks/createSessionCallback.js';
 import getHomeAndMenus from './routes/rootConfig/getHomeAndMenus.js';
+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';
-import normalizeInjectedCaller from './context/normalizeInjectedCaller.js';
-import resolveAuthentication from './context/resolveAuthentication.js';
-import resolvePinnedOrganization from './routes/auth/organizations/resolvePinnedOrganization.js';
-import runDetachedEndpoint from './routes/endpoints/runDetachedEndpoint.js';
-import runWebhookEndpoint from './routes/endpoints/runWebhookEndpoint.js';
-import runScheduledEndpoint from './routes/endpoints/runScheduledEndpoint.js';
-export { callAgent, callEndpoint, getEndpointConfig, callRequest, createApiContext, createChannelRegistry, createSystemContext, createWebSocketConnection, getAuthStrategies, getBetterAuth, getHomeAndMenus, getPageConfig, getRootConfig, logClientError, normalizeInjectedCaller, resolveAuthentication, resolvePinnedOrganization, runDetachedEndpoint, runWebhookEndpoint, runScheduledEndpoint };
+export { callAgent, callEndpoint, callRequest, createApiContext, createSessionCallback, getHomeAndMenus, getNextAuthConfig, getPageConfig, getRootConfig, logClientError };

package/dist/routes/agent/callAgent.js

@@ -12,8 +12,15 @@
   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 createEvaluateOperators from '../../context/createEvaluateOperators.js';
-import prepareAgent from './prepareAgent.js';
+*/ 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;
@@ -23,6 +30,9 @@ async function callAgent(context, { agentId, pageId, messages, conversationId, u
         agentId,
         pageId
     });
+    const agentConfig = await getAgentConfig(context, {
+        agentId
+    });
     const agentContext = {
         conversationId: conversationId ?? undefined,
         pageId,
@@ -30,12 +40,175 @@ async function callAgent(context, { agentId, pageId, messages, conversationId, u
         urlQuery: urlQuery ?? {},
         userId: context.user?.sub ?? context.user?.id ?? null
     };
-    const { agentConfig, connectionInstance, agentType, resolverContext } = await prepareAgent(context, {
-        agentId,
-        agentContext,
-        endpointDepth: 0,
-        mode: 'chat'
+    // 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,

package/dist/routes/{websocket/authorizeWebsocket.js → auth/callbacks/addUserFieldsToSession.js}

@@ -12,16 +12,17 @@
   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';
-function authorizeWebsocket({ authorize, logger }, { websocketConfig }) {
-    if (!authorize(websocketConfig)) {
-        logger.debug({
-            event: 'debug_websocket_authorize',
-            authorized: false,
-            auth_config: websocketConfig.auth
+*/ import { get, set } from '@lowdefy/helpers';
+function addUserFieldsToSession({ session, token, authConfig, user }) {
+    if (token) {
+        Object.keys(authConfig.userFields).forEach((fieldName)=>{
+            set(session.user, fieldName, get(token, fieldName));
+        });
+    }
+    if (user) {
+        Object.keys(authConfig.userFields).forEach((fieldName)=>{
+            set(session.user, fieldName, get(user, fieldName));
         });
-        // Same message as a missing websocket so channel existence does not leak.
-        throw new ConfigError(`Websocket "${websocketConfig.websocketId}" does not exist.`);
     }
 }
-export default authorizeWebsocket;
+export default addUserFieldsToSession;

package/dist/routes/auth/callbacks/addUserFieldsToToken.js

@@ -0,0 +1,30 @@
+/*
+  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 { get, set } from '@lowdefy/helpers';
+function addUserFieldsToToken({ account, authConfig, logger, profile, token, user }) {
+    const objects = {
+        account,
+        profile,
+        user
+    };
+    logger.debug('Adding userFields to user. Available provider data is:');
+    logger.debug(objects);
+    Object.entries(authConfig.userFields).forEach(([lowdefyFieldName, providerFieldName])=>{
+        const value = get(objects, providerFieldName);
+        logger.debug(`Adding provider field "${providerFieldName}" with value ${JSON.stringify(value)} as "${lowdefyFieldName}"`);
+        set(token, lowdefyFieldName, value);
+    });
+}
+export default addUserFieldsToToken;

package/dist/routes/auth/{hooks/composeAfterSlot.js → callbacks/createCallbackPlugins.js}

@@ -12,15 +12,10 @@
   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.
-*/ // The composed slot for after and synthetic points - engine hooks first,
-// then the user hooks in array order, sequentially. Return values are
-// ignored; a thrown error propagates as an operational error on the
-// underlying operation.
-function composeAfterSlot({ hooks }) {
-    return async function afterSlot(data, ctx) {
-        for (const hook of hooks){
-            await hook(data, ctx);
-        }
-    };
+*/ function createCallbackPlugins({ authConfig, plugins, type }) {
+    return authConfig.callbacks.map((callbackConfig)=>({
+            fn: plugins.callbacks[callbackConfig.type],
+            properties: callbackConfig.properties
+        })).filter((callback)=>callback.fn.meta.type === type);
 }
-export default composeAfterSlot;
+export default createCallbackPlugins;

package/dist/routes/auth/callbacks/createCallbacks.js

@@ -0,0 +1,46 @@
+/*
+  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 createJWTCallback from './createJWTCallback.js';
+import createRedirectCallback from './createRedirectCallback.js';
+import createSessionCallback from './createSessionCallback.js';
+import createSignInCallback from './createSignInCallback.js';
+function createCallbacks({ authConfig, logger, plugins }) {
+    const callbacks = {
+        session: createSessionCallback({
+            authConfig,
+            logger,
+            plugins
+        })
+    };
+    const jwt = createJWTCallback({
+        authConfig,
+        logger,
+        plugins
+    });
+    if (jwt) callbacks.jwt = jwt;
+    const redirect = createRedirectCallback({
+        authConfig,
+        logger,
+        plugins
+    });
+    if (redirect) callbacks.redirect = redirect;
+    const signIn = createSignInCallback({
+        authConfig,
+        plugins
+    });
+    if (signIn) callbacks.signIn = signIn;
+    return callbacks;
+}
+export default createCallbacks;

package/dist/routes/auth/callbacks/createJWTCallback.js

@@ -0,0 +1,77 @@
+/*
+  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 addUserFieldsToToken from './addUserFieldsToToken.js';
+import createCallbackPlugins from './createCallbackPlugins.js';
+function createJWTCallback({ authConfig, logger, plugins }) {
+    const jwtCallbackPlugins = createCallbackPlugins({
+        authConfig,
+        plugins,
+        type: 'jwt'
+    });
+    async function jwtCallback({ token, user, account, profile, isNewUser }) {
+        if (profile) {
+            const { id, sub, name, given_name, family_name, middle_name, nickname, preferred_username, profile: profile_claim, picture, website, email, email_verified, gender, birthdate, zoneinfo, locale, phone_number, phone_number_verified, address, updated_at } = profile;
+            token = {
+                id,
+                sub,
+                name,
+                given_name,
+                family_name,
+                middle_name,
+                nickname,
+                preferred_username,
+                profile: profile_claim,
+                picture,
+                website,
+                email,
+                email_verified,
+                gender,
+                birthdate,
+                zoneinfo,
+                locale,
+                phone_number,
+                phone_number_verified,
+                address,
+                updated_at,
+                ...token
+            };
+        }
+        if (profile || user) {
+            if (authConfig.userFields) {
+                addUserFieldsToToken({
+                    authConfig,
+                    account,
+                    logger,
+                    profile,
+                    token,
+                    user
+                });
+            }
+        }
+        for (const plugin of jwtCallbackPlugins){
+            token = await plugin.fn({
+                properties: plugin.properties ?? {},
+                account,
+                isNewUser,
+                profile,
+                token,
+                user
+            });
+        }
+        return token;
+    }
+    return jwtCallback;
+}
+export default createJWTCallback;

package/dist/routes/auth/callbacks/createRedirectCallback.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 createCallbackPlugins from './createCallbackPlugins.js';
+function defaultRedirect({ url, baseUrl }) {
+    if (url.startsWith('/')) return `${baseUrl}${url}`;
+    else if (new URL(url).origin === baseUrl) return url;
+    return baseUrl;
+}
+function createRedirectCallback({ authConfig, plugins }) {
+    const redirectCallbackPlugins = createCallbackPlugins({
+        authConfig,
+        plugins,
+        type: 'redirect'
+    });
+    if (redirectCallbackPlugins.length === 0) return defaultRedirect;
+    if (redirectCallbackPlugins.length !== 1) {
+        throw new Error('More than one auth redirect callbacks are configured. Only one is allowed.');
+    }
+    const [plugin] = redirectCallbackPlugins;
+    function redirectCallback({ url, baseUrl }) {
+        return plugin.fn({
+            properties: plugin.properties ?? {},
+            baseUrl,
+            url
+        });
+    }
+    return redirectCallback;
+}
+export default createRedirectCallback;

package/dist/routes/auth/callbacks/createSessionCallback.js

@@ -0,0 +1,81 @@
+/*
+  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 crypto from 'crypto';
+import addUserFieldsToSession from './addUserFieldsToSession.js';
+import createCallbackPlugins from './createCallbackPlugins.js';
+import validateSessionRoles from './validateSessionRoles.js';
+function createSessionCallback({ authConfig, plugins }) {
+    const sessionCallbackPlugins = createCallbackPlugins({
+        authConfig,
+        plugins,
+        type: 'session'
+    });
+    async function sessionCallback({ session, token, user }) {
+        const identifier = user ? user.id ?? user.sub ?? user.email : token.id ?? token.sub ?? token.email;
+        if (token) {
+            const { id, sub, name, given_name, family_name, middle_name, nickname, preferred_username, profile, picture, website, email, email_verified, gender, birthdate, zoneinfo, locale, phone_number, phone_number_verified, address, updated_at } = token;
+            session.user = {
+                id,
+                sub,
+                name,
+                given_name,
+                family_name,
+                middle_name,
+                nickname,
+                preferred_username,
+                profile,
+                picture,
+                website,
+                email,
+                email_verified,
+                gender,
+                birthdate,
+                zoneinfo,
+                locale,
+                phone_number,
+                phone_number_verified,
+                address,
+                updated_at,
+                ...session.user
+            };
+        }
+        if (authConfig.userFields) {
+            addUserFieldsToSession({
+                authConfig,
+                session,
+                token,
+                user
+            });
+        }
+        for (const plugin of sessionCallbackPlugins){
+            // eslint-disable-next-line no-param-reassign
+            session = await plugin.fn({
+                properties: plugin.properties ?? {},
+                session,
+                token,
+                user
+            });
+        }
+        validateSessionRoles({
+            session
+        });
+        // TODO: Should this be session.hashed_id or session.user.hashed_id
+        // Only session.user will be available using the _user operator
+        session.hashed_id = crypto.createHash('sha256').update(identifier ?? '').digest('base64');
+        return session;
+    }
+    return sessionCallback;
+}
+export default createSessionCallback;