@pikku/core 0.10.2 → 0.11.1

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

@@ -79,16 +79,16 @@ export declare const addHTTPPermission: <PikkuPermission extends CorePikkuPermis
  */
 export declare const wireHTTP: <In, Out, Route extends string, PikkuFunction extends CorePikkuFunction<In, Out> = CorePikkuFunction<In, Out>, PikkuFunctionSessionless extends CorePikkuFunctionSessionless<In, Out> = CorePikkuFunctionSessionless<In, Out>, PikkuPermissionGroup extends CorePikkuPermission<In> = CorePikkuPermission<In>, PikkuMiddleware extends CorePikkuMiddleware = CorePikkuMiddleware>(httpWiring: CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction, PikkuFunctionSessionless, PikkuPermissionGroup, PikkuMiddleware>) => void;
 /**
- * Combines the request and response objects into a single HTTP interaction object.
+ * Combines the request and response objects into a single HTTP wire object.
  *
  * This utility function creates an object that holds both the HTTP request and response,
  * which simplifies passing these around through middleware and route execution.
  *
  * @param {PikkuHTTPRequest | undefined} request - The HTTP request object.
  * @param {PikkuHTTPResponse | undefined} response - The HTTP response object.
- * @returns {PikkuHTTP | undefined} The combined HTTP interaction object or undefined if none provided.
+ * @returns {PikkuHTTP | undefined} The combined HTTP wire object or undefined if none provided.
  */
-export declare const createHTTPInteraction: (request: PikkuHTTPRequest | undefined, response: PikkuHTTPResponse | undefined) => PikkuHTTP | undefined;
+export declare const createHTTPWire: (request: PikkuHTTPRequest | undefined, response: PikkuHTTPResponse | undefined) => PikkuHTTP | undefined;
 /**
  * Executes an HTTP route for a given Fetch API request.
  *
@@ -123,11 +123,11 @@ export declare const pikkuFetch: <In, Out>(request: Request | PikkuHTTPRequest,
  * middleware execution, error handling, and session service cleanup.
  *
  * This function does the following:
- *  - Wraps the incoming request and response into an HTTP interaction object.
+ *  - Wraps the incoming request and response into an HTTP wire object.
  *  - Determines the correct route based on HTTP method and path.
  *  - Executes middleware and the route handler.
  *  - Catches and handles errors, optionally bubbling them if configured.
- *  - Cleans up any session services created during processing.
+ *  - Cleans up any wire services created during processing.
  *
  * @template In Expected input data type.
  * @template Out Expected output data type.
@@ -136,4 +136,4 @@ export declare const pikkuFetch: <In, Out>(request: Request | PikkuHTTPRequest,
  * @param {RunHTTPWiringOptions & RunHTTPWiringParams} options - Options such as singleton services, session handling, and error configuration.
  * @returns {Promise<Out | void>} The output from the route handler or void if an error occurred.
  */
-export declare const fetchData: <In, Out>(request: Request | PikkuHTTPRequest, response: PikkuHTTPResponse, { singletonServices, createSessionServices, skipUserSession, respondWith404, logWarningsForStatusCodes, coerceDataFromSchema, bubbleErrors, generateRequestId, }: RunHTTPWiringOptions & RunHTTPWiringParams) => Promise<Out | void>;
+export declare const fetchData: <In, Out>(request: Request | PikkuHTTPRequest, response: PikkuHTTPResponse, { singletonServices, createWireServices, skipUserSession, respondWith404, logWarningsForStatusCodes, coerceDataFromSchema, bubbleErrors, generateRequestId, }: RunHTTPWiringOptions & RunHTTPWiringParams) => Promise<Out | void>;

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

@@ -1,13 +1,11 @@
-import { PikkuWiringTypes, } from '../../types/core.types.js';
 import { NotFoundError } from '../../errors/errors.js';
