@pikku/core 0.7.8 → 0.8.0

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

@@ -0,0 +1,24 @@
+import type { CoreServices } from '../../types/core.types.js';
+import type { CoreQueueWorker, QueueJob } from './queue.types.js';
+import type { CoreAPIFunctionSessionless } from '../../function/functions.types.js';
+import { CreateSessionServices } from '../../types/core.types.js';
+/**
+ * Add a queue processor to the system
+ */
+export declare const addQueueWorker: <InputData = any, OutputData = any, APIFunction extends CoreAPIFunctionSessionless<InputData, OutputData> = CoreAPIFunctionSessionless<InputData, OutputData>>(queueWorker: CoreQueueWorker<APIFunction>) => void;
+/**
+ * Get all registered queue processors
+ */
+export declare function getQueueWorkers(): Map<string, CoreQueueWorker>;
+/**
+ * Stop and remove a queue processor
+ */
+export declare function removeQueueWorker(name: string): Promise<void>;
+/**
+ * Process a single queue job - this function is called by queue consumers
+ */
+export declare function runQueueJob({ singletonServices, createSessionServices, job, }: {
+    singletonServices: CoreServices;
+    createSessionServices?: CreateSessionServices;
+    job: QueueJob;
+}): Promise<void>;

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

@@ -0,0 +1,83 @@
+import { getErrorResponse } from '../../errors/error-handler.js';
+import { pikkuState } from '../../pikku-state.js';
+import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
+/**
+ * Error class for queue processor not found
+ */
+class QueueWorkerNotFoundError extends Error {
+    constructor(name) {
+        super(`Queue processor not found: ${name}`);
+    }
+}
+/**
+ * Add a queue processor to the system
+ */
+export const addQueueWorker = (queueWorker) => {
+    // Get processor metadata
+    const meta = pikkuState('queue', 'meta');
+    const processorMeta = meta[queueWorker.queueName];
+    if (!processorMeta) {
+        throw new Error(`Queue processor metadata not found for '${queueWorker.queueName}'. Make sure to run the CLI to generate metadata.`);
+    }
+    // Register the function with pikku
+    addFunction(processorMeta.pikkuFuncName, {
+        func: queueWorker.func,
+    });
+    // Store processor definition in state - runtime adapters will pick this up
+    const registrations = pikkuState('queue', 'registrations');
+    registrations.set(queueWorker.queueName, queueWorker);
+};
+/**
+ * Get all registered queue processors
+ */
+export function getQueueWorkers() {
+    return pikkuState('queue', 'registrations');
+}
+/**
+ * Stop and remove a queue processor
+ */
+export async function removeQueueWorker(name) {
+    const registrations = pikkuState('queue', 'registrations');
+    const registration = registrations.get(name);
+    if (!registration) {
+        throw new QueueWorkerNotFoundError(name);
+    }
+    registrations.delete(name);
+}
+/**
+ * Process a single queue job - this function is called by queue consumers
+ */
+export async function runQueueJob({ singletonServices, createSessionServices, job, }) {
+    const logger = singletonServices.logger;
+    const meta = pikkuState('queue', 'meta');
+    const processorMeta = meta[job.queueName];
+    if (!processorMeta) {
+        throw new Error(`Processor metadata not found for: ${job.queueName}`);
+    }
+    try {
+        logger.info(`Processing job ${job.id} in queue ${job.queueName}`);
+        // Use provided singleton services
+        const getAllServices = () => ({
+            ...singletonServices,
+            ...(createSessionServices
+                ? createSessionServices(singletonServices, {}, undefined)
+                : {}),
+        });
+        // Execute the pikku function with the job data
+        const result = await runPikkuFunc(processorMeta.pikkuFuncName, {
+            getAllServices,
+            data: job.data,
+        });
+        logger.debug(`Successfully processed job ${job.id} in queue ${job.queueName}`);
+        return result;
+    }
+    catch (error) {
+        logger.error(`Error processing job ${job.id} in queue ${job.queueName}:`, error);
+        const errorResponse = getErrorResponse(error);
+        if (errorResponse != null) {
+            logger.error('Processed error response:', errorResponse);
+        }
+        // Re-throw the error so the queue service can handle retries/DLQ
+        throw error;
+    }
+}

package/dist/events/queue/queue.types.d.ts

