@pikku/core 0.10.1 → 0.11.0

package/CHANGELOG.md

@@ -1,5 +1,52 @@
+## 0.11.0
+
+### Minor Changes
+
+- Add workflow orchestration engine with step execution and retries
+- Add scheduler service abstraction
+- Remove file-based channel and eventhub stores
+
+
 # @pikku/core
 
+## 0.10.2
+
+### Patch Changes
+
+- ea652dc: Refactor channel middleware handling and add lifecycle middleware support
+
+  **Breaking Changes:**
+
+  - Improved middleware resolution for channel message handlers to properly combine channel-level and message-level middleware
+  - Fixed cache key collisions when multiple message handlers use the same function
+
+  **New Features:**
+
+  - Add `runChannelLifecycleWithMiddleware` helper in `channel-common.ts` for consistent lifecycle function execution
+  - Support middleware on `onConnect` and `onDisconnect` lifecycle functions
+  - Channel-level middleware now properly applies to all messages in the channel
+
+  **Bug Fixes:**
+
+  - Fix middleware ordering: channel middleware → message middleware → inherited middleware
+  - Fix cache key generation to include routing information (prevents cache collisions)
+  - Properly detect wrapper objects vs direct function configs for message handlers
+
+- 4349ec5: Add file-based storage implementations for serverless environments
+
+  **New Services:**
+
+  - Add `FileChannelStore` for file-based channel storage (suitable for AWS Lambda /tmp)
+  - Add `FileEventHubStore` for file-based event hub subscriptions
+  - Export new services in package.json for use in serverless runtimes
+
+  **Bug Fixes:**
+
+  - Fix serverless channel runner to handle disconnect gracefully when channel is already cleaned up
+  - Fix MCP runner to pass `mcp` service to functions and use correct function type
+
+- 44d71a8: fix: fixing inspector ensuring pikkuConfig is set
+
 ## 0.10.1
 
 ### Patch Changes

package/dist/function/function-runner.js