-import { closeSessionServices, createWeakUID, isSerializable, } from '../../utils.js';
-import { PikkuUserSessionService } from '../../services/user-session-service.js';
+import { closeWireServices, createWeakUID, isSerializable, } from '../../utils.js';
+import { PikkuSessionService } from '../../services/user-session-service.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 HTTP middleware for a specific route pattern.
@@ -135,16 +133,16 @@ const getMatchingRoute = (requestType, requestPath) => {
     }
 };
 /**
- * Combines the request and response objects into a single HTTP interaction object.
+ * Combines the request and response objects into a single HTTP wire object.
  *
  * This utility function creates an object that holds both the HTTP request and response,
  * which simplifies passing these around through middleware and route execution.
  *
  * @param {PikkuHTTPRequest | undefined} request - The HTTP request object.
  * @param {PikkuHTTPResponse | undefined} response - The HTTP response object.
- * @returns {PikkuHTTP | undefined} The combined HTTP interaction object or undefined if none provided.
+ * @returns {PikkuHTTP | undefined} The combined HTTP wire object or undefined if none provided.
  */
-export const createHTTPInteraction = (request, response) => {
+export const createHTTPWire = (request, response) => {
     let http = undefined;
     if (request || response) {
         http = {};
@@ -172,17 +170,17 @@ export const createHTTPInteraction = (request, response) => {
  *
  * @param {Object} services - A collection of shared services and utilities.
  * @param {Object} matchedRoute - Contains route details, URL parameters, and optional schema.
- * @param {PikkuHTTP | undefined} http - The HTTP interaction object.
+ * @param {PikkuHTTP | undefined} http - The HTTP wire object.
  * @param {Object} options - Options for route execution (e.g., whether to coerce query strings to arrays).
- * @returns {Promise<any>} An object containing the route handler result and session services (if any).
+ * @returns {Promise<any>} An object containing the route handler result and wire services (if any).
  * @throws Throws errors like MissingSessionError or ForbiddenError on validation failures.
  */
 const executeRoute = async (services, matchedRoute, http, options) => {
-    const userSession = new PikkuUserSessionService();
+    const userSession = new PikkuSessionService();
     const { params, route, meta } = matchedRoute;
-    const { singletonServices, createSessionServices, skipUserSession, requestId, } = services;
+    const { singletonServices, createWireServices, skipUserSession, requestId } = services;
     const requiresSession = route.auth !== false;
-    let sessionServices;
+    let wireServices;
     let result;
     // Attach URL parameters to the request object
     http?.request?.setParams(params);
@@ -219,23 +217,11 @@ const executeRoute = async (services, matchedRoute, http, options) => {
             state: 'open',
         };
     }
-    const interaction = { http, channel };
-    const getAllServices = async (session) => {
-        // Create session-specific services for handling the request
-        sessionServices = await createSessionServices({ ...singletonServices, userSession, channel }, { http }, session);
-        return rpcService.injectRPCService({
-            ...singletonServices,
-            ...sessionServices,
-            http,
-            userSession,
-            channel,
-        }, interaction, route.auth);
-    };
-    result = await runPikkuFunc(PikkuWiringTypes.http, `${meta.method}:${meta.route}`, meta.pikkuFuncName, {
+    const wire = { http, channel, session: userSession };
+    result = await runPikkuFunc('http', `${meta.method}:${meta.route}`, meta.pikkuFuncName, {
         singletonServices,
-        getAllServices,
+        createWireServices,
         auth: route.auth !== false,
-        userSession,
         data,
         inheritedMiddleware: meta.middleware,
         wireMiddleware: route.middleware,
@@ -243,7 +229,7 @@ const executeRoute = async (services, matchedRoute, http, options) => {
         wirePermissions: route.permissions,
         coerceDataFromSchema: options.coerceDataFromSchema,
         tags: route.tags,
-        interaction,
+        wire,
     });
     // Respond with either a binary or JSON response based on configuration
     if (route.returnsJSON === false) {
@@ -255,7 +241,7 @@ const executeRoute = async (services, matchedRoute, http, options) => {
     http?.response?.status(200);
     // TODO: Evaluate if the response stream should be explicitly ended.
     // http?.response?.end()
-    return sessionServices ? { result, sessionServices } : { result };
+    return wireServices ? { result, wireServices } : { result };
 };
 /**
  * Executes an HTTP route for a given Fetch API request.
@@ -299,11 +285,11 @@ export const pikkuFetch = async (request, params) => {
  * middleware execution, error handling, and session service cleanup.
  *
  * This function does the following:
- *  - Wraps the incoming request and response into an HTTP interaction object.
+ *  - Wraps the incoming request and response into an HTTP wire object.
  *  - Determines the correct route based on HTTP method and path.
  *  - Executes middleware and the route handler.
  *  - Catches and handles errors, optionally bubbling them if configured.
- *  - Cleans up any session services created during processing.
+ *  - Cleans up any wire services created during processing.
  *
  * @template In Expected input data type.
  * @template Out Expected output data type.
@@ -312,14 +298,14 @@ export const pikkuFetch = async (request, params) => {
  * @param {RunHTTPWiringOptions & RunHTTPWiringParams} options - Options such as singleton services, session handling, and error configuration.
  * @returns {Promise<Out | void>} The output from the route handler or void if an error occurred.
  */
-export const fetchData = async (request, response, { singletonServices, createSessionServices, skipUserSession = false, respondWith404 = true, logWarningsForStatusCodes = [], coerceDataFromSchema = true, bubbleErrors = false, generateRequestId, }) => {
+export const fetchData = async (request, response, { singletonServices, createWireServices, skipUserSession = false, respondWith404 = true, logWarningsForStatusCodes = [], coerceDataFromSchema = true, bubbleErrors = false, generateRequestId, }) => {
     const requestId = request.getHeader?.('x-request-id') ||
         generateRequestId?.() ||
         createWeakUID();
-    let sessionServices;
+    let wireServices;
     let result;
-    // Combine the request and response into one interaction object
-    const http = createHTTPInteraction(request instanceof Request ? new PikkuFetchHTTPRequest(request) : request, response);
+    // Combine the request and response into one wire object
+    const http = createHTTPWire(request instanceof Request ? new PikkuFetchHTTPRequest(request) : request, response);
     const apiType = http.request.method();
     const apiRoute = http.request.path();
     // Locate the matching route based on the HTTP method and path
@@ -336,9 +322,9 @@ export const fetchData = async (request, response, { singletonServices, createSe
         }
         // Execute the matched route along with its middleware and session management
         ;
-        ({ result, sessionServices } = await executeRoute({
+        ({ result, wireServices } = await executeRoute({
             singletonServices,
-            createSessionServices,
+            createWireServices,
             skipUserSession,
             requestId,
         }, matchedRoute, http, { coerceDataFromSchema }));
@@ -350,8 +336,8 @@ export const fetchData = async (request, response, { singletonServices, createSe
     }
     finally {
         // Clean up any session-specific services created during processing
-        if (sessionServices) {
-            await closeSessionServices(singletonServices.logger, sessionServices);
+        if (wireServices) {
+            await closeWireServices(singletonServices.logger, wireServices);
         }
     }
 };

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

@@ -1,6 +1,6 @@
 import type { SerializeOptions } from 'cookie';
 import type { PikkuError } from '../../errors/error-handler.js';
-import type { PikkuDocs, CoreServices, CoreSingletonServices, CoreUserSession, CreateSessionServices, CorePikkuMiddleware, MiddlewareMetadata, PermissionMetadata } from '../../types/core.types.js';
+import type { CoreServices, CoreSingletonServices, CoreUserSession, CreateWireServices, CorePikkuMiddleware, CommonWireMeta } from '../../types/core.types.js';
 import type { CorePikkuFunction, CorePikkuFunctionSessionless, CorePikkuPermission, CorePermissionGroup, CorePikkuFunctionConfig } from '../../function/functions.types.js';
 type ExtractHTTPWiringParams<S extends string> = S extends `${string}:${infer Param}/${infer Rest}` ? Param | ExtractHTTPWiringParams<`/${Rest}`> : S extends `${string}:${infer Param}` ? Param : never;
 export type AssertHTTPWiringParams<In, HTTPWiring extends string> = ExtractHTTPWiringParams<HTTPWiring> extends keyof In ? unknown : [
@@ -19,7 +19,7 @@ export type RunHTTPWiringOptions = Partial<{
 }>;
 export type RunHTTPWiringParams = {
     singletonServices: CoreSingletonServices;
-    createSessionServices: CreateSessionServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
+    createWireServices: CreateWireServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
 };
 /**
  * Represents the HTTP methods supported for API HTTP wirings.
@@ -43,7 +43,7 @@ export type CoreHTTPFunction = {
     }>;
 };
 /**
- * Represents a http interaction within Pikku, including a request and response.
+ * Represents a http wire within Pikku, including a request and response.
  */
 export interface PikkuHTTP<In = unknown> {
     request?: PikkuHTTPRequest<In>;
@@ -67,7 +67,7 @@ export type PikkuQuery<T = Record<string, string | undefined>> = Record<string,
  * @template PikkuFunctionSessionless - The sessionless API function type, defaults to `CorePikkuFunctionSessionless`.
  * @template PikkuPermission - The permission function type, defaults to `CorePikkuPermission`.
  */
-export type CoreHTTPFunctionWiring<In, Out, R extends string, PikkuFunction extends CorePikkuFunction<In, Out, any, any, any> = CorePikkuFunction<In, Out>, PikkuFunctionSessionless extends CorePikkuFunctionSessionless<In, Out, any, any, any> = CorePikkuFunctionSessionless<In, Out>, PikkuPermission extends CorePikkuPermission<In, any, any> = CorePikkuPermission<In, any, any>, PikkuMiddleware extends CorePikkuMiddleware<any, any> = CorePikkuMiddleware<any>> = (CoreHTTPFunction & {
+export type CoreHTTPFunctionWiring<In, Out, R extends string, PikkuFunction extends CorePikkuFunction<In, Out, any, any> = CorePikkuFunction<In, Out>, PikkuFunctionSessionless extends CorePikkuFunctionSessionless<In, Out, any, any> = CorePikkuFunctionSessionless<In, Out>, PikkuPermission extends CorePikkuPermission<In, any, any> = CorePikkuPermission<In, any, any>, PikkuMiddleware extends CorePikkuMiddleware<any, any> = CorePikkuMiddleware<any>> = (CoreHTTPFunction & {
     route: R;
     method: HTTPMethod;
     func: CorePikkuFunctionConfig<PikkuFunction, PikkuPermission, PikkuMiddleware>;
@@ -135,18 +135,13 @@ export type HTTPFunctionMetaInputTypes = {
 /**
  * Represents metadata for a set of HTTP wirings, including HTTP wiring details, methods, input/output types, and documentation.
  */
-export type HTTPWiringMeta = {
-    pikkuFuncName: string;
+export type HTTPWiringMeta = CommonWireMeta & {
     route: string;
     method: HTTPMethod;
     params?: string[];
     query?: string[];
     inputTypes?: HTTPFunctionMetaInputTypes;
-    docs?: PikkuDocs;
-    tags?: string[];
     sse?: true;
-    middleware?: MiddlewareMetadata[];
-    permissions?: PermissionMetadata[];
 };
 export type HTTPWiringsMeta = Record<HTTPMethod, Record<string, HTTPWiringMeta>>;
 export type HTTPFunctionsMeta = Array<{

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

@@ -1,4 +1,4 @@
-import { type CoreServices, type CoreSingletonServices, type CoreUserSession, type CreateSessionServices } from '../../types/core.types.js';
+import { type CoreServices, type CoreSingletonServices, type CoreUserSession, type CreateWireServices } from '../../types/core.types.js';
 import type { CoreMCPResource, CoreMCPTool, CoreMCPPrompt, JsonRpcRequest, JsonRpcResponse, JsonRpcErrorResponse, PikkuMCP } from './mcp.types.js';
 import type { CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from '../../function/functions.types.js';
 export declare class MCPError extends Error {
@@ -8,7 +8,7 @@ export declare class MCPError extends Error {
 export type RunMCPEndpointParams<Tools extends string = any> = {
     singletonServices: CoreSingletonServices;
     mcp?: PikkuMCP<Tools>;
-    createSessionServices?: CreateSessionServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
+    createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
 };
 export type JsonRpcError = {
     code: number;

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

@@ -1,10 +1,9 @@
-import { PikkuWiringTypes, } from '../../types/core.types.js';
 import { getErrorResponse } from '../../errors/error-handler.js';
-import { closeSessionServices } from '../../utils.js';
+import { closeWireServices } 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 { PikkuSessionService } from '../../services/user-session-service.js';
 export class MCPError extends Error {
     error;
     constructor(error) {
@@ -100,8 +99,8 @@ export async function runMCPPrompt(request, params, name) {
 /**
  * JSON-RPC 2.0 compatible MCP endpoint runner
  */
-async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncName, { singletonServices, createSessionServices, mcp: mcpInteraction, }) {
-    let sessionServices;
+async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncName, { singletonServices, createWireServices, mcp: mcpWire }) {
+    let wireServices;
     try {
         // Validate JSON-RPC request structure
         if (request.jsonrpc !== '2.0') {
@@ -114,14 +113,9 @@ async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncName, { single
             throw new NotFoundError(`MCP '${type}' PikkuFunction Mapping not found for '${name}'`);
         }
         singletonServices.logger.debug(`Running MCP ${type}: ${name}`);
-        const interaction = { mcp: mcpInteraction };
-        const getAllServices = async () => {
-            sessionServices = await createSessionServices?.(singletonServices, interaction, undefined);
-            return rpcService.injectRPCService({
-                ...singletonServices,
-                ...sessionServices,
-                mcp: mcpInteraction,
-            }, interaction);
+        const wire = {
+            mcp: mcpWire,
+            session: new PikkuSessionService(),
         };
         // Get metadata for the MCP endpoint to access pre-resolved middleware
         let meta;
@@ -134,17 +128,16 @@ async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncName, { single
         else if (type === 'prompt') {
             meta = pikkuState('mcp', 'promptsMeta')[name];
         }
-        const result = await runPikkuFunc(PikkuWiringTypes.mcp, `${type}:${name}`, pikkuFuncName, {
+        const result = await runPikkuFunc('mcp', `${type}:${name}`, pikkuFuncName, {
             singletonServices,
-            getAllServices,
-            userSession: undefined, // TODO
+            createWireServices,
             data: () => request.params,
             inheritedMiddleware: meta?.middleware,
             wireMiddleware: mcp.middleware,
             inheritedPermissions: meta?.permissions,
             wirePermissions: mcp.permissions,
             tags: mcp.tags,
-            interaction,
+            wire,
         });
         return {
             id: request.id,
@@ -174,8 +167,8 @@ async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncName, { single
         }
     }
     finally {
-        if (sessionServices) {
-            await closeSessionServices(singletonServices.logger, sessionServices);
+        if (wireServices) {
+            await closeWireServices(singletonServices.logger, wireServices);
         }
     }
 }

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

@@ -64,6 +64,8 @@ export type CoreMCPResource<PikkuFunctionConfig = CorePikkuFunctionConfig<CorePi
     uri: string;
     title: string;
     description: string;
+    summary?: string;
+    errors?: string[];
     mimeType?: string;
     size?: number;
     streaming?: boolean;
@@ -79,6 +81,8 @@ export type CoreMCPTool<PikkuFunctionConfig = CorePikkuFunctionConfig<CorePikkuF
     name: string;
     title?: string;
     description: string;
+    summary?: string;
+    errors?: string[];
     func: PikkuFunctionConfig;
     tags?: string[];
     streaming?: boolean;
@@ -91,6 +95,8 @@ export type CoreMCPTool<PikkuFunctionConfig = CorePikkuFunctionConfig<CorePikkuF
 export type CoreMCPPrompt<PikkuFunctionConfig = CorePikkuFunctionConfig<CorePikkuFunctionSessionless<any, MCPPromptResponse>>, PikkuPermission = CorePikkuPermission<any, any>, PikkuMiddleware = CorePikkuMiddleware<any>> = {
     name: string;
     description: string;
+    summary?: string;
+    errors?: string[];
     func: PikkuFunctionConfig;
     tags?: string[];
     middleware?: PikkuMiddleware[];

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

@@ -2,7 +2,7 @@ import type { CoreServices } from '../../types/core.types.js';
 import type { CoreQueueWorker, QueueJob } from './queue.types.js';
 import type { CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from '../../function/functions.types.js';
 import { PikkuError } from '../../errors/error-handler.js';
-import { CreateSessionServices } from '../../types/core.types.js';
+import { CreateWireServices } from '../../types/core.types.js';
 /**
  * Error class for when a queue job is explicitly failed
  */
@@ -30,9 +30,9 @@ 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, updateProgress, }: {
+export declare function runQueueJob({ singletonServices, createWireServices, job, updateProgress, }: {
     singletonServices: CoreServices;
-    createSessionServices?: CreateSessionServices;
+    createWireServices?: CreateWireServices;
     job: QueueJob;
     updateProgress?: (progress: number | string | object) => Promise<void>;
 }): Promise<void>;

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

@@ -1,7 +1,6 @@
 import { getErrorResponse, PikkuError } from '../../errors/error-handler.js';
 import { pikkuState } from '../../pikku-state.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
-import { PikkuWiringTypes, } from '../../types/core.types.js';
 /**
  * Error class for queue processor not found
  */
@@ -45,7 +44,6 @@ export const wireQueueWorker = (queueWorker) => {
         permissions: queueWorker.func.permissions,
         middleware: queueWorker.func.middleware,
         tags: queueWorker.func.tags,
-        docs: queueWorker.func.docs,
     });
     // Store processor definition in state - runtime adapters will pick this up
     const registrations = pikkuState('queue', 'registrations');
@@ -71,7 +69,7 @@ export async function removeQueueWorker(name) {
 /**
  * Process a single queue job - this function is called by queue consumers
  */
-export async function runQueueJob({ singletonServices, createSessionServices, job, updateProgress, }) {
+export async function runQueueJob({ singletonServices, createWireServices, job, updateProgress, }) {
     const logger = singletonServices.logger;
     const meta = pikkuState('queue', 'meta');
     const processorMeta = meta[job.queueName];
@@ -84,7 +82,7 @@ export async function runQueueJob({ singletonServices, createSessionServices, jo
     if (!queueWorker) {
         throw new Error(`Queue worker registration not found for: ${job.queueName}`);
     }
-    // Create the queue interaction object
+    // Create the queue wire object
     const queue = {
         queueName: job.queueName,
         jobId: job.id,
@@ -102,24 +100,19 @@ export async function runQueueJob({ singletonServices, createSessionServices, jo
     };
     try {
         logger.info(`Processing job ${job.id} in queue ${job.queueName}`);
-        // Use provided singleton services
-        const getAllServices = async () => {
-            const sessionServices = await createSessionServices?.(singletonServices, { queue }, undefined);
-            return {
-                ...singletonServices,
-                ...sessionServices,
-            };
+        const wire = {
+            queue,
         };
         // Execute the pikku function with the job data
-        const result = await runPikkuFunc(PikkuWiringTypes.queue, job.queueName, processorMeta.pikkuFuncName, {
+        const result = await runPikkuFunc('queue', job.queueName, processorMeta.pikkuFuncName, {
             singletonServices,
-            getAllServices,
+            createWireServices,
             auth: false,
             data: () => job.data,
             inheritedMiddleware: processorMeta.middleware,
             wireMiddleware: queueWorker.middleware,
             tags: queueWorker.tags,
-            interaction: { queue },
+            wire,
         });
         logger.debug(`Successfully processed job ${job.id} in queue ${job.queueName}`);
         return result;

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

@@ -1,4 +1,4 @@
-import { PikkuDocs, MiddlewareMetadata } from '../../types/core.types.js';
+import { CommonWireMeta } from '../../types/core.types.js';
 import { CorePikkuFunctionConfig } from '../../function/functions.types.js';
 import { QueueConfigMapping } from './validate-worker-config.js';
 /**
@@ -126,21 +126,13 @@ export interface QueueWorkers {
     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;
+export type QueueWorkersMeta = Record<string, CommonWireMeta & {
     queueName: string;
-    session?: undefined;
-    docs?: PikkuDocs;
-    tags?: string[];
     config?: PikkuWorkerConfig;
-    middleware?: MiddlewareMetadata[];
 }>;
 /**
  * Core queue processor definition
@@ -149,13 +141,12 @@ export type CoreQueueWorker<PikkuFunctionConfig extends CorePikkuFunctionConfig<
     queueName: string;
     func: PikkuFunctionConfig;
     config?: PikkuWorkerConfig;
-    docs?: PikkuDocs;
-    session?: undefined;
+    errors?: string[];
     tags?: string[];
     middleware?: PikkuFunctionConfig['middleware'];
 };
 /**
- * Represents a queue interaction object for middleware
+ * Represents a queue wire object for middleware
  * Provides information and actions for the current queue job execution
  */
 export interface PikkuQueue {

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

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

package/dist/wirings/rpc/index.js

@@ -1 +1 @@
-export { initialize, PikkuRPCService } from './rpc-runner.js';
+export { initialize, PikkuRPCService, rpcService } from './rpc-runner.js';

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

@@ -1,26 +1,32 @@
-import { CoreServices, PikkuInteraction } from '../../types/core.types.js';
+import { CoreServices, PikkuWire } from '../../types/core.types.js';
 import { PikkuRPC } from './rpc-types.js';
 type RPCServiceConfig = {
     coerceDataFromSchema: boolean;
 };
 export declare class ContextAwareRPCService {
     private services;
-    private interaction;
+    private wire;
     private options;
-    constructor(services: CoreServices, interaction: PikkuInteraction, options: {
+    constructor(services: CoreServices, wire: PikkuWire, options: {
         coerceDataFromSchema?: boolean;
         requiresAuth?: boolean;
     });
     rpcExposed(funcName: string, data: any): Promise<any>;
     rpc<In = any, Out = any>(funcName: string, data: In): Promise<Out>;
+    rpcWithWire<In = any, Out = any>(rpcName: string, data: In, wire: PikkuWire): Promise<Out>;
+    startWorkflow<In = any>(workflowName: string, input: In): Promise<{
+        runId: string;
+    }>;
 }
 export declare class PikkuRPCService<Services extends CoreServices, TypedRPC = PikkuRPC> {
     private config?;
     initialize(config: RPCServiceConfig): void;
-    injectRPCService(services: Services, interaction: PikkuInteraction, requiresAuth?: boolean | undefined, depth?: number): Services & {
-        rpc: TypedRPC;
-    };
+    getContextRPCService(services: Services, wire: PikkuWire, requiresAuth?: boolean | undefined, depth?: number): TypedRPC;
 }
-export declare const rpcService: PikkuRPCService<CoreServices, PikkuRPC>;
+export declare const rpcService: PikkuRPCService<import("../../types/core.types.js").CoreSingletonServices<{
+    logLevel?: import("../../index.js").LogLevel;
+    secrets?: {};
+    workflow?: import("../workflow/workflow.types.js").WorkflowServiceConfig;
+}>, PikkuRPC>;
 export declare const initialize: (config: RPCServiceConfig) => void;
 export {};