@@ -0,0 +1,154 @@
+import { APIDocs } from '../../types/core.types.js';
+import { CoreAPIFunctionSessionless } from '../../function/functions.types.js';
+import { QueueConfigMapping } from './validate-worker-config.js';
+/**
+ * Configuration for queue workers - how jobs are processed
+ */
+/**
+ * Configuration for queue workers - how jobs are processed
+ */
+export interface PikkuWorkerConfig {
+    /** Optional worker name for identification and monitoring */
+    name?: string;
+    /** Number of messages to process in batch / in parallel */
+    batchSize?: number;
+    /** Number of messages to prefetch for efficiency */
+    prefetch?: number;
+    /** Polling interval for pull-based queues in ms */
+    pollInterval?: number;
+    /** Message visibility timeout in seconds */
+    visibilityTimeout?: number;
+    /** Duration of job lock in milliseconds */
+    lockDuration?: number;
+    /** Number of seconds to wait when queue is empty before polling again */
+    drainDelay?: number;
+    /** Keep N completed jobs for inspection */
+    removeOnComplete?: number;
+    /** Keep N failed jobs for inspection */
+    removeOnFail?: number;
+    /** Maximum number of times a job can be recovered from stalled state */
+    maxStalledCount?: number;
+    /** Condition to start processor at instance creation */
+    autorun?: boolean;
+}
+/**
+ * Configuration for individual jobs - how jobs behave
+ */
+export interface PikkuJobConfig {
+    /** Maximum retry attempts for failed jobs */
+    retryAttempts?: number;
+    /** Initial retry delay in milliseconds */
+    retryDelay?: number;
+    /** Retry backoff strategy */
+    retryBackoff?: 'linear' | 'exponential' | 'fixed';
+    /** Queue for failed messages after max retries */
+    deadLetterQueue?: string;
+    /** How long to retain completed jobs in seconds */
+    messageRetention?: number;
+    /** Job priority (higher numbers = higher priority) */
+    priority?: number;
+    /** Enable FIFO ordering where supported */
+    fifo?: boolean;
+    /** Job timeout in milliseconds */
+    timeout?: number;
+    /** Delay before job execution in milliseconds */
+    delay?: number;
+}
+/**
+ * Configuration validation result with warnings and fallbacks
+ */
+export interface ConfigValidationResult {
+    applied: Partial<PikkuWorkerConfig>;
+    ignored: Partial<PikkuWorkerConfig>;
+    warnings: string[];
+    fallbacks: {
+        [key: string]: any;
+    };
+}
+/**
+ * Queue job representation
+ */
+export type QueueJobStatus = 'waiting' | 'active' | 'completed' | 'failed' | 'delayed';
+export type QueueJobMetadata = {
+    progress?: number | string | object | undefined | boolean;
+    attemptsMade?: number;
+    maxAttempts?: number;
+    processedAt?: Date;
+    completedAt?: Date;
+    failedAt?: Date;
+    error?: string;
+    createdAt: Date;
+};
+export interface QueueJob<T = any, R = any> {
+    id: string;
+    queueName: string;
+    status: () => Promise<QueueJobStatus> | QueueJobStatus;
+    data: T;
+    result?: R;
+    waitForCompletion?: (ttl?: number) => Promise<R>;
+    metadata?: () => Promise<QueueJobMetadata> | QueueJobMetadata;
+}
+/**
+ * Job options for queue operations
+ */
+export interface JobOptions {
+    priority?: number;
+    delay?: number;
+    attempts?: number;
+    backoff?: string | {
+        type: string;
+        delay?: number;
+    };
+    removeOnComplete?: number;
+    removeOnFail?: number;
+    jobId?: string;
+}
+/**
+ * Queue provider interface for job publishing operations
+ */
+export interface QueueService {
+    /** Whether this queue provider supports job results */
+    readonly supportsResults: boolean;
+    /** Add a job to the queue with type safety */
+    add<T>(queueName: string, data: T, options?: JobOptions): Promise<string>;
+    /** Get job status and result */
+    getJob<T, R>(queueName: string, jobId: string): Promise<QueueJob<T, R> | null>;
+}
+/**
+ * Queue service interface that queue adapters implement
+ */
+export interface QueueWorkers {
+    /** Service name identifier */
+    name: string;
+    /** Whether this queue service supports job results */
+    supportsResults: boolean;
+    /** Configuration mapping for validation */
+    configMappings: QueueConfigMapping;
+    /** Scan state and register all compatible processors */
+    registerQueues(): Promise<Record<string, ConfigValidationResult[]>>;
+    /** Close all queues and connections */
+    close(): Promise<void>;
+}
+/**
+ * Queue processor metadata
+ */
+export type queueWorkersMeta = Record<string, {
+    pikkuFuncName: string;
+    schemaName?: string;
+    queueName: string;
+    session?: undefined;
+    docs?: APIDocs;
+    tags?: string[];
+    config?: PikkuWorkerConfig;
+}>;
+/**
+ * Core queue processor definition
+ */
+export type CoreQueueWorker<APIFunction = CoreAPIFunctionSessionless<any, any>> = {
+    queueName: string;
+    func: APIFunction;
+    config?: PikkuWorkerConfig;
+    docs?: APIDocs;
+    session?: undefined;
+    tags?: string[];
+};

package/dist/events/queue/register-queue-helper.d.ts

