@pikku/core 0.11.0 → 0.11.1

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,8 +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';
-import { rpcService } from '../rpc/rpc-runner.js';
 /**
  * Error class for queue processor not found
  */
@@ -46,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');
@@ -72,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];
@@ -85,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,
@@ -103,26 +100,19 @@ export async function runQueueJob({ singletonServices, createSessionServices, jo
     };
     try {
         logger.info(`Processing job ${job.id} in queue ${job.queueName}`);
-        const interaction = { queue };
-        // Use provided singleton services
-        const getAllServices = async () => {
-            const sessionServices = await createSessionServices?.(singletonServices, { queue }, undefined);
-            const services = rpcService.injectRPCService({
-                ...singletonServices,
-                ...sessionServices,
-            }, interaction, false);
-            return services;
+        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,
+            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';
 /**
@@ -130,15 +130,9 @@ export interface QueueWorkers {
 /**
  * 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
@@ -147,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/rpc-runner.d.ts

@@ -1,19 +1,19 @@
-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>;
-    rpcWithInteraction<In = any, Out = any>(funcName: string, data: In, interaction: PikkuInteraction): 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;
     }>;
@@ -21,10 +21,12 @@ export declare class ContextAwareRPCService {
 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 {};

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

@@ -1,4 +1,3 @@
-import { PikkuWiringTypes, } from '../../types/core.types.js';
 import { runPikkuFunc } from '../../function/function-runner.js';
 import { pikkuState } from '../../pikku-state.js';
 import { ForbiddenError } from '../../errors/errors.js';
@@ -13,11 +12,11 @@ const getPikkuFunctionName = (rpcName) => {
 // Context-aware RPC client for use within services
 export class ContextAwareRPCService {
     services;
-    interaction;
+    wire;
     options;
-    constructor(services, interaction, options) {
+    constructor(services, wire, options) {
         this.services = services;
-        this.interaction = interaction;
+        this.wire = wire;
         this.options = options;
     }
     async rpcExposed(funcName, data) {
@@ -31,52 +30,46 @@ export class ContextAwareRPCService {
         return await this.rpc(funcName, data);
     }
     async rpc(funcName, data) {
-        const rpcDepth = this.services.rpc?.depth || 0;
-        return runPikkuFunc(PikkuWiringTypes.rpc, funcName, getPikkuFunctionName(funcName), {
+        const rpcDepth = this.wire.rpc?.depth || 0;
+        const updatedWire = {
+            ...this.wire,
+            rpc: this.wire.rpc
+                ? {
+                    ...this.wire.rpc,
+                    depth: rpcDepth + 1,
+                    global: false,
+                }
+                : undefined,
+        };
+        return runPikkuFunc('rpc', funcName, getPikkuFunctionName(funcName), {
             auth: this.options.requiresAuth,
+            // TODO: this is a hack since services have already been created
+            // but is valid since we don't want to keep creating new wire services
             singletonServices: this.services,
-            getAllServices: () => {
-                this.services.rpc = this.services.rpc
-                    ? {
-                        ...this.services.rpc,
-                        depth: rpcDepth + 1,
-                        global: false,
-                    }
-                    : undefined;
-                return this.services;
-            },
             data: () => data,
-            userSession: this.services.userSession,
             coerceDataFromSchema: this.options.coerceDataFromSchema,
-            interaction: this.interaction,
+            wire: updatedWire,
         });
     }
-    async rpcWithInteraction(funcName, data, interaction) {
-        const rpcDepth = this.services.rpc?.depth || 0;
-        const mergedInteraction = {
-            ...this.interaction,
-            ...interaction,
+    async rpcWithWire(rpcName, data, wire) {
+        const rpcDepth = this.wire.rpc?.depth || 0;
+        const mergedWire = {
+            ...this.wire,
+            ...wire,
+            rpc: this.wire.rpc
+                ? {
+                    ...this.wire.rpc,
+                    depth: rpcDepth + 1,
+                    global: false,
+                }
+                : undefined,
         };
-        return runPikkuFunc(PikkuWiringTypes.rpc, funcName, getPikkuFunctionName(funcName), {
+        return runPikkuFunc('rpc', rpcName, getPikkuFunctionName(rpcName), {
             auth: this.options.requiresAuth,
             singletonServices: this.services,
-            getAllServices: () => {
-                this.services.rpc = this.services.rpc
-                    ? {
-                        ...this.services.rpc,
-                        depth: rpcDepth + 1,
-                        global: false,
-                    }
-                    : undefined;
-                return {
-                    ...this.services,
-                    ...mergedInteraction,
-                };
-            },
             data: () => data,
-            userSession: this.services.userSession,
             coerceDataFromSchema: this.options.coerceDataFromSchema,
-            interaction: mergedInteraction,
+            wire: mergedWire,
         });
     }
     async startWorkflow(workflowName, input) {
@@ -94,23 +87,19 @@ export class PikkuRPCService {
         this.config = config;
     }
     // Convenience function for initializing
-    injectRPCService(services, interaction, requiresAuth, depth = 0) {
-        const serviceCopy = {
-            ...services,
-        };
-        const serviceRPC = new ContextAwareRPCService(serviceCopy, interaction, {
+    getContextRPCService(services, wire, requiresAuth, depth = 0) {
+        const serviceRPC = new ContextAwareRPCService(services, wire, {
             coerceDataFromSchema: this.config?.coerceDataFromSchema,
             requiresAuth,
         });
-        serviceCopy.rpc = {
+        return {
             depth,
             global: false,
             invoke: serviceRPC.rpc.bind(serviceRPC),
             invokeExposed: serviceRPC.rpc.bind(serviceRPC),
             startWorkflow: serviceRPC.startWorkflow.bind(serviceRPC),
-            rpcWithInteraction: serviceRPC.rpcWithInteraction.bind(serviceRPC),
+            rpcWithWire: serviceRPC.rpcWithWire.bind(serviceRPC),
         };
-        return serviceCopy;
     }
 }
 // Create a singleton instance

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

@@ -1,12 +1,12 @@
-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 { CoreScheduledTask } from './scheduler.types.js';
 import { CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from '../../function/functions.types.js';
 export type RunScheduledTasksParams = {
     name: string;
     session?: CoreUserSession;
     singletonServices: CoreSingletonServices;
-    createSessionServices?: CreateSessionServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
+    createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
 };
 export declare const wireScheduler: <PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunctionSessionless<void, void>>>(scheduledTask: CoreScheduledTask<PikkuFunctionConfig>) => void;
-export declare function runScheduledTask({ name, session, singletonServices, createSessionServices, }: RunScheduledTasksParams): Promise<void>;
+export declare function runScheduledTask({ name, session, singletonServices, createWireServices, }: RunScheduledTasksParams): Promise<void>;
 export declare const getScheduledTasks: () => Map<string, CoreScheduledTask>;

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

@@ -1,10 +1,8 @@
-import { PikkuWiringTypes, } from '../../types/core.types.js';
 import { getErrorResponse, PikkuError } 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 { PikkuUserSessionService } from '../../services/user-session-service.js';
+import { PikkuSessionService } from '../../services/user-session-service.js';
 export const wireScheduler = (scheduledTask) => {
     const meta = pikkuState('scheduler', 'meta');
     const taskMeta = meta[scheduledTask.name];
@@ -17,7 +15,6 @@ export const wireScheduler = (scheduledTask) => {
         permissions: scheduledTask.func.permissions,
         middleware: scheduledTask.func.middleware,
         tags: scheduledTask.func.tags,
-        docs: scheduledTask.func.docs,
     });
     const tasks = pikkuState('scheduler', 'tasks');
     if (tasks.has(scheduledTask.name)) {
@@ -36,11 +33,11 @@ class ScheduledTaskSkippedError extends PikkuError {
         this.name = 'ScheduledTaskSkippedError';
     }
 }
-export async function runScheduledTask({ name, session, singletonServices, createSessionServices, }) {
-    let sessionServices;
+export async function runScheduledTask({ name, session, singletonServices, createWireServices, }) {
+    let wireServices;
     const task = pikkuState('scheduler', 'tasks').get(name);
     const meta = pikkuState('scheduler', 'meta')[name];
-    const userSession = new PikkuUserSessionService();
+    const userSession = new PikkuSessionService();
     if (session) {
         userSession.set(session);
     }
@@ -50,8 +47,8 @@ export async function runScheduledTask({ name, session, singletonServices, creat
     if (!meta) {
         throw new ScheduledTaskNotFoundError(`Scheduled task meta not found: ${name}`);
     }
-    // Create the scheduled task interaction object
-    const interaction = {
+    // Create the scheduled task wire object
+    const wire = {
         scheduledTask: {
             name,
             schedule: task.schedule,
@@ -60,28 +57,20 @@ export async function runScheduledTask({ name, session, singletonServices, creat
                 throw new ScheduledTaskSkippedError(name, reason);
             },
         },
+        session: userSession,
     };
     try {
         singletonServices.logger.info(`Running schedule task: ${name} | schedule: ${task.schedule}`);
-        const getAllServices = async () => {
-            sessionServices = await createSessionServices?.(singletonServices, interaction, session);
-            return rpcService.injectRPCService({
-                ...singletonServices,
-                ...sessionServices,
-            }, interaction);
-        };
-        const result = await runPikkuFunc(PikkuWiringTypes.scheduler, meta.name, meta.pikkuFuncName, {
+        await runPikkuFunc('scheduler', meta.name, meta.pikkuFuncName, {
             singletonServices,
-            getAllServices,
-            userSession,
+            createWireServices,
             auth: false,
             data: () => undefined,
             inheritedMiddleware: meta.middleware,
             wireMiddleware: task.middleware,
             tags: task.tags,
-            interaction,
+            wire,
         });
-        return result;
     }
     catch (e) {
         const errorResponse = getErrorResponse(e);
@@ -91,8 +80,8 @@ export async function runScheduledTask({ name, session, singletonServices, creat
         throw e;
     }
     finally {
-        if (sessionServices) {
-            await closeSessionServices(singletonServices.logger, sessionServices);
+        if (wireServices) {
+            await closeWireServices(singletonServices.logger, wireServices);
         }
     }
 }

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

@@ -1,16 +1,12 @@
-import { PikkuDocs, CoreUserSession, CorePikkuMiddleware, MiddlewareMetadata } from '../../types/core.types.js';
+import { CoreUserSession, CorePikkuMiddleware, CommonWireMeta } from '../../types/core.types.js';
 import { CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from '../../function/functions.types.js';
 /**
  * Represents metadata for scheduled tasks, including title, schedule, and documentation.
  */
-export type ScheduledTasksMeta<UserSession extends CoreUserSession = any> = Record<string, {
-    pikkuFuncName: string;
+export type ScheduledTasksMeta<UserSession extends CoreUserSession = any> = Record<string, CommonWireMeta & {
     name: string;
     schedule: string;
     session?: UserSession;
-    docs?: PikkuDocs;
-    tags?: string[];
-    middleware?: MiddlewareMetadata[];
 }>;
 /**
  * Represents a core scheduled task.
@@ -19,12 +15,11 @@ export type CoreScheduledTask<PikkuFunctionConfig = CorePikkuFunctionConfig<Core
     name: string;
     schedule: string;
     func: PikkuFunctionConfig;
-    docs?: PikkuDocs;
     tags?: string[];
     middleware?: PikkuMiddleware[];
 };
 /**
- * Represents a scheduled task interaction object for middleware
+ * Represents a scheduled task wire object for middleware
  * Provides information about the current scheduled task execution
  */
 export interface PikkuScheduledTask {

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

@@ -1,6 +1,15 @@
 /**
  * Workflow module exports
  */
-export type { CoreWorkflow, WorkflowStepOptions, WorkflowStepMeta, PikkuWorkflowInteraction, PikkuWorkflow, WorkflowsMeta, WorkflowRun, StepState, WorkflowStatus, StepStatus, } from './workflow.types.js';
+export type { CoreWorkflow, WorkflowStepOptions, WorkflowStepMeta, RpcStepMeta, BranchStepMeta, ParallelGroupStepMeta, FanoutStepMeta, ReturnStepMeta, InlineStepMeta, SleepStepMeta, CancelStepMeta, InputSource, OutputBinding, PikkuWorkflowWire, PikkuWorkflow, WorkflowsMeta, WorkflowRun, StepState, WorkflowStatus, StepStatus, } from './workflow.types.js';
 export { PikkuWorkflowService } from './pikku-workflow-service.js';
-export { wireWorkflow } from './workflow-runner.js';
+export { addWorkflow } from './workflow-runner.js';
+/**
+ * @deprecated This function is no longer used and will be removed in a future release.
+ * It exists only for backwards compatibility with generated code.
+ * TODO: Remove this export in a future release after updating code generation
+ */
+export declare const wireWorkflow: <T extends {
+    name: string;
+    func: any;
+}>(workflow: T) => void;

package/dist/wirings/workflow/index.js

@@ -2,5 +2,13 @@
  * Workflow module exports
  */
 export { PikkuWorkflowService } from './pikku-workflow-service.js';
-// Functions
-export { wireWorkflow } from './workflow-runner.js';
+// Internal registration function (used by generated code)
+export { addWorkflow } from './workflow-runner.js';
+/**
+ * @deprecated This function is no longer used and will be removed in a future release.
+ * It exists only for backwards compatibility with generated code.
+ * TODO: Remove this export in a future release after updating code generation
+ */
+export const wireWorkflow = (workflow) => {
+    // Empty function - no longer used, kept for backwards compatibility
+};