@pikku/core 0.7.8 → 0.8.1

package/dist/events/queue/validate-worker-config.js

@@ -0,0 +1,50 @@
+/**
+ * Validates worker configuration using a mapping table
+ * This provides a flexible, maintainable way to validate configurations
+ * across different queue implementations
+ *
+ * @param config - The worker configuration to validate
+ * @param configMapping - The mapping table defining supported/unsupported configurations
+ * @returns Validation result with applied, ignored, warnings, and fallbacks
+ */
+export function validateWorkerConfig(configMapping, config = {}) {
+    const applied = {};
+    const ignored = {};
+    const warnings = [];
+    const fallbacks = {};
+    // Process each configuration property
+    for (const [key, value] of Object.entries(config)) {
+        if (value === undefined)
+            continue;
+        const configKey = key;
+        // Check if it's a supported configuration
+        if (configKey in configMapping.supported) {
+            applied[configKey] = value;
+            continue;
+        }
+        // Check if it's a fallback configuration
+        if (configKey in configMapping.fallbacks) {
+            const fallbackMapping = configMapping.fallbacks[configKey];
+            applied[configKey] = value;
+            fallbacks[key] = fallbackMapping.fallbackValue;
+            warnings.push(`${key}: ${fallbackMapping.reason}. ${fallbackMapping.explanation}`);
+            continue;
+        }
+        // Check if it's an unsupported configuration
+        if (configKey in configMapping.unsupported) {
+            ignored[configKey] = value;
+            const mapping = configMapping.unsupported[configKey];
+            warnings.push(`${key}: ${mapping.reason}. ${mapping.explanation}`);
+            continue;
+        }
+        // Unknown configuration
+        ignored[configKey] = value;
+        warnings.push(`${key}: Unknown configuration option for this queue implementation`);
+    }
+    return {
+        applied,
+        ignored,
+        warnings,
+        fallbacks,
+    };
+}

package/dist/events/rpc/index.d.ts

@@ -0,0 +1,2 @@
+export { initialize } from './rpc-runner.js';
+export type { PikkuRPC, RPCMeta } from './rpc-types.js';

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

@@ -0,0 +1,25 @@
+import { CoreServices } from '../../types/core.types.js';
+type RPCServiceConfig = {
+    coerceDataFromSchema: boolean;
+};
+export declare class PikkuRPCService {
+    private config?;
+    initialize(config: RPCServiceConfig): void;
+    injectRPCService(coreServices: CoreServices, depth?: number): {
+        schema?: import("../../index.js").SchemaService;
+        config: {
+            logLevel?: import("../../index.js").LogLevel;
+            secrets?: {};
+        };
+        logger: import("../../index.js").Logger;
+        variables: import("../../services/variables-service.js").VariablesService;
+        http?: import("../http/http.types.js").PikkuHTTP;
+        mcp?: import("../mcp/mcp.types.js").PikkuMCP;
+        rpc?: import("./rpc-types.js").PikkuRPC;
+        userSession?: import("../../index.js").UserSessionService<import("../../types/core.types.js").CoreUserSession> | undefined;
+        channel?: import("../channel/channel.types.js").PikkuChannel<unknown, unknown>;
+    };
+}
+export declare const rpcService: PikkuRPCService;
+export declare const initialize: (config: RPCServiceConfig) => void;
+export {};

package/dist/{rpc → events/rpc}/rpc-runner.js

