@pikku/core 0.9.3 → 0.9.4

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## 0.9.0
 
+## 0.9.4
+
+### Patch Changes
+
+- c18800d: feat: adding queue and scheduledTask to interactions
+
 ## 0.9.3
 
 ### Patch Changes

package/dist/function/function-runner.d.ts

@@ -2,11 +2,12 @@ import { CoreServices, CoreUserSession, CorePikkuMiddleware } from '../types/cor
 import { CorePermissionGroup, CorePikkuFunction, CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from './functions.types.js';
 export declare const addFunction: (funcName: string, funcConfig: CorePikkuFunctionConfig<any, any> | CorePikkuFunctionSessionless<any, any> | CorePikkuFunction<any, any>) => void;
 export declare const runPikkuFuncDirectly: <In, Out>(funcName: string, allServices: CoreServices, data: In, session?: CoreUserSession) => Promise<Out>;
-export declare const runPikkuFunc: <In = any, Out = any>(funcName: string, { getAllServices, data, session, permissions: transportPermissions, middleware: transportMiddleware, coerceDataFromSchema, }: {
+export declare const runPikkuFunc: <In = any, Out = any>(funcName: string, { getAllServices, data, session, permissions: transportPermissions, middleware: transportMiddleware, coerceDataFromSchema, tags, }: {
     getAllServices: () => Promise<CoreServices> | CoreServices;
     data: In;
     session?: CoreUserSession;
     permissions?: CorePermissionGroup;
     middleware?: CorePikkuMiddleware[];
     coerceDataFromSchema?: boolean;
+    tags?: string[];
 }) => Promise<Out>;

package/dist/function/function-runner.js

@@ -1,6 +1,6 @@
 import { ForbiddenError } from '../errors/errors.js';
 import { runMiddleware } from '../middleware-runner.js';
-import { verifyPermissions } from '../permissions.js';
+import { verifyPermissions, getPermissionsForTags } from '../permissions.js';
 import { pikkuState } from '../pikku-state.js';
 import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js';
 export const addFunction = (funcName, funcConfig) => {
@@ -16,7 +16,7 @@ export const runPikkuFuncDirectly = async (funcName, allServices, data, session)
     }
     return (await funcConfig.func(allServices, data, session));
 };
-export const runPikkuFunc = async (funcName, { getAllServices, data, session, permissions: transportPermissions, middleware: transportMiddleware, coerceDataFromSchema, }) => {
+export const runPikkuFunc = async (funcName, { getAllServices, data, session, permissions: transportPermissions, middleware: transportMiddleware, coerceDataFromSchema, tags = [], }) => {
     const funcConfig = pikkuState('function', 'functions').get(funcName);
     if (!funcConfig) {
         throw new Error(`Function not found: ${funcName}`);
@@ -39,7 +39,17 @@ export const runPikkuFunc = async (funcName, { getAllServices, data, session, pe
         }
     }
     let permissioned = true;
-    if (funcConfig.permissions) {
+    // Check tagged permissions first - ALL must pass
+    const taggedPermissions = getPermissionsForTags([
+        ...tags,
+        ...(funcConfig.tags || []),
+    ]);
+    if (taggedPermissions.length > 0) {
+        const taggedResults = await Promise.all(taggedPermissions.map((permission) => permission(allServices, data, session)));
+        permissioned = taggedResults.every((result) => result);
+    }
+    // Only check function permissions if tagged permissions passed
+    if (permissioned && funcConfig.permissions) {
         permissioned = await verifyPermissions(funcConfig.permissions, allServices, data, session);
     }
     if (!permissioned && transportPermissions) {

package/dist/function/functions.types.d.ts

@@ -35,12 +35,13 @@ export type CorePikkuFunctionSessionless<In, Out, ChannelData extends unknown |
  */
 export type CorePikkuPermission<In = any, Services extends CoreSingletonServices = CoreServices, Session extends CoreUserSession = CoreUserSession> = (services: Services, data: In, session?: Session) => Promise<boolean>;
 export type CorePermissionGroup<PikkuPermission = CorePikkuPermission<any>> = Record<string, PikkuPermission | PikkuPermission[]> | undefined;
-export type CorePikkuFunctionConfig<PikkuFunction extends CorePikkuFunction<any, any, any, any, any> | CorePikkuFunctionSessionless<any, any, any, any, any>, PikkuPermission extends CorePikkuPermission<any, any, any> = CorePikkuPermission<any>> = {
+export type CorePikkuFunctionConfig<PikkuFunction extends CorePikkuFunction<any, any, any, any, any> | CorePikkuFunctionSessionless<any, any, any, any, any>, PikkuPermission extends CorePikkuPermission<any, any, any> = CorePikkuPermission<any>, PikkuMiddleware extends CorePikkuMiddleware<any> = CorePikkuMiddleware<any>> = {
     name?: string;
     expose?: boolean;
     func: PikkuFunction;
     auth?: boolean;
     permissions?: CorePermissionGroup<PikkuPermission>;
-    middleware?: CorePikkuMiddleware[];
+    middleware?: PikkuMiddleware[];
+    tags?: string[];
     docs?: PikkuDocs;
 };

package/dist/index.d.ts

@@ -21,7 +21,8 @@ export * from './middleware/index.js';
 export * from './time-utils.js';
 export * from './utils.js';
 export { pikkuState } from './pikku-state.js';
-export { runMiddleware } from './middleware-runner.js';
+export { runMiddleware, addMiddleware, addMiddlewareForTags, } from './middleware-runner.js';
+export { addPermission, getPermissionsForTags } from './permissions.js';
 export { wireHTTP, addHTTPMiddleware } from './wirings/http/http-runner.js';
 export { wireChannel } from './wirings/channel/channel-runner.js';
 export { wireScheduler } from './wirings/scheduler/scheduler-runner.js';

package/dist/index.js

@@ -21,7 +21,8 @@ export * from './middleware/index.js';
 export * from './time-utils.js';
 export * from './utils.js';
 export { pikkuState } from './pikku-state.js';
-export { runMiddleware } from './middleware-runner.js';
+export { runMiddleware, addMiddleware, addMiddlewareForTags, } from './middleware-runner.js';
+export { addPermission, getPermissionsForTags } from './permissions.js';
 export { wireHTTP, addHTTPMiddleware } from './wirings/http/http-runner.js';
 export { wireChannel } from './wirings/channel/channel-runner.js';
 export { wireScheduler } from './wirings/scheduler/scheduler-runner.js';

package/dist/middleware-runner.d.ts

@@ -20,3 +20,65 @@ import { CoreSingletonServices, PikkuInteraction, CorePikkuMiddleware } from './
 export declare const runMiddleware: <Middleware extends CorePikkuMiddleware>(services: CoreSingletonServices & {
     userSession?: UserSessionService<any>;
 }, interaction: PikkuInteraction, middlewares: Middleware[], main?: () => Promise<unknown>) => Promise<unknown>;
+/**
+ * Adds global middleware for a specific tag.
+ *
+ * This function allows you to register middleware that will be applied to
+ * any wiring (HTTP, Channel, Queue, Scheduler, MCP) that includes the matching tag.
+ *
+ * @template PikkuMiddleware The middleware type.
+ * @param {string} tag - The tag that the middleware should apply to.
+ * @param {PikkuMiddleware[]} middleware - The middleware array to apply for the specified tag.
+ *
+ * @throws {Error} If middleware for the tag already exists.
+ *
+ * @example
+ * ```typescript
+ * // Add admin middleware for admin endpoints
+ * addMiddleware('admin', [adminMiddleware])
+ *
+ * // Add authentication middleware for auth endpoints
+ * addMiddleware('auth', [authMiddleware])
+ *
+ * // Add logging middleware for all API endpoints
+ * addMiddleware('api', [loggingMiddleware])
+ * ```
+ */
+export declare const addMiddleware: <PikkuMiddleware extends CorePikkuMiddleware>(tag: string, middleware: PikkuMiddleware[]) => void;
+/**
+ * Retrieves middleware for a given set of tags.
+ *
+ * This function looks up all middleware registered for any of the provided tags
+ * and returns them as a flattened array.
+ *
+ * @param {string[]} tags - Array of tags to look up middleware for.
+ * @returns {CorePikkuMiddleware[]} Array of middleware functions that apply to the given tags.
+ *
+ * @example
+ * ```typescript
+ * // Get all middleware for tags 'api' and 'auth'
+ * const middleware = getMiddlewareForTags(['api', 'auth'])
+ * ```
+ */
+export declare const getMiddlewareForTags: (tags?: string[]) => CorePikkuMiddleware[];
+/**
+ * Combines tag-based middleware with wiring-specific middleware.
+ *
+ * This helper function gets middleware for tags and combines it with any
+ * wiring-specific middleware, avoiding the need for manual spreading.
+ *
+ * @param {CorePikkuMiddleware[] | undefined} wiringMiddleware - Wiring-specific middleware.
+ * @param {string[] | undefined} tags - Array of tags to look up middleware for.
+ * @returns {CorePikkuMiddleware[]} Combined array of tag-based and wiring-specific middleware.
+ *
+ * @example
+ * ```typescript
+ * // Instead of:
+ * const taggedMiddleware = getMiddlewareForTags(tags)
+ * const combined = [...taggedMiddleware, ...(middleware || [])]
+ *
+ * // Use:
+ * const combined = addMiddlewareForTags(middleware, tags)
+ * ```
+ */
+export declare const addMiddlewareForTags: (wiringMiddleware?: CorePikkuMiddleware[], tags?: string[]) => CorePikkuMiddleware[];

package/dist/middleware-runner.js

@@ -1,3 +1,4 @@
+import { pikkuState } from './pikku-state.js';
 /**
  * Runs a chain of middleware functions in sequence before executing the main function.
  *
@@ -16,10 +17,12 @@
  * );
  */
 export const runMiddleware = async (services, interaction, middlewares, main) => {
+    // Deduplicate middleware using Set to avoid running the same middleware multiple times
+    const uniqueMiddleware = Array.from(new Set(middlewares));
     let result;
     const dispatch = async (index) => {
-        if (middlewares && index < middlewares.length) {
-            return await middlewares[index](services, interaction, () => dispatch(index + 1));
+        if (uniqueMiddleware && index < uniqueMiddleware.length) {
+            return await uniqueMiddleware[index](services, interaction, () => dispatch(index + 1));
         }
         else if (main) {
             result = await main();
@@ -28,3 +31,89 @@ export const runMiddleware = async (services, interaction, middlewares, main) =>
     await dispatch(0);
     return result;
 };
+/**
+ * Adds global middleware for a specific tag.
+ *
+ * This function allows you to register middleware that will be applied to
+ * any wiring (HTTP, Channel, Queue, Scheduler, MCP) that includes the matching tag.
+ *
+ * @template PikkuMiddleware The middleware type.
+ * @param {string} tag - The tag that the middleware should apply to.
+ * @param {PikkuMiddleware[]} middleware - The middleware array to apply for the specified tag.
+ *
+ * @throws {Error} If middleware for the tag already exists.
+ *
+ * @example
+ * ```typescript
+ * // Add admin middleware for admin endpoints
+ * addMiddleware('admin', [adminMiddleware])
+ *
+ * // Add authentication middleware for auth endpoints
+ * addMiddleware('auth', [authMiddleware])
+ *
+ * // Add logging middleware for all API endpoints
+ * addMiddleware('api', [loggingMiddleware])
+ * ```
+ */
+export const addMiddleware = (tag, middleware) => {
+    const middlewareStore = pikkuState('misc', 'middleware');
+    // Check if tag already exists
+    if (middlewareStore[tag]) {
+        throw new Error(`Middleware for tag '${tag}' already exists. Use a different tag or remove the existing middleware first.`);
+    }
+    middlewareStore[tag] = middleware;
+};
+/**
+ * Retrieves middleware for a given set of tags.
+ *
+ * This function looks up all middleware registered for any of the provided tags
+ * and returns them as a flattened array.
+ *
+ * @param {string[]} tags - Array of tags to look up middleware for.
+ * @returns {CorePikkuMiddleware[]} Array of middleware functions that apply to the given tags.
+ *
+ * @example
+ * ```typescript
+ * // Get all middleware for tags 'api' and 'auth'
+ * const middleware = getMiddlewareForTags(['api', 'auth'])
+ * ```
+ */
+export const getMiddlewareForTags = (tags) => {
+    if (!tags || tags.length === 0) {
+        return [];
+    }
+    const middlewareStore = pikkuState('misc', 'middleware');
+    const applicableMiddleware = [];
+    // Collect middleware for all matching tags
+    for (const tag of tags) {
+        const tagMiddleware = middlewareStore[tag];
+        if (tagMiddleware) {
+            applicableMiddleware.push(...tagMiddleware);
+        }
+    }
+    return applicableMiddleware;
+};
+/**
+ * Combines tag-based middleware with wiring-specific middleware.
+ *
+ * This helper function gets middleware for tags and combines it with any
+ * wiring-specific middleware, avoiding the need for manual spreading.
+ *
+ * @param {CorePikkuMiddleware[] | undefined} wiringMiddleware - Wiring-specific middleware.
+ * @param {string[] | undefined} tags - Array of tags to look up middleware for.
+ * @returns {CorePikkuMiddleware[]} Combined array of tag-based and wiring-specific middleware.
+ *
+ * @example
+ * ```typescript
+ * // Instead of:
+ * const taggedMiddleware = getMiddlewareForTags(tags)
+ * const combined = [...taggedMiddleware, ...(middleware || [])]
+ *
+ * // Use:
+ * const combined = addMiddlewareForTags(middleware, tags)
+ * ```
+ */
+export const addMiddlewareForTags = (wiringMiddleware, tags) => {
+    const taggedMiddleware = getMiddlewareForTags(tags);
+    return [...taggedMiddleware, ...(wiringMiddleware || [])];
+};

package/dist/permissions.d.ts

@@ -8,3 +8,43 @@ import { CorePermissionGroup } from './function/functions.types.js';
  * @returns A promise that resolves to void.
  */
 export declare const verifyPermissions: (permissions: CorePermissionGroup, services: CoreServices, data: any, session?: CoreUserSession) => Promise<boolean>;
+/**
+ * Adds global permissions for a specific tag.
+ *
+ * This function allows you to register permissions that will be applied to
+ * any wiring (HTTP, Channel, Queue, Scheduler, MCP) that includes the matching tag.
+ *
+ * @param {string} tag - The tag that the permissions should apply to.
+ * @param {any[]} permissions - The permissions array to apply for the specified tag.
+ *
+ * @throws {Error} If permissions for the tag already exist.
+ *
+ * @example
+ * ```typescript
+ * // Add admin permissions for admin endpoints
+ * addPermission('admin', [adminPermission])
+ *
+ * // Add authentication permissions for auth endpoints
+ * addPermission('auth', [authPermission])
+ *
+ * // Add read permissions for all API endpoints
+ * addPermission('api', [readPermission])
+ * ```
+ */
+export declare const addPermission: (tag: string, permissions: any[]) => void;
+/**
+ * Retrieves permissions for a given set of tags.
+ *
+ * This function looks up all permissions registered for any of the provided tags
+ * and returns them as a flattened array.
+ *
+ * @param {string[]} tags - Array of tags to look up permissions for.
+ * @returns {any[]} Array of permission functions that apply to the given tags.
+ *
+ * @example
+ * ```typescript
+ * // Get all permissions for tags 'api' and 'auth'
+ * const permissions = getPermissionsForTags(['api', 'auth'])
+ * ```
+ */
+export declare const getPermissionsForTags: (tags?: string[]) => any[];

package/dist/permissions.js

@@ -1,3 +1,4 @@
+import { pikkuState } from './pikku-state.js';
 /**
  * This function validates permissions by iterating over permission groups and executing the corresponding permission functions. If all functions in at least one group return true, the permission is considered valid.
  * @param services - The core services required for permission validation.
@@ -30,3 +31,64 @@ export const verifyPermissions = async (permissions, services, data, session) =>
     }
     return false;
 };
+/**
+ * Adds global permissions for a specific tag.
+ *
+ * This function allows you to register permissions that will be applied to
+ * any wiring (HTTP, Channel, Queue, Scheduler, MCP) that includes the matching tag.
+ *
+ * @param {string} tag - The tag that the permissions should apply to.
+ * @param {any[]} permissions - The permissions array to apply for the specified tag.
+ *
+ * @throws {Error} If permissions for the tag already exist.
+ *
+ * @example
+ * ```typescript
+ * // Add admin permissions for admin endpoints
+ * addPermission('admin', [adminPermission])
+ *
+ * // Add authentication permissions for auth endpoints
+ * addPermission('auth', [authPermission])
+ *
+ * // Add read permissions for all API endpoints
+ * addPermission('api', [readPermission])
+ * ```
+ */
+export const addPermission = (tag, permissions) => {
+    const permissionsStore = pikkuState('misc', 'permissions');
+    // Check if tag already exists
+    if (permissionsStore[tag]) {
+        throw new Error(`Permissions for tag '${tag}' already exist. Use a different tag or remove the existing permissions first.`);
+    }
+    permissionsStore[tag] = permissions;
+};
+/**
+ * Retrieves permissions for a given set of tags.
+ *
+ * This function looks up all permissions registered for any of the provided tags
+ * and returns them as a flattened array.
+ *
+ * @param {string[]} tags - Array of tags to look up permissions for.
+ * @returns {any[]} Array of permission functions that apply to the given tags.
+ *
+ * @example
+ * ```typescript
+ * // Get all permissions for tags 'api' and 'auth'
+ * const permissions = getPermissionsForTags(['api', 'auth'])
+ * ```
+ */
+export const getPermissionsForTags = (tags) => {
+    if (!tags || tags.length === 0) {
+        return [];
+    }
+    const permissionsStore = pikkuState('misc', 'permissions');
+    const applicablePermissions = [];
+    // Collect permissions for all matching tags
+    for (const tag of new Set(tags)) {
+        const tagPermissions = permissionsStore[tag];
+        if (tagPermissions) {
+            applicablePermissions.push(...tagPermissions);
+        }
+    }
+    return applicablePermissions;
+};

package/dist/pikku-state.d.ts

@@ -49,6 +49,8 @@ interface PikkuState {
     misc: {
         errors: Map<PikkuError, ErrorDetails>;
         schemas: Map<string, any>;
+        middleware: Record<string, CorePikkuMiddleware[]>;
+        permissions: Record<string, any[]>;
     };
 }
 export declare const resetPikkuState: () => void;

package/dist/pikku-state.js

@@ -36,6 +36,8 @@ export const resetPikkuState = () => {
         misc: {
             errors: globalThis.pikkuState?.misc?.errors || new Map(),
             schemas: globalThis.pikkuState?.misc?.schema || new Map(),
+            middleware: globalThis.pikkuState?.misc?.middleware || {},
+            permissions: globalThis.pikkuState?.misc?.permissions || {},
         },
     };
 };

package/dist/types/core.types.d.ts

@@ -6,6 +6,8 @@ import { UserSessionService } from '../services/user-session-service.js';
 import { PikkuChannel } from '../wirings/channel/channel.types.js';
 import { PikkuRPC } from '../wirings/rpc/rpc-types.js';
 import { PikkuMCP } from '../wirings/mcp/mcp.types.js';
+import { PikkuScheduledTask } from '../wirings/scheduler/scheduler.types.js';
+import { PikkuQueue } from '../wirings/queue/queue.types.js';
 export declare enum PikkuWiringTypes {
     http = "http",
     scheduler = "scheduler",
@@ -90,11 +92,15 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
 /**
  * Represents different forms of interaction within Pikku and the outside world.
  */
-export interface PikkuInteraction {
-    http?: PikkuHTTP;
-    mcp?: PikkuMCP;
-    rpc?: PikkuRPC;
-}
+export type PikkuInteraction = Partial<{
+    http: PikkuHTTP;
+    mcp: PikkuMCP;
+    rpc: PikkuRPC;
+    channel: PikkuChannel<unknown, unknown>;
+    scheduledTask: PikkuScheduledTask;
+    queue: PikkuQueue;
+    s: any;
+}>;
 /**
  * A function that can wrap an interaction and be called before or after
  */

package/dist/wirings/channel/channel-handler.js

@@ -56,6 +56,7 @@ export const processMessageHandlers = (services, session, channelConfig, channel
             session,
             permissions,
             middleware,
+            tags: channelConfig.tags,
         });
     };
     const onMessage = async (rawData) => {

package/dist/wirings/channel/local/local-channel-runner.js

@@ -4,7 +4,7 @@ import { closeSessionServices } from '../../../utils.js';
 import { processMessageHandlers } from '../channel-handler.js';
 import { PikkuLocalChannelHandler } from './local-channel-handler.js';
 import { handleHTTPError } from '../../../handle-error.js';
-import { runMiddleware } from '../../../middleware-runner.js';
+import { addMiddlewareForTags, runMiddleware, } from '../../../middleware-runner.js';
 import { PikkuUserSessionService } from '../../../services/user-session-service.js';
 import { runPikkuFuncDirectly } from '../../../function/function-runner.js';
 import { rpcService } from '../../rpc/rpc-runner.js';
@@ -17,25 +17,33 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
         http = createHTTPInteraction(request, response);
         route = http?.request?.path();
     }
+    let openingData, channelConfig, meta;
+    try {
+        ;
+        ({ openingData, channelConfig, meta } = await openChannel({
+            channelId,
+            createSessionServices,
+            respondWith404,
+            request,
+            response,
+            route,
+            singletonServices,
+            skipUserSession,
+            coerceDataFromSchema,
+            userSession,
+        }));
+    }
+    catch (e) {
+        handleHTTPError(e, http, channelId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
+        return;
+    }
     const main = async () => {
         try {
-            const { openingData, channelConfig, meta } = await openChannel({
-                channelId,
-                createSessionServices,
-                respondWith404,
-                request,
-                response,
-                route,
-                singletonServices,
-                skipUserSession,
-                coerceDataFromSchema,
-                userSession,
-            });
             channelHandler = new PikkuLocalChannelHandler(channelId, channelConfig.name, openingData);
             const channel = channelHandler.getChannel();
             const session = await userSession.get();
             if (createSessionServices) {
-                sessionServices = await createSessionServices(singletonServices, { http }, session);
+                sessionServices = await createSessionServices(singletonServices, { http, channel }, session);
             }
             const allServices = rpcService.injectRPCService({
                 ...singletonServices,
@@ -69,6 +77,6 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
     await runMiddleware({
         ...singletonServices,
         userSession,
-    }, { http }, route.middleware || [], main);
+    }, { http }, addMiddlewareForTags(channelConfig.middleware, channelConfig.tags), main);
     return channelHandler;
 };

package/dist/wirings/channel/serverless/serverless-channel-runner.js

@@ -4,7 +4,7 @@ import { openChannel } from '../channel-runner.js';
 import { createHTTPInteraction } from '../../http/http-runner.js';
 import { handleHTTPError } from '../../../handle-error.js';
 import { PikkuUserSessionService } from '../../../services/user-session-service.js';
-import { runMiddleware } from '../../../middleware-runner.js';
+import { addMiddlewareForTags, runMiddleware, } from '../../../middleware-runner.js';
 import { pikkuState } from '../../../pikku-state.js';
 import { PikkuFetchHTTPRequest } from '../../http/pikku-fetch-http-request.js';
 import { runPikkuFuncDirectly } from '../../../function/function-runner.js';
@@ -76,7 +76,7 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
     await runMiddleware({
         ...singletonServices,
         userSession,
-    }, { http }, channelConfig.middleware || [], main);
+    }, { http }, addMiddlewareForTags(channelConfig.middleware, channelConfig.tags), main);
 };
 export const runChannelDisconnect = async ({ singletonServices, ...params }) => {
     let sessionServices;

package/dist/wirings/http/http-runner.js

@@ -2,7 +2,7 @@ import { match } from 'path-to-regexp';
 import { MissingSessionError, NotFoundError } from '../../errors/errors.js';
 import { closeSessionServices, createWeakUID, isSerializable, } from '../../utils.js';
 import { PikkuUserSessionService, } from '../../services/user-session-service.js';
-import { runMiddleware } from '../../middleware-runner.js';
+import { addMiddlewareForTags, runMiddleware } from '../../middleware-runner.js';
 import { handleHTTPError } from '../../handle-error.js';
 import { pikkuState } from '../../pikku-state.js';
 import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
@@ -143,7 +143,16 @@ export const createHTTPInteraction = (request, response) => {
 /**
  * Validates the input data and executes the route handler with associated middleware.
  *
- * This function is the central execution point for a route. It performs these steps:
+ * NOTE: HTTP wiring handles middleware differently from other wirings (RPC, MCP, Queue, etc.)
+ * because HTTP needs to:
+ * 1. Check session early for performance (before expensive body parsing)
+ * 2. Handle HTTP-specific concerns (headers, cookies, SSE setup)
+ * 3. Process middleware that may set up authentication/session state
+ *
+ * Other wirings (RPC/MCP/Queue/Scheduler) simply pass middleware/permissions/auth
+ * directly to runPikkuFunc without processing them.
+ *
+ * This function performs these steps:
  *  1. Sets URL parameters on the request.
  *  2. Validates the user session if required.
  *  3. Creates session-specific services.
@@ -228,6 +237,7 @@ const executeRouteWithMiddleware = async (services, matchedRoute, http, options)
             data,
             permissions: route.permissions,
             coerceDataFromSchema: options.coerceDataFromSchema,
+            tags: route.tags,
         });
         // Respond with either a binary or JSON response based on configuration
         if (route.returnsJSON === false) {
@@ -241,7 +251,7 @@ const executeRouteWithMiddleware = async (services, matchedRoute, http, options)
         // http?.response?.end()
     };
     // Execute middleware, then run the main logic
-    await runMiddleware({ ...singletonServices, userSession }, { http }, middleware, runMain);
+    await runMiddleware({ ...singletonServices, userSession }, { http }, addMiddlewareForTags(middleware, route.tags), runMain);
     return sessionServices ? { result, sessionServices } : { result };
 };
 /**

package/dist/wirings/http/http.types.d.ts

@@ -35,6 +35,7 @@ export type CoreHTTPFunction = {
     eventChannel?: false;
     returnsJSON?: false;
     timeout?: number;
+    tags?: string[];
     docs?: Partial<{
         description: string;
         response: string;

package/dist/wirings/mcp/mcp-runner.js

@@ -4,6 +4,7 @@ import { pikkuState } from '../../pikku-state.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 import { rpcService } from '../rpc/rpc-runner.js';
 import { BadRequestError, NotFoundError } from '../../errors/errors.js';
+import { addMiddlewareForTags, runMiddleware } from '../../middleware-runner.js';
 export class MCPError extends Error {
     error;
     constructor(error) {
@@ -113,26 +114,33 @@ async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncName, { sessio
             throw new NotFoundError(`MCP '${type}' PikkuFunction Mapping not found for '${name}'`);
         }
         singletonServices.logger.debug(`Running MCP ${type}: ${name}`);
-        const getAllServices = async () => {
-            if (createSessionServices) {
-                const services = await createSessionServices(singletonServices, { mcp: interaction }, session);
-                sessionServices = services;
+        let result;
+        // Main MCP execution logic wrapped for middleware handling
+        const runMain = async () => {
+            const getAllServices = async () => {
+                if (createSessionServices) {
+                    const services = await createSessionServices(singletonServices, { mcp: interaction }, session);
+                    sessionServices = services;
+                    return rpcService.injectRPCService({
+                        ...singletonServices,
+                        ...services,
+                        mcp: interaction,
+                    });
+                }
                 return rpcService.injectRPCService({
                     ...singletonServices,
-                    ...services,
                     mcp: interaction,
                 });
-            }
-            return rpcService.injectRPCService({
-                ...singletonServices,
-                mcp: interaction,
+            };
+            result = await runPikkuFunc(pikkuFuncName, {
+                getAllServices,
+                session,
+                data: request.params,
+                tags: mcp.tags,
             });
         };
-        const result = await runPikkuFunc(pikkuFuncName, {
-            getAllServices,
-            session,
-            data: request.params,
-        });
+        // Get middleware for tags and run middleware
+        await runMiddleware(singletonServices, { mcp: interaction }, addMiddlewareForTags(mcp.middleware, mcp.tags), runMain);
         return {
             id: request.id,
             result,