@pikku/core 0.9.4 → 0.9.6

package/dist/wirings/channel/channel-runner.d.ts

@@ -1,4 +1,5 @@
 import { UserSessionService } from '../../services/user-session-service.js';
+import { CorePikkuMiddleware } from '../../types/core.types.js';
 import { ChannelMeta, CoreChannel, RunChannelOptions, RunChannelParams } from './channel.types.js';
 /**
  * Adds a channel and registers all functions referenced in it using the
@@ -11,4 +12,5 @@ export declare const openChannel: ({ route, singletonServices, coerceDataFromSch
     openingData: unknown;
     channelConfig: CoreChannel<unknown, any>;
     meta: ChannelMeta;
+    httpMiddleware: CorePikkuMiddleware[] | undefined;
 }>;

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

@@ -2,7 +2,7 @@ import { NotFoundError } from '../../errors/errors.js';
 import { addFunction } from '../../function/function-runner.js';
 import { pikkuState } from '../../pikku-state.js';
 import { coerceTopLevelDataFromSchema, validateSchema } from '../../schema.js';
-import { match } from 'path-to-regexp';
+import { httpRouter } from '../http/routers/http-router.js';
 /**
  * Adds a channel and registers all functions referenced in it using the
  * function names already stored in the channel metadata
@@ -65,30 +65,28 @@ export const wireChannel = (channel) => {
     pikkuState('channel', 'channels').set(channel.name, channel);
 };
 const getMatchingChannelConfig = (request) => {
+    const matchedPath = httpRouter.match('get', request);
+    if (!matchedPath) {
+        return null;
+    }
+    const meta = pikkuState('channel', 'meta');
+    const channelMeta = Object.values(meta).find((channelConfig) => channelConfig.route === matchedPath.route);
+    if (!channelMeta) {
+        return null;
+    }
     const channels = pikkuState('channel', 'channels');
-    const channelsMeta = pikkuState('channel', 'meta');
-    for (const channelConfig of channels.values()) {
-        const cleanedRoute = channelConfig.route.replace(/^\/\//, '/');
-        const cleanedRequest = request.replace(/^\/\//, '/');
-        const matchFunc = match(cleanedRoute, {
-            decode: decodeURIComponent,
-        });
-        const matchedPath = matchFunc(cleanedRequest);
-        if (matchedPath) {
-            const channelMeta = channelsMeta[channelConfig.name];
-            if (!channelMeta) {
-                throw new Error(`Channel ${channelConfig.name} not found in metadata`);
-            }
-            return {
-                matchedPath,
-                params: matchedPath.params,
-                channelConfig,
-                schemaName: channelMeta.input,
-                meta: channelMeta,
-            };
-        }
+    const channelConfig = channels.get(channelMeta.name);
+    if (!channelConfig) {
+        return null;
     }
-    return null;
+    return {
+        matchedPath,
+        params: matchedPath.params,
+        channelConfig,
+        schemaName: channelMeta.input,
+        meta: channelMeta,
+        httpMiddleware: matchedPath.middleware,
+    };
 };
 export const openChannel = async ({ route, singletonServices, coerceDataFromSchema = true, request, }) => {
     const matchingChannel = getMatchingChannelConfig(route);
@@ -96,7 +94,7 @@ export const openChannel = async ({ route, singletonServices, coerceDataFromSche
         singletonServices.logger.info(`Channel not found: ${route}`);
         throw new NotFoundError(`Channel not found: ${route}`);
     }
-    const { params, channelConfig, schemaName, meta } = matchingChannel;
+    const { params, channelConfig, schemaName, meta, httpMiddleware } = matchingChannel;
     const requiresSession = channelConfig.auth !== false;
     request?.setParams(params);
     singletonServices.logger.info(`Matched channel: ${channelConfig.name} | route: ${channelConfig.route} | auth: ${requiresSession.toString()}`);
@@ -108,5 +106,5 @@ export const openChannel = async ({ route, singletonServices, coerceDataFromSche
         }
         await validateSchema(singletonServices.logger, singletonServices.schema, schemaName, openingData);
     }
-    return { openingData, channelConfig, meta };
+    return { openingData, channelConfig, meta, httpMiddleware };
 };

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

@@ -3,8 +3,9 @@ import { createHTTPInteraction } from '../../http/http-runner.js';
 import { closeSessionServices } from '../../../utils.js';
 import { processMessageHandlers } from '../channel-handler.js';
 import { PikkuLocalChannelHandler } from './local-channel-handler.js';
+import { PikkuWiringTypes } from '../../../types/core.types.js';
 import { handleHTTPError } from '../../../handle-error.js';
-import { addMiddlewareForTags, runMiddleware, } from '../../../middleware-runner.js';
+import { combineMiddleware, 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,10 +18,10 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
         http = createHTTPInteraction(request, response);
         route = http?.request?.path();
     }
-    let openingData, channelConfig, meta;
+    let openingData, channelConfig, meta, httpMiddleware;
     try {
         ;
-        ({ openingData, channelConfig, meta } = await openChannel({
+        ({ openingData, channelConfig, meta, httpMiddleware } = await openChannel({
             channelId,
             createSessionServices,
             respondWith404,
@@ -77,6 +78,10 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
     await runMiddleware({
         ...singletonServices,
         userSession,
-    }, { http }, addMiddlewareForTags(channelConfig.middleware, channelConfig.tags), main);
+    }, { http }, combineMiddleware(PikkuWiringTypes.channel, channelConfig.name, {
+        wiringMiddleware: channelConfig.middleware,
+        wiringTags: channelConfig.tags,
+        httpMiddleware,
+    }), main);
     return channelHandler;
 };

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

@@ -1,10 +1,11 @@
+import { PikkuWiringTypes } from '../../../types/core.types.js';
 import { closeSessionServices } from '../../../utils.js';
 import { processMessageHandlers } from '../channel-handler.js';
 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 { addMiddlewareForTags, runMiddleware, } from '../../../middleware-runner.js';
+import { combineMiddleware, 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';
@@ -34,7 +35,7 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
         http = createHTTPInteraction(new PikkuFetchHTTPRequest(request), response);
     }
     const userSession = new PikkuUserSessionService(channelStore, channelId);
-    const { channelConfig, openingData, meta } = await openChannel({
+    const { channelConfig, openingData, meta, httpMiddleware } = await openChannel({
         channelId,
         createSessionServices,
         request,
@@ -76,7 +77,11 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
     await runMiddleware({
         ...singletonServices,
         userSession,
-    }, { http }, addMiddlewareForTags(channelConfig.middleware, channelConfig.tags), main);
+    }, { http }, combineMiddleware(PikkuWiringTypes.channel, channelConfig.name, {
+        wiringMiddleware: channelConfig.middleware,
+        wiringTags: channelConfig.tags,
+        httpMiddleware,
+    }), main);
 };
 export const runChannelDisconnect = async ({ singletonServices, ...params }) => {
     let sessionServices;

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

@@ -1,14 +1,15 @@
-import { match } from 'path-to-regexp';
+import { PikkuWiringTypes, } from '../../types/core.types.js';
 import { MissingSessionError, NotFoundError } from '../../errors/errors.js';
 import { closeSessionServices, createWeakUID, isSerializable, } from '../../utils.js';
 import { PikkuUserSessionService, } from '../../services/user-session-service.js';
-import { addMiddlewareForTags, runMiddleware } from '../../middleware-runner.js';
+import { combineMiddleware, 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';
 import { PikkuFetchHTTPRequest } from './pikku-fetch-http-request.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 import { rpcService } from '../rpc/rpc-runner.js';
+import { httpRouter } from './routers/http-router.js';
 /**
  * Registers middleware either globally or for a specific route.
  *
@@ -22,25 +23,20 @@ import { rpcService } from '../rpc/rpc-runner.js';
  */
 export const addHTTPMiddleware = (routeOrMiddleware, middleware) => {
     const middlewareStore = pikkuState('http', 'middleware');
-    if (typeof routeOrMiddleware === 'string' && middleware) {
-        const route = routeOrMiddleware;
-        // Remove existing entry for this route if it exists
-        const existingIndex = middlewareStore.findIndex((item) => item.route === route);
-        if (existingIndex !== -1) {
-            middlewareStore.splice(existingIndex, 1);
-        }
-        middlewareStore.push({ route, middleware });
+    let route = '*';
+    if (typeof routeOrMiddleware === 'string') {
+        route = routeOrMiddleware;
+        middleware = middleware;
     }
     else {
-        // Handle global middleware
-        const existingIndex = middlewareStore.findIndex((item) => item.route === '*');
-        if (existingIndex !== -1) {
-            middlewareStore.splice(existingIndex, 1);
-        }
-        middlewareStore.push({
-            route: '*',
-            middleware: routeOrMiddleware,
-        });
+        middleware = routeOrMiddleware;
+    }
+    const currentMiddleware = middlewareStore.get(route);
+    if (currentMiddleware) {
+        middlewareStore.set(route, [...currentMiddleware, ...middleware]);
+    }
+    else {
+        middlewareStore.set(route, middleware);
     }
 };
 /**
@@ -60,7 +56,7 @@ export const addHTTPMiddleware = (routeOrMiddleware, middleware) => {
  */
 export const wireHTTP = (httpWiring) => {
     const httpMeta = pikkuState('http', 'meta');
-    const routeMeta = httpMeta.find((meta) => meta.route === httpWiring.route && meta.method === httpWiring.method);
+    const routeMeta = httpMeta[httpWiring.method][httpWiring.route];
     if (!routeMeta) {
         throw new Error('Route metadata not found');
     }
@@ -85,37 +81,22 @@ export const wireHTTP = (httpWiring) => {
  * @returns {Object | undefined} An object with matched route details or undefined if no match.
  */
 const getMatchingRoute = (requestType, requestPath) => {
-    const allRoutes = pikkuState('http', 'routes');
-    const middleware = pikkuState('http', 'middleware');
-    const routes = allRoutes.get(requestType.toLowerCase());
-    if (!routes) {
-        return undefined;
-    }
-    for (const route of routes.values()) {
-        // Generate a matching function from the route pattern
-        const matchFunc = match(`/${route.route}`.replace(/^\/\//, '/'), {
-            decode: decodeURIComponent,
-        });
-        // Attempt to match the request path
-        const matchedPath = matchFunc(requestPath.replace(/^\/\//, '/'));
-        if (matchedPath) {
-            // Aggregate global and route-specific middleware
-            const globalMiddleware = middleware
-                .filter((m) => m.route === '*' || new RegExp(m.route).test(route.route))
-                .map((m) => m.middleware)
-                .flat();
-            const meta = pikkuState('http', 'meta').find((meta) => meta.route === route.route && meta.method === route.method);
-            return {
-                matchedPath,
-                params: matchedPath.params,
-                route,
-                permissions: route.permissions,
-                middleware: [...globalMiddleware, ...(route.middleware || [])],
-                meta: meta,
-            };
-        }
+    const matchedPath = httpRouter.match(requestType.toLowerCase(), requestPath);
+    if (matchedPath) {
+        const route = pikkuState('http', 'routes')
+            .get(requestType.toLowerCase())
+            .get(matchedPath.route);
+        const meta = pikkuState('http', 'meta')[requestType.toLowerCase()][route.route];
+        return {
+            matchedPath,
+            params: matchedPath.params,
+            route,
+            permissions: route.permissions,
+            httpMiddleware: matchedPath.middleware,
+            middleware: route.middleware,
+            meta: meta,
+        };
     }
-    return undefined;
 };
 /**
  * Combines the request and response objects into a single HTTP interaction object.
@@ -170,7 +151,7 @@ export const createHTTPInteraction = (request, response) => {
  * @throws Throws errors like MissingSessionError or ForbiddenError on validation failures.
  */
 const executeRouteWithMiddleware = async (services, matchedRoute, http, options) => {
-    const { matchedPath, params, route, middleware, meta } = matchedRoute;
+    const { matchedPath, params, route, httpMiddleware, middleware, meta } = matchedRoute;
     const { singletonServices, userSession, createSessionServices, skipUserSession, requestId, } = services;
     const requiresSession = route.auth !== false;
     let sessionServices;
@@ -231,7 +212,7 @@ const executeRouteWithMiddleware = async (services, matchedRoute, http, options)
                 channel,
             });
         };
-        result = await runPikkuFunc(meta.pikkuFuncName, {
+        result = await runPikkuFunc(PikkuWiringTypes.http, `${meta.method}:${meta.route}`, meta.pikkuFuncName, {
             getAllServices,
             session,
             data,
@@ -250,8 +231,16 @@ const executeRouteWithMiddleware = async (services, matchedRoute, http, options)
         // TODO: Evaluate if the response stream should be explicitly ended.
         // http?.response?.end()
     };
+    // Get function config for middleware and tags
+    const funcConfig = pikkuState('function', 'functions').get(meta.pikkuFuncName);
     // Execute middleware, then run the main logic
-    await runMiddleware({ ...singletonServices, userSession }, { http }, addMiddlewareForTags(middleware, route.tags), runMain);
+    await runMiddleware({ ...singletonServices, userSession }, { http }, combineMiddleware(PikkuWiringTypes.http, `${meta.method}:${meta.route}`, {
+        httpMiddleware,
+        wiringMiddleware: middleware,
+        wiringTags: route.tags,
+        funcMiddleware: funcConfig?.middleware,
+        funcTags: funcConfig?.tags,
+    }), runMain);
     return sessionServices ? { result, sessionServices } : { result };
 };
 /**
@@ -343,7 +332,8 @@ export const fetchData = async (request, response, { singletonServices, createSe
         }, ignoreMiddleware
             ? {
                 ...matchedRoute,
-                middleware: [],
+                middleware: undefined,
+                httpMiddleware: undefined,
             }
             : matchedRoute, http, { coerceDataFromSchema }));
         return result;

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

@@ -46,8 +46,8 @@ export type CoreHTTPFunction = {
 /**
  * Represents a http interaction within Pikku, including a request and response.
  */
-export interface PikkuHTTP {
-    request?: PikkuHTTPRequest;
+export interface PikkuHTTP<In = unknown> {
+    request?: PikkuHTTPRequest<In>;
     response?: PikkuHTTPResponse;
 }
 /**
@@ -147,7 +147,7 @@ export type HTTPWiringMeta = {
     tags?: string[];
     sse?: true;
 };
-export type HTTPWiringsMeta = Array<HTTPWiringMeta>;
+export type HTTPWiringsMeta = Record<HTTPMethod, Record<string, HTTPWiringMeta>>;
 export type HTTPFunctionsMeta = Array<{
     name: string;
     inputs: string[] | null;
@@ -169,12 +169,12 @@ export interface PikkuHTTPRequest<In = unknown> {
     setParams(params: Record<string, string | string[] | undefined>): void;
     query(): PikkuQuery;
 }
-export interface PikkuHTTPResponse {
+export interface PikkuHTTPResponse<Out = unknown> {
     status(code: number): this;
     cookie(name: string, value: string | null, options: SerializeOptions): this;
     header(name: string, value: string | string[]): this;
     arrayBuffer(data: ArrayBuffer | ArrayBufferView | Blob | string | FormData | URLSearchParams | ReadableStream): this;
-    json(data: unknown): this;
+    json(data: Out): this;
     redirect(location: string, status?: number): this;
     close?: () => void;
     setMode?: (mode: 'stream') => void;

package/dist/wirings/http/pikku-fetch-http-request.js

@@ -48,6 +48,9 @@ export class PikkuFetchHTTPRequest {
      * @returns An object containing the cookies.
      */
     cookie(cookieName) {
+        if (this.#cookies?.[cookieName]) {
+            return this.#cookies[cookieName];
+        }
         const cookieHeader = this.header('cookie');
         this.#cookies = cookieHeader ? parseCookie(cookieHeader) : {};
         return this.#cookies[cookieName] || null;

package/dist/wirings/http/routers/http-router.d.ts

@@ -0,0 +1,12 @@
+import { CorePikkuMiddleware } from '../../../types/core.types.js';
+import { HTTPMethod } from '../http.types.js';
+import { PathToRegexRouter } from './path-to-regex.js';
+export type MatchResult = {
+    route: string;
+    params: Record<string, any>;
+    middleware?: CorePikkuMiddleware[];
+} | null;
+export interface Router {
+    match(method: HTTPMethod, path: string): MatchResult;
+}
+export declare const httpRouter: PathToRegexRouter;

package/dist/wirings/http/routers/http-router.js

@@ -0,0 +1,2 @@
+import { PathToRegexRouter } from './path-to-regex.js';
+export const httpRouter = new PathToRegexRouter();

package/dist/wirings/http/routers/path-to-regex.d.ts

@@ -0,0 +1,10 @@
+import { MatchResult, Router } from './http-router.js';
+import { HTTPMethod } from '../http.types.js';
+export declare class PathToRegexRouter implements Router {
+    private compiledRoutes;
+    private staticRoutes;
+    private precompiledMiddleware;
+    private isInitialized;
+    initialize(): void;
+    match(method: HTTPMethod, path: string): MatchResult;
+}

package/dist/wirings/http/routers/path-to-regex.js

@@ -0,0 +1,118 @@
+import { match } from 'path-to-regexp';
+import { pikkuState } from '../../../pikku-state.js';
+export class PathToRegexRouter {
+    compiledRoutes = new Map();
+    staticRoutes = new Map();
+    precompiledMiddleware = new Map();
+    isInitialized = false;
+    initialize() {
+        const routes = pikkuState('http', 'routes');
+        const channelRoutes = pikkuState('channel', 'channels');
+        const middlewareMap = pikkuState('http', 'middleware');
+        // Precompile middleware lookups
+        for (const [middlewareRoute, middlewareArray] of middlewareMap.entries()) {
+            this.precompiledMiddleware.set(middlewareRoute, middlewareArray);
+        }
+        // Helper function to compile routes for a given method
+        const compileRoutesForMethod = (method, routeEntries) => {
+            const methodCompiledRoutes = this.compiledRoutes.get(method) || new Map();
+            const methodStaticRoutes = this.staticRoutes.get(method) || new Map();
+            for (const [routePath] of routeEntries) {
+                // Normalize route path - ensure it starts with /
+                const normalizedRoutePath = routePath.startsWith('/')
+                    ? routePath
+                    : `/${routePath}`;
+                // Check if route is static (no parameters or wildcards)
+                const isStaticRoute = !/\*|:/.test(normalizedRoutePath);
+                // Precompute middleware for this route
+                const routeMiddleware = [];
+                // Add global middleware (*)
+                const globalMiddleware = this.precompiledMiddleware.get('*');
+                if (globalMiddleware) {
+                    routeMiddleware.push(...globalMiddleware);
+                }
+                // Add route-specific middleware
+                for (const [middlewareRoute, middlewareArray,] of this.precompiledMiddleware.entries()) {
+                    if (middlewareRoute !== '*') {
+                        // Use regex test for pattern matching
+                        try {
+                            if (new RegExp(middlewareRoute).test(normalizedRoutePath)) {
+                                routeMiddleware.push(...middlewareArray);
+                            }
+                        }
+                        catch {
+                            // If regex is invalid, do exact match
+                            if (middlewareRoute === normalizedRoutePath) {
+                                routeMiddleware.push(...middlewareArray);
+                            }
+                        }
+                    }
+                }
+                if (isStaticRoute) {
+                    // Store static routes for O(1) lookup
+                    methodStaticRoutes.set(normalizedRoutePath, {
+                        route: routePath, // Keep the original route path for lookup in pikkuState
+                        middleware: routeMiddleware,
+                    });
+                }
+                else {
+                    // Compile dynamic routes with path-to-regexp
+                    const matcher = match(normalizedRoutePath, {
+                        decode: decodeURIComponent,
+                    });
+                    methodCompiledRoutes.set(normalizedRoutePath, {
+                        matcher,
+                        route: routePath, // Keep the original route path for lookup in pikkuState
+                        middleware: routeMiddleware,
+                    });
+                }
+            }
+            this.compiledRoutes.set(method, methodCompiledRoutes);
+            this.staticRoutes.set(method, methodStaticRoutes);
+        };
+        // Precompile all HTTP route matchers
+        for (const [method, routeMap] of routes.entries()) {
+            compileRoutesForMethod(method, routeMap.entries());
+        }
+        // Precompile all channel route matchers (treating them as GET routes for WebSocket upgrades)
+        const channelRoutesArray = Array.from(channelRoutes.entries()).map(([, channel]) => [channel.route, channel]);
+        compileRoutesForMethod('get', channelRoutesArray);
+        this.isInitialized = true;
+    }
+    match(method, path) {
+        if (!this.isInitialized) {
+            this.initialize();
+        }
+        // Normalize path - ensure it starts with /
+        const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+        // First, try static routes for O(1) lookup
+        const methodStaticRoutes = this.staticRoutes.get(method);
+        if (methodStaticRoutes) {
+            const staticRoute = methodStaticRoutes.get(normalizedPath);
+            if (staticRoute) {
+                return {
+                    route: staticRoute.route,
+                    params: {},
+                    middleware: staticRoute.middleware,
+                };
+            }
+        }
+        // If no static route matched, try dynamic routes
+        const methodRoutes = this.compiledRoutes.get(method);
+        if (!methodRoutes) {
+            return null;
+        }
+        // Try each compiled route for this method
+        for (const [, compiledRoute] of methodRoutes.entries()) {
+            const result = compiledRoute.matcher(normalizedPath);
+            if (result) {
+                return {
+                    route: compiledRoute.route,
+                    params: result.params,
+                    middleware: compiledRoute.middleware,
+                };
+            }
+        }
+        return null;
+    }
+}

package/dist/wirings/mcp/mcp-runner.d.ts

@@ -1,4 +1,4 @@
-import type { CoreServices, CoreSingletonServices, CoreUserSession, CreateSessionServices } from '../../types/core.types.js';
+import { type CoreServices, type CoreSingletonServices, type CoreUserSession, type CreateSessionServices } from '../../types/core.types.js';
 import type { CoreMCPResource, CoreMCPTool, CoreMCPPrompt, JsonRpcRequest, JsonRpcResponse, JsonRpcErrorResponse, PikkuMCP } from './mcp.types.js';
 import type { CorePikkuFunctionSessionless } from '../../function/functions.types.js';
 export declare class MCPError extends Error {

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

@@ -1,10 +1,11 @@
+import { PikkuWiringTypes, } from '../../types/core.types.js';
 import { getErrorResponse } from '../../errors/error-handler.js';
 import { closeSessionServices } from '../../utils.js';
 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';
+import { combineMiddleware, runMiddleware } from '../../middleware-runner.js';
 export class MCPError extends Error {
     error;
     constructor(error) {
@@ -132,15 +133,20 @@ async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncName, { sessio
                     mcp: interaction,
                 });
             };
-            result = await runPikkuFunc(pikkuFuncName, {
+            result = await runPikkuFunc(PikkuWiringTypes.mcp, `${type}:${name}`, pikkuFuncName, {
                 getAllServices,
                 session,
                 data: request.params,
                 tags: mcp.tags,
             });
         };
-        // Get middleware for tags and run middleware
-        await runMiddleware(singletonServices, { mcp: interaction }, addMiddlewareForTags(mcp.middleware, mcp.tags), runMain);
+        const funcConfig = pikkuState('function', 'functions').get(pikkuFuncName);
+        await runMiddleware(singletonServices, { mcp: interaction }, combineMiddleware(PikkuWiringTypes.mcp, `${type}:${name}`, {
+            wiringMiddleware: mcp.middleware,
+            wiringTags: mcp.tags,
+            funcMiddleware: funcConfig?.middleware,
+            funcTags: funcConfig?.tags,
+        }), runMain);
         return {
             id: request.id,
             result,

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

@@ -1,7 +1,8 @@
 import { getErrorResponse, PikkuError } from '../../errors/error-handler.js';
 import { pikkuState } from '../../pikku-state.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
-import { addMiddlewareForTags, runMiddleware } from '../../middleware-runner.js';
+import { PikkuWiringTypes, } from '../../types/core.types.js';
+import { combineMiddleware, runMiddleware } from '../../middleware-runner.js';
 /**
  * Error class for queue processor not found
  */
@@ -106,15 +107,22 @@ export async function runQueueJob({ singletonServices, createSessionServices, jo
                     : {}),
             });
             // Execute the pikku function with the job data
-            result = await runPikkuFunc(processorMeta.pikkuFuncName, {
+            result = await runPikkuFunc(PikkuWiringTypes.queue, job.queueName, processorMeta.pikkuFuncName, {
                 getAllServices,
                 data: job.data,
                 tags: queueWorker.tags,
             });
             logger.debug(`Successfully processed job ${job.id} in queue ${job.queueName}`);
         };
+        // Get function config for middleware and tags
+        const funcConfig = pikkuState('function', 'functions').get(processorMeta.pikkuFuncName);
         // Get middleware for tags and combine with queue-specific middleware
-        await runMiddleware(singletonServices, { queue }, addMiddlewareForTags(queueWorker.middleware, queueWorker.tags), runMain);
+        await runMiddleware(singletonServices, { queue }, combineMiddleware(PikkuWiringTypes.queue, `${job.queueName}:${job.id}`, {
+            wiringMiddleware: queueWorker.middleware,
+            wiringTags: queueWorker.tags,
+            funcMiddleware: funcConfig?.middleware,
+            funcTags: funcConfig?.tags,
+        }), runMain);
         return result;
     }
     catch (error) {

package/dist/wirings/rpc/rpc-runner.d.ts

@@ -13,13 +13,12 @@ export declare class PikkuRPCService {
         };
         logger: import("../../index.js").Logger;
         variables: import("../../services/variables-service.js").VariablesService;
-        http?: import("../http/http.types.js").PikkuHTTP | undefined;
+        http?: import("../http/http.types.js").PikkuHTTP<unknown> | undefined;
         mcp?: import("../mcp/mcp.types.js").PikkuMCP;
         rpc?: import("./rpc-types.js").PikkuRPC;
         channel?: import("../channel/channel.types.js").PikkuChannel<unknown, unknown>;
         scheduledTask?: import("../scheduler/scheduler.types.js").PikkuScheduledTask | undefined;
         queue?: import("../queue/queue.types.js").PikkuQueue | undefined;
-        s?: any;
         userSession?: import("../../index.js").UserSessionService<import("../../types/core.types.js").CoreUserSession> | undefined;
     };
 }

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

@@ -1,3 +1,4 @@
+import { PikkuWiringTypes } from '../../types/core.types.js';
 import { runPikkuFunc } from '../../function/function-runner.js';
 import { pikkuState } from '../../pikku-state.js';
 import { ForbiddenError } from '../../errors/errors.js';
@@ -31,7 +32,7 @@ class ContextAwareRPCService {
         const session = await this.services.userSession?.get();
         const rpcDepth = this.services.rpc?.depth || 0;
         const pikkuFuncName = getPikkuFunctionName(funcName);
-        return runPikkuFunc(pikkuFuncName, {
+        return runPikkuFunc(PikkuWiringTypes.rpc, pikkuFuncName, pikkuFuncName, {
             getAllServices: () => {
                 this.services.rpc = this.services.rpc
                     ? {

package/dist/wirings/scheduler/scheduler-runner.d.ts

@@ -1,4 +1,4 @@
-import type { CoreServices, CoreSingletonServices, CoreUserSession, CreateSessionServices } from '../../types/core.types.js';
+import { type CoreServices, type CoreSingletonServices, type CoreUserSession, type CreateSessionServices } from '../../types/core.types.js';
 import type { CoreScheduledTask } from './scheduler.types.js';
 import type { CorePikkuFunctionSessionless } from '../../function/functions.types.js';
 export type RunScheduledTasksParams = {