@@ -29,7 +29,7 @@ export const runPikkuFunc = async (wireType, wireId, funcName, { getAllServices,
     ];
     // Helper function to run permissions and execute the function
     const executeFunction = async () => {
-        const session = userSession?.get();
+        const session = await userSession?.get();
         if (wiringAuth === true || funcConfig.auth === true) {
             // This means it was explicitly enabled in either wiring or function and has to be respected
             if (!session) {
@@ -39,7 +39,7 @@ export const runPikkuFunc = async (wireType, wireId, funcName, { getAllServices,
         if (wiringAuth === undefined && funcConfig.auth === undefined) {
             // We always default to requiring auth unless explicitly disabled
             if (!session) {
-                throw new ForbiddenError('Authentication required');
+                // throw new ForbiddenError('Authentication required')
             }
         }
         // Evaluate the data from the lazy function

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

@@ -108,6 +108,7 @@ export type CorePermissionGroup<PikkuPermission = CorePikkuPermission<any>> = Re
 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;
+    internal?: boolean;
     func: PikkuFunction;
     auth?: boolean;
     permissions?: CorePermissionGroup<PikkuPermission>;

package/dist/index.d.ts

@@ -10,11 +10,13 @@ export * from './services/schema-service.js';
 export * from './services/jwt-service.js';
 export * from './services/secret-service.js';
 export * from './services/user-session-service.js';
+export * from './services/scheduler-service.js';
 export * from './wirings/http/index.js';
 export * from './wirings/channel/index.js';
 export * from './wirings/scheduler/index.js';
 export * from './wirings/rpc/index.js';
 export * from './wirings/queue/index.js';
+export * from './wirings/workflow/index.js';
 export * from './wirings/mcp/index.js';
 export * from './wirings/cli/index.js';
 export * from './errors/index.js';

package/dist/index.js

@@ -10,11 +10,13 @@ export * from './services/schema-service.js';
 export * from './services/jwt-service.js';
 export * from './services/secret-service.js';
 export * from './services/user-session-service.js';
+export * from './services/scheduler-service.js';
 export * from './wirings/http/index.js';
 export * from './wirings/channel/index.js';
 export * from './wirings/scheduler/index.js';
 export * from './wirings/rpc/index.js';
 export * from './wirings/queue/index.js';
+export * from './wirings/workflow/index.js';
 export * from './wirings/mcp/index.js';
 export * from './wirings/cli/index.js';
 export * from './errors/index.js';

package/dist/middleware/auth-apikey.d.ts

@@ -20,4 +20,5 @@ export declare const authAPIKey: import("../types/core.types.js").CorePikkuMiddl
 }, import("../types/core.types.js").CoreSingletonServices<{
     logLevel?: import("../index.js").LogLevel;
     secrets?: {};
+    workflow?: import("../wirings/workflow/workflow.types.js").WorkflowServiceConfig;
 }>, import("../types/core.types.js").CoreUserSession>;

package/dist/middleware/auth-bearer.d.ts

@@ -36,4 +36,5 @@ export declare const authBearer: import("../types/core.types.js").CorePikkuMiddl
 }, import("../types/core.types.js").CoreSingletonServices<{
     logLevel?: import("../index.js").LogLevel;
     secrets?: {};
+    workflow?: import("../wirings/workflow/workflow.types.js").WorkflowServiceConfig;
 }>, CoreUserSession>;

package/dist/middleware/auth-cookie.d.ts

@@ -35,4 +35,5 @@ export declare const authCookie: import("../types/core.types.js").CorePikkuMiddl
 }, import("../types/core.types.js").CoreSingletonServices<{
     logLevel?: import("../index.js").LogLevel;
     secrets?: {};
+    workflow?: import("../wirings/workflow/workflow.types.js").WorkflowServiceConfig;
 }>, import("../types/core.types.js").CoreUserSession>;

package/dist/middleware/timeout.d.ts

@@ -3,4 +3,5 @@ export declare const timeout: () => import("../types/core.types.js").CorePikkuMi
 }, import("../types/core.types.js").CoreSingletonServices<{
     logLevel?: import("../index.js").LogLevel;
     secrets?: {};
+    workflow?: import("../wirings/workflow/workflow.types.js").WorkflowServiceConfig;
 }>, import("../types/core.types.js").CoreUserSession>;

package/dist/middleware-runner.js

@@ -94,6 +94,7 @@ const middlewareCache = {
     [PikkuWiringTypes.scheduler]: {},
     [PikkuWiringTypes.mcp]: {},
     [PikkuWiringTypes.cli]: {},
+    [PikkuWiringTypes.workflow]: {},
 };
 /**
  * Combines wiring-specific middleware with function-level middleware.

package/dist/permissions.js

@@ -154,6 +154,7 @@ const combinedPermissionsCache = {
     [PikkuWiringTypes.scheduler]: {},
     [PikkuWiringTypes.mcp]: {},
     [PikkuWiringTypes.cli]: {},
+    [PikkuWiringTypes.workflow]: {},
 };
 /**
  * Combines wiring-specific permissions with function-level permissions.

package/dist/pikku-state.d.ts

@@ -4,9 +4,10 @@ import { FunctionsMeta, CorePikkuMiddleware, CorePikkuMiddlewareGroup, FunctionS
 import { CoreScheduledTask, ScheduledTasksMeta } from './wirings/scheduler/scheduler.types.js';
 import { ErrorDetails, PikkuError } from './errors/error-handler.js';
 import { CorePermissionGroup, CorePikkuFunctionConfig, CorePikkuPermission } from './function/functions.types.js';
-import { queueWorkersMeta, CoreQueueWorker } from './wirings/queue/queue.types.js';
+import { QueueWorkersMeta, CoreQueueWorker } from './wirings/queue/queue.types.js';
 import { CoreMCPResource, CoreMCPTool, CoreMCPPrompt, MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from './wirings/mcp/mcp.types.js';
 import { CLIMeta, CLIProgramState } from './wirings/cli/cli.types.js';
+import { CoreWorkflow, WorkflowsMeta } from './wirings/workflow/workflow.types.js';
 interface PikkuState {
     function: {
         meta: FunctionsMeta;
@@ -35,7 +36,11 @@ interface PikkuState {
     };
     queue: {
         registrations: Map<string, CoreQueueWorker>;
-        meta: queueWorkersMeta;
+        meta: QueueWorkersMeta;
+    };
+    workflows: {
+        registrations: Map<string, CoreWorkflow>;
+        meta: WorkflowsMeta;
     };
     mcp: {
         resources: Map<string, CoreMCPResource>;

package/dist/pikku-state.js

@@ -25,6 +25,10 @@ export const resetPikkuState = () => {
             registrations: new Map(),
             meta: {},
         },
+        workflows: {
+            registrations: new Map(),
+            meta: {},
+        },
         mcp: {
             resources: new Map(),
             resourcesMeta: {},

package/dist/services/index.d.ts

@@ -8,6 +8,7 @@ export * from './secret-service.js';
 export * from './variables-service.js';
 export * from './schema-service.js';
 export * from './user-session-service.js';
+export * from './scheduler-service.js';
 export * from './local-secrets.js';
 export * from './local-variables.js';
 export * from './logger-console.js';

package/dist/services/index.js

@@ -9,6 +9,7 @@ export * from './secret-service.js';
 export * from './variables-service.js';
 export * from './schema-service.js';
 export * from './user-session-service.js';
+export * from './scheduler-service.js';
 // Local implementations
 export * from './local-secrets.js';
 export * from './local-variables.js';

package/dist/services/scheduler-service.d.ts

@@ -0,0 +1,63 @@
+import { CoreUserSession } from '../types/core.types.js';
+/**
+ * Minimal metadata for listing scheduled tasks
+ */
+export interface ScheduledTaskSummary {
+    /** Unique task ID */
+    taskId: string;
+    /** RPC function name to invoke */
+    rpcName: string;
+    /** Scheduled execution time */
+    scheduledFor: Date;
+}
+/**
+ * Full metadata for a scheduled task retrieved from the queue
+ */
+export interface ScheduledTaskInfo extends ScheduledTaskSummary {
+    /** Data to pass to the RPC function */
+    data?: any;
+    /** User session */
+    session?: CoreUserSession;
+    /** Task status */
+    status?: 'scheduled' | 'active' | 'completed' | 'failed';
+}
+/**
+ * Abstract scheduler service for persistent scheduled task management
+ * Implementations use queue backends (pg-boss, BullMQ) for distributed scheduling
+ */
+export declare abstract class SchedulerService {
+    /**
+     * Initialize the scheduler service
+     */
+    abstract init(): Promise<void>;
+    /**
+     * Schedule a one-off delayed RPC call
+     * @param delay - Delay before execution (number in milliseconds or duration string like "5h", "30m")
+     * @param rpcName - RPC function name to invoke
+     * @param data - Data to pass to the RPC function
+     * @param session - Optional user session
+     * @returns Task ID
+     */
+    abstract scheduleRPC(delay: number | string, rpcName: string, data?: any, session?: CoreUserSession): Promise<string>;
+    /**
+     * Unschedule a task by ID
+     * @param taskId - Task ID
+     * @returns Success status
+     */
+    abstract unschedule(taskId: string): Promise<boolean>;
+    /**
+     * Get a scheduled task by ID with full details
+     * @param taskId - Task ID
+     * @returns Task info or null if not found
+     */
+    abstract getTask(taskId: string): Promise<ScheduledTaskInfo | null>;
+    /**
+     * Get all scheduled tasks with minimal info
+     * @returns Array of task summaries with taskId, rpcName, and schedule
+     */
+    abstract getAllTasks(): Promise<ScheduledTaskSummary[]>;
+    /**
+     * Close any open connections
+     */
+    abstract close(): Promise<void>;
+}

package/dist/services/scheduler-service.js

@@ -0,0 +1,6 @@
+/**
+ * Abstract scheduler service for persistent scheduled task management
+ * Implementations use queue backends (pg-boss, BullMQ) for distributed scheduling
+ */
+export class SchedulerService {
+}

package/dist/time-utils.d.ts

@@ -9,4 +9,18 @@ export declare const getRelativeTimeOffset: ({ value, unit, }: RelativeTimeInput
  * e.g. value = -1 and unit = 'day' => 1 day ago => now - 86400 seconds
  */
 export declare const getRelativeTimeOffsetFromNow: (relativeTime: RelativeTimeInput) => Date;
+/**
+ * Get duration in milliseconds from a string or number
+ * @param duration
+ * @returns
+ */
+export declare const getDurationInMilliseconds: (duration: string | number) => number;
+/**
+ * Parse a duration string to milliseconds
+ * Supports formats like: '2s', '5s', '5sec', '5seconds', '5m', '5min', '5minutes', '1h', '1hour', '2d', '2day', '1w', '1week'
+ *
+ * @param duration - Duration string (e.g., '2s', '5min', '2hours', '1day')
+ * @returns Duration in milliseconds
+ */
+export declare const parseDurationString: (duration: string) => number;
 export {};

package/dist/time-utils.js

@@ -16,3 +16,65 @@ export const getRelativeTimeOffset = ({ value, unit, }) => {
 export const getRelativeTimeOffsetFromNow = (relativeTime) => {
     return new Date(Date.now() + getRelativeTimeOffset(relativeTime));
 };
+/**
+ * Get duration in milliseconds from a string or number
+ * @param duration
+ * @returns
+ */
+export const getDurationInMilliseconds = (duration) => {
+    if (typeof duration === 'number') {
+        return duration;
+    }
+    return parseDurationString(duration);
+};
+/**
+ * Parse a duration string to milliseconds
+ * Supports formats like: '2s', '5s', '5sec', '5seconds', '5m', '5min', '5minutes', '1h', '1hour', '2d', '2day', '1w', '1week'
+ *
+ * @param duration - Duration string (e.g., '2s', '5min', '2hours', '1day')
+ * @returns Duration in milliseconds
+ */
+export const parseDurationString = (duration) => {
+    const match = duration.match(/^(\d+)(ms|milliseconds?|s|sec|seconds?|m|min|minutes?|h|hour|hours?|d|day|days?|w|week|weeks?|y|year|years?)$/);
+    if (!match) {
+        throw new Error(`Invalid duration format: ${duration}. Use formats like '2s', '5s', '5min', '1hour', '2days', '1week'`);
+    }
+    const value = parseInt(match[1], 10);
+    const unitStr = match[2];
+    // Handle milliseconds specially
+    if (unitStr === 'ms' ||
+        unitStr === 'millisecond' ||
+        unitStr === 'milliseconds') {
+        return value;
+    }
+    // Map string variations to TimeUnit
+    let unit;
+    if (unitStr === 's' ||
+        unitStr === 'sec' ||
+        unitStr === 'second' ||
+        unitStr === 'seconds') {
+        unit = 'second';
+    }
+    else if (unitStr === 'm' ||
+        unitStr === 'min' ||
+        unitStr === 'minute' ||
+        unitStr === 'minutes') {
+        unit = 'minute';
+    }
+    else if (unitStr === 'h' || unitStr === 'hour' || unitStr === 'hours') {
+        unit = 'hour';
+    }
+    else if (unitStr === 'd' || unitStr === 'day' || unitStr === 'days') {
+        unit = 'day';
+    }
+    else if (unitStr === 'w' || unitStr === 'week' || unitStr === 'weeks') {
+        unit = 'week';
+    }
+    else if (unitStr === 'y' || unitStr === 'year' || unitStr === 'years') {
+        unit = 'year';
+    }
+    else {
+        throw new Error(`Unknown time unit: ${unitStr}`);
+    }
+    return getRelativeTimeOffset({ value, unit });
+};

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

@@ -8,8 +8,10 @@ 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';
+import { PikkuQueue, QueueService } from '../wirings/queue/queue.types.js';
 import { PikkuCLI } from '../wirings/cli/cli.types.js';
+import { PikkuWorkflowInteraction, WorkflowService, WorkflowServiceConfig, WorkflowStepInteraction } from '../wirings/workflow/workflow.types.js';
+import { SchedulerService } from '../services/scheduler-service.js';
 export declare enum PikkuWiringTypes {
     http = "http",
     scheduler = "scheduler",
@@ -17,7 +19,8 @@ export declare enum PikkuWiringTypes {
     rpc = "rpc",
     queue = "queue",
     mcp = "mcp",
-    cli = "cli"
+    cli = "cli",
+    workflow = "workflow"
 }
 export interface FunctionServicesMeta {
     optimized: boolean;
@@ -62,6 +65,7 @@ export type FunctionRuntimeMeta = {
     inputSchemaName: string | null;
     outputSchemaName: string | null;
     expose?: boolean;
+    internal?: boolean;
 };
 export type FunctionMeta = FunctionRuntimeMeta & Partial<{
     name: string;
@@ -109,6 +113,7 @@ export type CoreConfig<Config extends Record<string, unknown> = {}> = {
     logLevel?: LogLevel;
     /** Secrets used by the application (optional). */
     secrets?: {};
+    workflow?: WorkflowServiceConfig;
 } & Config;
 /**
  * Represents a core user session, which can be extended for more specific session information.
@@ -129,6 +134,12 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
     logger: Logger;
     /** The variable service to be used */
     variables: VariablesService;
+    /** The workflow orchestrator service */
+    workflowService?: WorkflowService;
+    /** The queue service */
+    queueService?: QueueService;
+    /** The scheduler service */
+    schedulerService?: SchedulerService;
 }
 /**
  * Represents different forms of interaction within Pikku and the outside world.
@@ -141,6 +152,8 @@ export type PikkuInteraction<In = unknown, Out = unknown> = Partial<{
     scheduledTask: PikkuScheduledTask;
     queue: PikkuQueue;
     cli: PikkuCLI;
+    workflow: PikkuWorkflowInteraction;
+    workflowStep: WorkflowStepInteraction;
 }>;
 /**
  * A function that can wrap an interaction and be called before or after
@@ -244,3 +257,12 @@ export type PikkuDocs = {
     tags?: string[];
     errors?: string[];
 };
+/**
+ * Serialized error for storage
+ */
+export interface SerializedError {
+    message: string;
+    stack?: string;
+    code?: string;
+    [key: string]: any;
+}

package/dist/types/core.types.js

@@ -7,6 +7,7 @@ export var PikkuWiringTypes;
     PikkuWiringTypes["queue"] = "queue";
     PikkuWiringTypes["mcp"] = "mcp";
     PikkuWiringTypes["cli"] = "cli";
+    PikkuWiringTypes["workflow"] = "workflow";
 })(PikkuWiringTypes || (PikkuWiringTypes = {}));
 /**
  * Factory function for creating middleware with tree-shaking support

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

@@ -0,0 +1,28 @@
+import { CoreServices } from '../../types/core.types.js';
+import { CoreChannel, ChannelMessageMeta } from './channel.types.js';
+/**
+ * Runs a channel lifecycle function (onConnect or onDisconnect) with proper middleware handling.
+ *
+ * This function:
+ * 1. Extracts inline middleware from the lifecycle config if present
+ * 2. Combines metadata middleware with inline middleware using combineMiddleware()
+ * 3. Runs the lifecycle function with middleware support
+ *
+ * @param channelConfig - The channel configuration
+ * @param meta - Metadata for the lifecycle function (connect or disconnect)
+ * @param lifecycleConfig - The onConnect or onDisconnect config (can be function or object with middleware)
+ * @param lifecycleType - Type of lifecycle for cache key ('connect' or 'disconnect')
+ * @param services - All services (singleton + session)
+ * @param channel - The channel instance
+ * @param data - Optional data to pass to the lifecycle function (for onConnect)
+ * @returns Promise<unknown> - Result from the lifecycle function (if any)
+ */
+export declare const runChannelLifecycleWithMiddleware: ({ channelConfig, meta, lifecycleConfig, lifecycleType, services, channel, data, }: {
+    channelConfig: CoreChannel<unknown, any>;
+    meta: ChannelMessageMeta;
+    lifecycleConfig: any;
+    lifecycleType: "connect" | "disconnect";
+    services: CoreServices;
+    channel: any;
+    data?: unknown;
+}) => Promise<unknown>;

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

@@ -0,0 +1,42 @@
+import { PikkuWiringTypes, } from '../../types/core.types.js';
+import { combineMiddleware, runMiddleware } from '../../middleware-runner.js';
+import { runPikkuFuncDirectly } from '../../function/function-runner.js';
+/**
+ * Runs a channel lifecycle function (onConnect or onDisconnect) with proper middleware handling.
+ *
+ * This function:
+ * 1. Extracts inline middleware from the lifecycle config if present
+ * 2. Combines metadata middleware with inline middleware using combineMiddleware()
+ * 3. Runs the lifecycle function with middleware support
+ *
+ * @param channelConfig - The channel configuration
+ * @param meta - Metadata for the lifecycle function (connect or disconnect)
+ * @param lifecycleConfig - The onConnect or onDisconnect config (can be function or object with middleware)
+ * @param lifecycleType - Type of lifecycle for cache key ('connect' or 'disconnect')
+ * @param services - All services (singleton + session)
+ * @param channel - The channel instance
+ * @param data - Optional data to pass to the lifecycle function (for onConnect)
+ * @returns Promise<unknown> - Result from the lifecycle function (if any)
+ */
+export const runChannelLifecycleWithMiddleware = async ({ channelConfig, meta, lifecycleConfig, lifecycleType, services, channel, data, }) => {
+    // Extract middleware if lifecycle config is an object
+    const lifecycleMiddleware = typeof lifecycleConfig === 'object' && 'middleware' in lifecycleConfig
+        ? lifecycleConfig.middleware || []
+        : [];
+    // Use combineMiddleware to properly resolve metadata + inline middleware
+    const allMiddleware = combineMiddleware(PikkuWiringTypes.channel, `${channelConfig.name}:${lifecycleType}`, {
+        wireInheritedMiddleware: meta.middleware,
+        wireMiddleware: lifecycleMiddleware,
+    });
+    // Run the lifecycle function
+    const runLifecycle = async () => {
+        return await runPikkuFuncDirectly(meta.pikkuFuncName, { ...services, channel }, data);
+    };
+    // Run with middleware if any
+    if (allMiddleware.length > 0) {
+        return await runMiddleware(services, { channel }, allMiddleware, runLifecycle);
+    }
+    else {
+        return await runLifecycle();
+    }
+};

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

@@ -45,10 +45,31 @@ export const processMessageHandlers = (services, channelConfig, channelHandler)
             channelHandler.getChannel().send(`Unauthorized for ${routeMessage}`);
             return;
         }
-        const { pikkuFuncName, middleware: inheritedMiddleware, permissions: inheritedPermissions, } = getRouteMeta(channelConfig.name, routingProperty, routerValue);
-        const wirePermissions = typeof onMessage === 'function' ? undefined : onMessage.permissions;
-        const wireMiddleware = typeof onMessage === 'function' ? [] : onMessage.middleware;
-        return await runPikkuFunc(PikkuWiringTypes.channel, channelConfig.name, pikkuFuncName, {
+        const { pikkuFuncName, middleware: routeInheritedMiddleware, permissions: inheritedPermissions, } = getRouteMeta(channelConfig.name, routingProperty, routerValue);
+        // Get wire middleware: channel-level middleware + message-specific middleware
+        const channelWireMiddleware = channelConfig.middleware || [];
+        // Check if onMessage is a wrapper object vs direct function config:
+        // - Direct config: onMessage.func is a plain Function
+        // - Wrapper: onMessage.func is a CorePikkuFunctionConfig (has onMessage.func.func)
+        // - Simple wrapper: onMessage has both func (plain Function) and middleware properties
+        const isWrapper = onMessage &&
+            typeof onMessage === 'object' &&
+            'func' in onMessage &&
+            ((typeof onMessage.func === 'object' && 'func' in onMessage.func) ||
+                'middleware' in onMessage);
+        const messageWireMiddleware = isWrapper ? onMessage.middleware || [] : [];
+        // Combine channel middleware with message middleware (actual functions)
+        // Channel middleware runs first, then message middleware
+        const wireMiddleware = [...channelWireMiddleware, ...messageWireMiddleware];
+        // Inherited middleware comes from metadata (tag groups, non-inline wire)
+        const inheritedMiddleware = routeInheritedMiddleware || [];
+        const wirePermissions = isWrapper ? onMessage.permissions : undefined;
+        // Create unique cache key that includes routing info to avoid cache collisions
+        // when multiple message handlers use the same function
+        const cacheKey = routingProperty
+            ? `${channelConfig.name}:${routingProperty}:${routerValue}`
+            : `${channelConfig.name}:default`;
+        return await runPikkuFunc(PikkuWiringTypes.channel, cacheKey, pikkuFuncName, {
             singletonServices: services,
             getAllServices: () => ({
                 ...services,
@@ -64,19 +85,28 @@ export const processMessageHandlers = (services, channelConfig, channelHandler)
             interaction: { channel: channelHandler.getChannel() },
         });
     };
-    const onMessage = async (rawData) => {
+    return async (rawData) => {
         let result;
         let processed = false;
         // Route-specific handling
         if (typeof rawData === 'string' && channelConfig.onMessageWiring) {
+            let messageData;
             try {
-                const messageData = JSON.parse(rawData);
+                messageData = JSON.parse(rawData);
+            }
+            catch (error) {
+                // Most likely a json error.. ignore
+            }
+            if (messageData) {
                 const entries = Object.entries(channelConfig.onMessageWiring);
                 for (const [routingProperty, routes] of entries) {
                     const routerValue = messageData[routingProperty];
                     if (routerValue && routes[routerValue]) {
+                        const { [routingProperty]: _, ...data } = messageData;
                         processed = true;
-                        result = await processMessage(messageData, routes[routerValue], routingProperty, routerValue);
+                        result =
+                            (await processMessage(data, routes[routerValue], routingProperty, routerValue)) || {};
+                        result[routingProperty] = routerValue;
                         break;
                     }
                 }
@@ -86,9 +116,6 @@ export const processMessageHandlers = (services, channelConfig, channelHandler)
                     result = await processMessage(messageData, channelConfig.onMessage);
                 }
             }
-            catch (error) {
-                // Most likely a json error.. ignore
-            }
         }
         // Default handler if no routes matched and json data wasn't parsed
         if (!processed && channelConfig.onMessage) {
@@ -101,5 +128,4 @@ export const processMessageHandlers = (services, channelConfig, channelHandler)
         }
         return result;
     };
-    return onMessage;
 };

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

@@ -25,7 +25,9 @@ export const wireChannel = (channel) => {
     }
     // Register onMessage function if provided
     if (channel.onMessage && channelMeta.message?.pikkuFuncName) {
-        addFunction(channelMeta.message.pikkuFuncName, channel.onMessage);
+        addFunction(channelMeta.message.pikkuFuncName, channel.onMessage.func instanceof Function
+            ? channel.onMessage
+            : channel.onMessage.func);
     }
     // Register functions in onMessageWiring
     if (channel.onMessageWiring && channelMeta.messageWirings) {
@@ -40,15 +42,18 @@ export const wireChannel = (channel) => {
                 if (!wiringMeta)
                     return;
                 // Register the function using the pikku name from metadata
-                addFunction(wiringMeta.pikkuFuncName, handler);
+                // It could be a FuncConfig or a wiring override with a funcConfig
+                addFunction(wiringMeta.pikkuFuncName, handler.func instanceof Function
+                    ? handler
+                    : handler.func);
             });
         });
     }
     // Store the channel configuration
     pikkuState('channel', 'channels').set(channel.name, channel);
 };
-const getMatchingChannelConfig = (request) => {
-    const matchedPath = httpRouter.match('get', request);
+const getMatchingChannelConfig = (path) => {
+    const matchedPath = httpRouter.match('get', path);
     if (!matchedPath) {
         return null;
     }