@@ -1,5 +1,5 @@
-import { runPikkuFunc } from '../function/function-runner.js';
-import { pikkuState } from '../pikku-state.js';
+import { runPikkuFunc } from '../../function/function-runner.js';
+import { pikkuState } from '../../pikku-state.js';
 const getRPCMeta = (rpcName) => {
     const rpc = pikkuState('rpc', 'meta');
     const rpcMeta = rpc[rpcName];

package/dist/events/scheduler/index.d.ts

@@ -0,0 +1,3 @@
+export * from './scheduler.types.js';
+export { runScheduledTask, addScheduledTask, getScheduledTasks, } from './scheduler-runner.js';
+export * from './log-schedulers.js';

package/dist/events/scheduler/index.js

@@ -0,0 +1,3 @@
+export * from './scheduler.types.js';
+export { runScheduledTask, addScheduledTask, getScheduledTasks, } from './scheduler-runner.js';
+export * from './log-schedulers.js';

package/dist/{scheduler → events/scheduler}/log-schedulers.d.ts

@@ -1,4 +1,4 @@
-import { Logger } from '../services/index.js';
+import { Logger } from '../../services/index.js';
 /**
  * Logs all the loaded scheduled tasks.
  * @param logger - A logger for logging information.

package/dist/{scheduler → events/scheduler}/log-schedulers.js

@@ -1,4 +1,4 @@
-import { pikkuState } from '../pikku-state.js';
+import { pikkuState } from '../../pikku-state.js';
 /**
  * Logs all the loaded scheduled tasks.
  * @param logger - A logger for logging information.

package/dist/{scheduler → events/scheduler}/scheduler-runner.d.ts

@@ -1,6 +1,6 @@
-import type { CoreServices, CoreSingletonServices, CoreUserSession, CreateSessionServices } from '../types/core.types.js';
+import type { CoreServices, CoreSingletonServices, CoreUserSession, CreateSessionServices } from '../../types/core.types.js';
 import type { CoreScheduledTask } from './scheduler.types.js';
-import type { CoreAPIFunctionSessionless } from '../function/functions.types.js';
+import type { CoreAPIFunctionSessionless } from '../../function/functions.types.js';
 export type RunScheduledTasksParams = {
     name: string;
     session?: CoreUserSession;
@@ -8,4 +8,5 @@ export type RunScheduledTasksParams = {
     createSessionServices?: CreateSessionServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
 };
 export declare const addScheduledTask: <APIFunction extends CoreAPIFunctionSessionless<void, void>>(scheduledTask: CoreScheduledTask<APIFunction>) => void;
-export declare function runScheduledTask<SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession>({ name, session, singletonServices, createSessionServices, }: RunScheduledTasksParams): Promise<void>;
+export declare function runScheduledTask({ name, session, singletonServices, createSessionServices, }: RunScheduledTasksParams): Promise<void>;
+export declare const getScheduledTasks: () => Map<string, CoreScheduledTask>;

package/dist/{scheduler → events/scheduler}/scheduler-runner.js

@@ -1,7 +1,7 @@
-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 { 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';
 export const addScheduledTask = (scheduledTask) => {
     const meta = pikkuState('scheduler', 'meta');
@@ -64,3 +64,6 @@ export async function runScheduledTask({ name, session, singletonServices, creat
         }
     }
 }
+export const getScheduledTasks = () => {
+    return pikkuState('scheduler', 'tasks');
+};

package/dist/{scheduler → events/scheduler}/scheduler.types.d.ts

@@ -1,5 +1,5 @@
-import { APIDocs, CoreUserSession } from '../types/core.types.js';
-import { CoreAPIFunctionSessionless } from '../function/functions.types.js';
+import { APIDocs, CoreUserSession } from '../../types/core.types.js';
+import { CoreAPIFunctionSessionless } from '../../function/functions.types.js';
 /**
  * Represents metadata for scheduled tasks, including title, schedule, and documentation.
  */
@@ -14,11 +14,10 @@ export type ScheduledTasksMeta<UserSession extends CoreUserSession = any> = Reco
 /**
  * Represents a core scheduled task.
  */
-export type CoreScheduledTask<APIFunction = CoreAPIFunctionSessionless<void, void>, UserSession extends CoreUserSession = CoreUserSession> = {
+export type CoreScheduledTask<APIFunction = CoreAPIFunctionSessionless<void, void>> = {
     name: string;
     schedule: string;
     func: APIFunction;
     docs?: APIDocs;
-    session?: UserSession;
     tags?: string[];
 };

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

@@ -1,11 +1,12 @@
-import { CoreServices, CoreUserSession } from '../types/core.types.js';
+import { CoreServices, CoreUserSession, PikkuFunctionMiddleware } from '../types/core.types.js';
 import { CorePermissionGroup, CorePikkuFunctionConfig } from './functions.types.js';
 export declare const addFunction: (funcName: string, funcConfig: CorePikkuFunctionConfig<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, coerceDataFromSchema, }: {
+export declare const runPikkuFunc: <In = any, Out = any>(funcName: string, { getAllServices, data, session, permissions: transportPermissions, middleware: transportMiddleware, coerceDataFromSchema, }: {
     getAllServices: () => Promise<CoreServices> | CoreServices;
     data: In;
     session?: CoreUserSession;
     permissions?: CorePermissionGroup;
+    middleware?: PikkuFunctionMiddleware[];
     coerceDataFromSchema?: boolean;
 }) => Promise<Out>;

package/dist/function/function-runner.js

@@ -1,43 +1,8 @@
 import { ForbiddenError } from '../errors/errors.js';
+import { runMiddleware } from '../middleware-runner.js';
 import { verifyPermissions } from '../permissions.js';
 import { pikkuState } from '../pikku-state.js';
 import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js';
-// Permission merging function
-function mergePermissions(logger, funcName, funcPermissions, transportPermissions) {
-    if (!funcPermissions && !transportPermissions) {
-        return undefined;
-    }
-    if (!funcPermissions) {
-        return transportPermissions;
-    }
-    if (!transportPermissions) {
-        return funcPermissions;
-    }
-    // Start with a copy of function permissions
-    const mergedPermissions = { ...funcPermissions };
-    // Merge in transport permissions
-    for (const [key, transportValue] of Object.entries(transportPermissions)) {
-        if (key in mergedPermissions) {
-            // For permission arrays, concatenate and deduplicate values
-            if (Array.isArray(mergedPermissions[key]) &&
-                Array.isArray(transportValue)) {
-                mergedPermissions[key] = [
-                    ...new Set([...mergedPermissions[key], ...transportValue]),
-                ];
-            }
-            // For other types, warn about conflict and use the more restrictive (transport-level) value
-            else {
-                logger.warn(`Permission conflict on key "${key}" for function "${funcName}". Using transport-level permission.`);
-                mergedPermissions[key] = transportValue;
-            }
-        }
-        else {
-            // If key doesn't exist in function permissions, add it
-            mergedPermissions[key] = transportValue;
-        }
-    }
-    return mergedPermissions;
-}
 export const addFunction = (funcName, funcConfig) => {
     pikkuState('function', 'functions').set(funcName, funcConfig);
 };
@@ -48,7 +13,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, coerceDataFromSchema, }) => {
+export const runPikkuFunc = async (funcName, { getAllServices, data, session, permissions: transportPermissions, middleware: transportMiddleware, coerceDataFromSchema, }) => {
     const funcConfig = pikkuState('function', 'functions').get(funcName);
     if (!funcConfig) {
         throw new Error(`Function not found: ${funcName}`);
@@ -70,11 +35,22 @@ export const runPikkuFunc = async (funcName, { getAllServices, data, session, pe
             coerceTopLevelDataFromSchema(schemaName, data);
         }
     }
-    // Execute permission checks
-    const mergedPermissions = mergePermissions(allServices.logger, funcName, funcConfig.permissions, transportPermissions);
-    const permissioned = await verifyPermissions(mergedPermissions, allServices, data, session);
+    let permissioned = true;
+    if (funcConfig.permissions) {
+        permissioned = await verifyPermissions(funcConfig.permissions, allServices, data, session);
+    }
+    if (!permissioned && transportPermissions) {
+        permissioned = await verifyPermissions(transportPermissions, allServices, data, session);
+    }
     if (permissioned === false) {
         throw new ForbiddenError('Permission denied');
     }
+    if (transportMiddleware || funcConfig.middleware) {
+        return (await runMiddleware(allServices, {
+            http: allServices.http,
+            mcp: allServices.mcp,
+            rpc: allServices.rpc,
+        }, [...(transportMiddleware || []), ...(funcConfig.middleware || [])], async () => await funcConfig.func(allServices, data, session)));
+    }
     return (await funcConfig.func(allServices, data, session));
 };

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

@@ -1,5 +1,5 @@
-import { PikkuChannel } from '../channel/channel.types.js';
-import type { CoreServices, CoreSingletonServices, CoreUserSession } from '../types/core.types.js';
+import { PikkuChannel } from '../events/channel/channel.types.js';
+import type { CoreServices, CoreSingletonServices, CoreUserSession, PikkuFunctionMiddleware } from '../types/core.types.js';
 /**
  * Represents a core API function that performs an operation using core services and a user session.
  *
@@ -39,4 +39,5 @@ export type CorePikkuFunctionConfig<APIFunction extends CoreAPIFunction<any, any
     func: APIFunction;
     auth?: boolean;
     permissions?: CorePermissionGroup<APIPermission>;
+    middleware?: PikkuFunctionMiddleware[];
 };

package/dist/handle-error.d.ts

@@ -1,5 +1,5 @@
 import { Logger } from './services/logger.js';
-import { PikkuHTTP } from './http/http.types.js';
+import { PikkuHTTP } from './events/http/http.types.js';
 /**
  * Handle errors that occur during route processing
  *
@@ -11,4 +11,4 @@ import { PikkuHTTP } from './http/http.types.js';
  * @param {boolean} respondWith404 - Whether to respond with 404 for NotFoundError
  * @param {boolean} bubbleError - Whether to throw the error after handling
  */
-export declare const handleError: (e: any, http: PikkuHTTP | undefined, trackerId: string | undefined, logger: Logger, logWarningsForStatusCodes: number[], respondWith404: boolean, bubbleError: boolean) => void;
+export declare const handleHTTPError: (e: any, http: PikkuHTTP | undefined, trackerId: string | undefined, logger: Logger, logWarningsForStatusCodes: number[], respondWith404: boolean, bubbleError: boolean) => void;

package/dist/handle-error.js

@@ -11,7 +11,7 @@ import { NotFoundError } from './errors/errors.js';
  * @param {boolean} respondWith404 - Whether to respond with 404 for NotFoundError
  * @param {boolean} bubbleError - Whether to throw the error after handling
  */
-export const handleError = (e, http, trackerId, logger, logWarningsForStatusCodes, respondWith404, bubbleError) => {
+export const handleHTTPError = (e, http, trackerId, logger, logWarningsForStatusCodes, respondWith404, bubbleError) => {
     // Skip 404 handling if configured to do so
     if (e instanceof NotFoundError && !respondWith404) {
         return;

package/dist/index.d.ts

@@ -5,16 +5,24 @@ export * from './types/core.types.js';
 export * from './function/index.js';
 export * from './pikku-request.js';
 export * from './pikku-response.js';
-export * from './services/index.js';
-export * from './http/index.js';
-export * from './channel/index.js';
-export * from './scheduler/index.js';
+export * from './services/logger.js';
+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 './events/http/index.js';
+export * from './events/channel/index.js';
+export * from './events/scheduler/index.js';
+export * from './events/rpc/index.js';
+export * from './events/queue/index.js';
+export * from './events/mcp/index.js';
 export * from './errors/index.js';
 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 { addHTTPRoute, addMiddleware } from './http/http-runner.js';
-export { addChannel } from './channel/channel-runner.js';
-export { addScheduledTask } from './scheduler/scheduler-runner.js';
+export { addHTTPRoute, addMiddleware } from './events/http/http-runner.js';
+export { addChannel } from './events/channel/channel-runner.js';
+export { addScheduledTask } from './events/scheduler/scheduler-runner.js';
+export { addMCPResource, addMCPTool, addMCPPrompt, runMCPResource, runMCPTool, runMCPPrompt, getMCPTools, getMCPResources, getMCPPrompts, getMCPResourcesMeta, getMCPToolsMeta, getMCPPromptsMeta, } from './events/mcp/mcp-runner.js';

package/dist/index.js

@@ -5,16 +5,24 @@ export * from './types/core.types.js';
 export * from './function/index.js';
 export * from './pikku-request.js';
 export * from './pikku-response.js';
-export * from './services/index.js';
-export * from './http/index.js';
-export * from './channel/index.js';
-export * from './scheduler/index.js';
+export * from './services/logger.js';
+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 './events/http/index.js';
+export * from './events/channel/index.js';
+export * from './events/scheduler/index.js';
+export * from './events/rpc/index.js';
+export * from './events/queue/index.js';
+export * from './events/mcp/index.js';
 export * from './errors/index.js';
 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 { addHTTPRoute, addMiddleware } from './http/http-runner.js';
-export { addChannel } from './channel/channel-runner.js';
-export { addScheduledTask } from './scheduler/scheduler-runner.js';
+export { addHTTPRoute, addMiddleware } from './events/http/http-runner.js';
+export { addChannel } from './events/channel/channel-runner.js';
+export { addScheduledTask } from './events/scheduler/scheduler-runner.js';
+export { addMCPResource, addMCPTool, addMCPPrompt, runMCPResource, runMCPTool, runMCPPrompt, getMCPTools, getMCPResources, getMCPPrompts, getMCPResourcesMeta, getMCPToolsMeta, getMCPPromptsMeta, } from './events/mcp/mcp-runner.js';

package/dist/middleware-runner.d.ts

@@ -1,5 +1,5 @@
 import { UserSessionService } from './services/user-session-service.js';
-import { CoreSingletonServices, PikkuInteraction, PikkuMiddleware } from './types/core.types.js';
+import { CoreSingletonServices, PikkuFunctionMiddleware, PikkuInteraction, PikkuMiddleware } from './types/core.types.js';
 /**
  * Runs a chain of middleware functions in sequence before executing the main function.
  *
@@ -17,6 +17,6 @@ import { CoreSingletonServices, PikkuInteraction, PikkuMiddleware } from './type
  *   async () => { return await runMain(); }
  * );
  */
-export declare const runMiddleware: (services: CoreSingletonServices & {
-    userSession: UserSessionService<any>;
-}, interaction: PikkuInteraction, middlewares: PikkuMiddleware[], main?: () => Promise<void>) => Promise<void>;
+export declare const runMiddleware: <Middleware extends PikkuMiddleware | PikkuFunctionMiddleware = PikkuMiddleware>(services: CoreSingletonServices & {
+    userSession?: UserSessionService<any>;
+}, interaction: PikkuInteraction, middlewares: Middleware[], main?: () => Promise<unknown>) => Promise<unknown>;

package/dist/middleware-runner.js

@@ -16,13 +16,15 @@
  * );
  */
 export const runMiddleware = async (services, interaction, middlewares, main) => {
+    let result;
     const dispatch = async (index) => {
         if (middlewares && index < middlewares.length) {
             return await middlewares[index](services, interaction, () => dispatch(index + 1));
         }
         else if (main) {
-            await main();
+            result = await main();
         }
     };
     await dispatch(0);
+    return result;
 };

package/dist/pikku-state.d.ts

@@ -1,10 +1,12 @@
-import { ChannelsMeta, CoreAPIChannel } from './channel/channel.types.js';
-import { CoreHTTPFunctionRoute, HTTPMethod, HTTPRoutesMeta } from './http/http.types.js';
+import { ChannelsMeta, CoreAPIChannel } from './events/channel/channel.types.js';
+import { CoreHTTPFunctionRoute, HTTPMethod, HTTPRoutesMeta } from './events/http/http.types.js';
 import { FunctionsMeta, PikkuMiddleware } from './types/core.types.js';
-import { CoreScheduledTask, ScheduledTasksMeta } from './scheduler/scheduler.types.js';
+import { CoreScheduledTask, ScheduledTasksMeta } from './events/scheduler/scheduler.types.js';
 import { ErrorDetails, PikkuError } from './errors/error-handler.js';
 import { CorePikkuFunctionConfig } from './function/functions.types.js';
-import { RPCMeta } from './rpc/rpc-types.js';
+import { RPCMeta } from './events/rpc/rpc-types.js';
+import { queueWorkersMeta, CoreQueueWorker } from './events/queue/queue.types.js';
+import { CoreMCPResource, CoreMCPTool, CoreMCPPrompt, MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from './events/mcp/mcp.types.js';
 interface PikkuState {
     function: {
         meta: FunctionsMeta;
@@ -33,6 +35,18 @@ interface PikkuState {
         tasks: Map<string, CoreScheduledTask>;
         meta: ScheduledTasksMeta;
     };
+    queue: {
+        registrations: Map<string, CoreQueueWorker>;
+        meta: queueWorkersMeta;
+    };
+    mcp: {
+        resources: Map<string, CoreMCPResource>;
+        resourcesMeta: MCPResourceMeta;
+        tools: Map<string, CoreMCPTool>;
+        toolsMeta: MCPToolMeta;
+        prompts: Map<string, CoreMCPPrompt>;
+        promptsMeta: MCPPromptMeta;
+    };
     misc: {
         errors: Map<PikkuError, ErrorDetails>;
         schemas: Map<string, any>;

package/dist/pikku-state.js

@@ -21,6 +21,18 @@ export const resetPikkuState = () => {
             tasks: new Map(),
             meta: [],
         },
+        queue: {
+            registrations: new Map(),
+            meta: {},
+        },
+        mcp: {
+            resources: new Map(),
+            resourcesMeta: {},
+            tools: new Map(),
+            toolsMeta: {},
+            prompts: new Map(),
+            promptsMeta: {},
+        },
         misc: {
             errors: globalThis.pikkuState?.misc?.errors || new Map(),
             schemas: globalThis.pikkuState?.misc?.schema || new Map(),

package/dist/services/index.d.ts

@@ -4,11 +4,11 @@
 export * from './content-service.js';
 export * from './jwt-service.js';
 export * from './logger.js';
-export * from './logger-console.js';
 export * from './secret-service.js';
 export * from './variables-service.js';
 export * from './schema-service.js';
 export * from './user-session-service.js';
-export * from './local-content.js';
 export * from './local-secrets.js';
 export * from './local-variables.js';
+export * from './logger-console.js';
+export * from './local-content.js';

package/dist/services/index.js

@@ -5,12 +5,12 @@
 export * from './content-service.js';
 export * from './jwt-service.js';
 export * from './logger.js';
-export * from './logger-console.js';
 export * from './secret-service.js';
 export * from './variables-service.js';
 export * from './schema-service.js';
 export * from './user-session-service.js';
-export * from './local-content.js';
 // Local implementations
 export * from './local-secrets.js';
 export * from './local-variables.js';
+export * from './logger-console.js';
+export * from './local-content.js';

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

@@ -1,4 +1,4 @@
-import { RelativeTimeInput } from '../time-utils.js';
+import type { RelativeTimeInput } from '../time-utils.js';
 /**
  * Interface for handling JSON Web Tokens (JWT).
  */

package/dist/services/user-session-service.d.ts

@@ -1,4 +1,4 @@
-import { ChannelStore } from '../channel/channel-store.js';
+import { ChannelStore } from '../events/channel/channel-store.js';
 import { CoreUserSession } from '../types/core.types.js';
 export interface UserSessionService<UserSession extends CoreUserSession> {
     sessionChanged: boolean;

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

@@ -1,18 +1,18 @@
 import type { Logger, LogLevel } from '../services/logger.js';
 import { VariablesService } from '../services/variables-service.js';
-import { EventHubService } from '../channel/eventhub-service.js';
 import { SchemaService } from '../services/schema-service.js';
-import { PikkuHTTP } from '../http/http.types.js';
+import { PikkuHTTP } from '../events/http/http.types.js';
 import { UserSessionService } from '../services/user-session-service.js';
-import { JWTService } from '../services/jwt-service.js';
-import { SecretService } from '../services/secret-service.js';
-import { PikkuChannel } from '../channel/channel.types.js';
-import { PikkuRPC } from '../rpc/rpc-types.js';
+import { PikkuChannel } from '../events/channel/channel.types.js';
+import { PikkuRPC } from '../events/rpc/rpc-types.js';
+import { PikkuMCP } from '../events/mcp/mcp.types.js';
 export declare enum PikkuEventTypes {
     http = "http",
-    scheduled = "scheduled",
+    scheduler = "scheduler",
     channel = "channel",
-    rpc = "rpc"
+    rpc = "rpc",
+    queue = "queue",
+    mcp = "mcp"
 }
 export interface FunctionServicesMeta {
     optimized: boolean;
@@ -69,8 +69,6 @@ export interface CoreUserSession {
  * Interface for core singleton services provided by Pikku.
  */
 export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
-    /** JWT Service */
-    jwt?: JWTService;
     /** The schema library used to validate data */
     schema?: SchemaService;
     /** The core configuration for the application. */
@@ -79,17 +77,21 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
     logger: Logger;
     /** The variable service to be used */
     variables: VariablesService;
-    /** The subscription service that is passed to streams */
-    eventHub?: EventHubService<unknown>;
-    /** SecretServce  */
-    secrets?: SecretService;
 }
 /**
  * Represents different forms of interaction within Pikku and the outside world.
  */
 export interface PikkuInteraction {
     http?: PikkuHTTP;
+    mcp?: PikkuMCP;
+    rpc?: PikkuRPC;
 }
+/**
+ * A function that can wrap an interaction and be called before or after
+ */
+export type PikkuFunctionMiddleware<SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession> = (services: SingletonServices & {
+    userSession?: UserSessionService<UserSession>;
+}, interactions: PikkuInteraction, next: () => Promise<void>) => Promise<void>;
 /**
  * A function that can wrap an interaction and be called before or after
  */
@@ -100,6 +102,7 @@ export type PikkuMiddleware<SingletonServices extends CoreSingletonServices = Co
  * Represents the core services used by Pikku, including singleton services and the request/response interaction.
  */
 export type CoreServices<SingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession, CoreServices extends Record<string, unknown> = {}> = SingletonServices & PikkuInteraction & {
+    mcp?: PikkuMCP;
     rpc?: PikkuRPC;
     userSession?: UserSessionService<UserSession>;
     channel?: PikkuChannel<unknown, unknown>;

package/dist/types/core.types.js

@@ -1,7 +1,9 @@
 export var PikkuEventTypes;
 (function (PikkuEventTypes) {
     PikkuEventTypes["http"] = "http";
-    PikkuEventTypes["scheduled"] = "scheduled";
+    PikkuEventTypes["scheduler"] = "scheduler";
     PikkuEventTypes["channel"] = "channel";
     PikkuEventTypes["rpc"] = "rpc";
+    PikkuEventTypes["queue"] = "queue";
+    PikkuEventTypes["mcp"] = "mcp";
 })(PikkuEventTypes || (PikkuEventTypes = {}));