@@ -0,0 +1,17 @@
+import type { ConfigValidationResult, CoreQueueWorker } from './queue.types.js';
+import { QueueConfigMapping } from './validate-worker-config.js';
+import { Logger } from '../../services/logger.js';
+/**
+ * Queue processor registration callback
+ */
+export type QueueRegistrationCallback<T = any> = (queueName: string, processor: CoreQueueWorker) => Promise<T>;
+/**
+ * Helper function to register queue processors with validation
+ * This centralizes the common logic for looping over processors and validating configs
+ *
+ * @param configMappings - Configuration mapping for the queue implementation
+ * @param registerCallback - Callback to register each individual queue processor
+ * @param logger - Optional logger for info/error messages
+ * @returns Record of validation results by queue name
+ */
+export declare function registerqueueWorkers<T = any>(configMappings: QueueConfigMapping, logger: Logger, registerCallback: QueueRegistrationCallback<T>): Promise<Record<string, ConfigValidationResult[]>>;

package/dist/events/queue/register-queue-helper.js

@@ -0,0 +1,34 @@
+import { getQueueWorkers } from './queue-runner.js';
+import { validateWorkerConfig, } from './validate-worker-config.js';
+/**
+ * Helper function to register queue processors with validation
+ * This centralizes the common logic for looping over processors and validating configs
+ *
+ * @param configMappings - Configuration mapping for the queue implementation
+ * @param registerCallback - Callback to register each individual queue processor
+ * @param logger - Optional logger for info/error messages
+ * @returns Record of validation results by queue name
+ */
+export async function registerqueueWorkers(configMappings, logger, registerCallback) {
+    const configValidation = {};
+    const queueWorkers = getQueueWorkers();
+    for (const [queueName, processor] of queueWorkers) {
+        logger?.info(`Registering queue processor: ${queueName}`);
+        // Validate the processor configuration
+        const validationResult = validateWorkerConfig(configMappings, processor.config);
+        // Store validation results
+        configValidation[queueName] = configValidation[queueName] || [];
+        configValidation[queueName].push(validationResult);
+        if (validationResult.warnings.length > 0) {
+            logger?.warn(`Configuration warnings for queue ${queueName}:`, validationResult.warnings);
+        }
+        try {
+            await registerCallback(queueName, processor);
+            logger?.info(`Successfully registered queue processor: ${queueName}`);
+        }
+        catch (error) {
+            logger?.error(`Failed to register queue processor ${queueName}:`, error);
+        }
+    }
+    return configValidation;
+}

package/dist/events/queue/validate-worker-config.d.ts

@@ -0,0 +1,41 @@
+import { PikkuWorkerConfig, ConfigValidationResult } from './queue.types.js';
+/**
+ * Configuration mapping structure for queue implementations
+ */
+export interface QueueConfigMapping {
+    /** Configurations that are directly supported */
+    supported: Partial<Record<keyof PikkuWorkerConfig, {
+        /** The property name in the underlying queue system */
+        queueProperty?: string;
+        /** Optional transform function for the value */
+        transform?: (value: any) => any;
+        /** Description of what this configuration does */
+        description: string;
+    }>>;
+    /** Configurations that are not supported */
+    unsupported: Partial<Record<keyof PikkuWorkerConfig, {
+        /** Why this configuration is not supported */
+        reason: string;
+        /** Detailed explanation of what the queue system does instead */
+        explanation: string;
+    }>>;
+    /** Configurations that have partial support or workarounds */
+    fallbacks: Partial<Record<keyof PikkuWorkerConfig, {
+        /** Why this configuration uses a fallback */
+        reason: string;
+        /** Detailed explanation of the fallback behavior */
+        explanation: string;
+        /** The fallback value or description */
+        fallbackValue: string;
+    }>>;
+}
+/**
+ * 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 declare function validateWorkerConfig(configMapping: QueueConfigMapping, config?: PikkuWorkerConfig): ConfigValidationResult;

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,28 @@
+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): {
+        jwt?: import("../../index.js").JWTService;
+        schema?: import("../../index.js").SchemaService;
+        config: {
+            logLevel?: import("../../index.js").LogLevel;
+            secrets?: {};
+        };
+        logger: import("../../index.js").Logger;
+        variables: import("../../index.js").VariablesService;
+        eventHub?: import("../channel/eventhub-service.js").EventHubService<unknown>;
+        secrets?: import("../../index.js").SecretService;
+        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.js

@@ -1,4 +1,5 @@
 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';
@@ -76,5 +77,12 @@ export const runPikkuFunc = async (funcName, { getAllServices, data, session, pe
     if (permissioned === false) {
         throw new ForbiddenError('Permission denied');
     }
+    if (funcConfig.middleware) {
+        return (await runMiddleware(allServices, {
+            http: allServices.http,
+            mcp: allServices.mcp,
+            rpc: allServices.rpc,
+        }, 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

@@ -6,15 +6,19 @@ 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 './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

@@ -6,15 +6,19 @@ 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 './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';