@pikku/core 0.11.1 → 0.12.0

package/dist/wirings/oauth2/wire-oauth2-credential.js

@@ -0,0 +1,21 @@
+/**
+ * No-op function for declaring OAuth2 credentials.
+ * This exists purely for TypeScript type checking and will be tree-shaken.
+ * The CLI extracts metadata via AST parsing.
+ *
+ * @example
+ * ```typescript
+ * wireOAuth2Credential({
+ *   name: 'slackOAuth',
+ *   displayName: 'Slack OAuth',
+ *   secretId: 'SLACK_OAUTH_APP',
+ *   tokenSecretId: 'SLACK_OAUTH_TOKENS',
+ *   authorizationUrl: 'https://slack.com/oauth/v2/authorize',
+ *   tokenUrl: 'https://slack.com/api/oauth.v2.access',
+ *   scopes: ['chat:write', 'channels:read'],
+ * })
+ * ```
+ */
+export const wireOAuth2Credential = (_config) => {
+    // No-op - metadata only, extracted by CLI via AST
+};

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

@@ -1,5 +1,5 @@
-export type * from './queue.types.js';
-export { wireQueueWorker, runQueueJob, getQueueWorkers, removeQueueWorker, QueueJobDiscardedError, QueueJobFailedError, } from './queue-runner.js';
+export type { ConfigValidationResult, CoreQueueWorker, JobOptions, PikkuJobConfig, PikkuWorkerConfig, PikkuQueue, QueueJob, QueueJobStatus, QueueService, QueueWorkers, QueueWorkersMeta, } from './queue.types.js';
+export { wireQueueWorker, runQueueJob, createQueueJobRunner, getQueueWorkers, removeQueueWorker, QueueJobDiscardedError, QueueJobFailedError, } from './queue-runner.js';
 export { validateWorkerConfig } from './validate-worker-config.js';
 export type { QueueConfigMapping } from './validate-worker-config.js';
 export { registerQueueWorkers } from './register-queue-helper.js';

package/dist/wirings/queue/index.js

@@ -1,5 +1,5 @@
 // Queue processor management
-export { wireQueueWorker, runQueueJob, getQueueWorkers, removeQueueWorker, QueueJobDiscardedError, QueueJobFailedError, } from './queue-runner.js';
+export { wireQueueWorker, runQueueJob, createQueueJobRunner, getQueueWorkers, removeQueueWorker, QueueJobDiscardedError, QueueJobFailedError, } from './queue-runner.js';
 // Configuration validation
 export { validateWorkerConfig } from './validate-worker-config.js';
 // Queue registration helper

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

@@ -36,3 +36,10 @@ export declare function runQueueJob({ singletonServices, createWireServices, job
     job: QueueJob;
     updateProgress?: (progress: number | string | object) => Promise<void>;
 }): Promise<void>;
+export declare const createQueueJobRunner: ({ singletonServices, createWireServices, }: {
+    singletonServices: CoreServices;
+    createWireServices?: CreateWireServices;
+}) => ({ job, updateProgress, }: {
+    job: QueueJob;
+    updateProgress?: (progress: number | string | object) => Promise<void>;
+}) => Promise<void>;

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

@@ -1,4 +1,5 @@
 import { getErrorResponse, PikkuError } from '../../errors/error-handler.js';
+import { PikkuMissingMetaError } from '../../errors/errors.js';
 import { pikkuState } from '../../pikku-state.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 /**
@@ -32,13 +33,13 @@ export class QueueJobDiscardedError extends PikkuError {
  */
 export const wireQueueWorker = (queueWorker) => {
     // Get processor metadata
-    const meta = pikkuState('queue', 'meta');
-    const processorMeta = meta[queueWorker.queueName];
+    const meta = pikkuState(null, 'queue', 'meta');
+    const processorMeta = meta[queueWorker.name];
     if (!processorMeta) {
-        throw new Error(`Queue processor metadata not found for '${queueWorker.queueName}'. Make sure to run the CLI to generate metadata.`);
+        throw new PikkuMissingMetaError(`Missing generated metadata for queue worker '${queueWorker.name}'`);
     }
     // Register the function with pikku
-    addFunction(processorMeta.pikkuFuncName, {
+    addFunction(processorMeta.pikkuFuncId, {
         func: queueWorker.func.func,
         auth: queueWorker.func.auth,
         permissions: queueWorker.func.permissions,
@@ -46,20 +47,20 @@ export const wireQueueWorker = (queueWorker) => {
         tags: queueWorker.func.tags,
     });
     // Store processor definition in state - runtime adapters will pick this up
-    const registrations = pikkuState('queue', 'registrations');
-    registrations.set(queueWorker.queueName, queueWorker);
+    const registrations = pikkuState(null, 'queue', 'registrations');
+    registrations.set(queueWorker.name, queueWorker);
 };
 /**
  * Get all registered queue processors
  */
 export function getQueueWorkers() {
-    return pikkuState('queue', 'registrations');
+    return pikkuState(null, 'queue', 'registrations');
 }
 /**
  * Stop and remove a queue processor
  */
 export async function removeQueueWorker(name) {
-    const registrations = pikkuState('queue', 'registrations');
+    const registrations = pikkuState(null, 'queue', 'registrations');
     const registration = registrations.get(name);
     if (!registration) {
         throw new QueueWorkerNotFoundError(name);
@@ -71,13 +72,13 @@ export async function removeQueueWorker(name) {
  */
 export async function runQueueJob({ singletonServices, createWireServices, job, updateProgress, }) {
     const logger = singletonServices.logger;
-    const meta = pikkuState('queue', 'meta');
+    const meta = pikkuState(null, 'queue', 'meta');
     const processorMeta = meta[job.queueName];
     if (!processorMeta) {
-        throw new Error(`Processor metadata not found for: ${job.queueName}`);
+        throw new PikkuMissingMetaError(`Missing generated metadata for queue worker '${job.queueName}'`);
     }
     // Get the queue worker registration to access middleware
-    const registrations = pikkuState('queue', 'registrations');
+    const registrations = pikkuState(null, 'queue', 'registrations');
     const queueWorker = registrations.get(job.queueName);
     if (!queueWorker) {
         throw new Error(`Queue worker registration not found for: ${job.queueName}`);
@@ -104,7 +105,7 @@ export async function runQueueJob({ singletonServices, createWireServices, job,
             queue,
         };
         // Execute the pikku function with the job data
-        const result = await runPikkuFunc('queue', job.queueName, processorMeta.pikkuFuncName, {
+        const result = await runPikkuFunc('queue', job.queueName, processorMeta.pikkuFuncId, {
             singletonServices,
             createWireServices,
             auth: false,
@@ -127,3 +128,13 @@ export async function runQueueJob({ singletonServices, createWireServices, job,
         throw error;
     }
 }
+export const createQueueJobRunner = ({ singletonServices, createWireServices, }) => {
+    return async ({ job, updateProgress, }) => {
+        await runQueueJob({
+            singletonServices,
+            createWireServices,
+            job,
+            updateProgress,
+        });
+    };
+};

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

@@ -1,6 +1,7 @@
 import { CommonWireMeta } from '../../types/core.types.js';
 import { CorePikkuFunctionConfig } from '../../function/functions.types.js';
 import { QueueConfigMapping } from './validate-worker-config.js';
+import { Logger } from '../../services/logger.js';
 /**
  * Configuration for queue workers - how jobs are processed
  */
@@ -124,6 +125,11 @@ export interface QueueWorkers {
     supportsResults: boolean;
     /** Configuration mapping for validation */
     configMappings: QueueConfigMapping;
+    /** Set runtime queue job runner callback and logger */
+    setJobRunner(runJob: (params: {
+        job: QueueJob;
+        updateProgress?: (progress: number | string | object) => Promise<void>;
+    }) => Promise<void>, logger: Logger): void;
     /** Scan state and register all compatible processors */
     registerQueues(): Promise<Record<string, ConfigValidationResult[]>>;
 }
@@ -131,14 +137,14 @@ export interface QueueWorkers {
  * Queue processor metadata
  */
 export type QueueWorkersMeta = Record<string, CommonWireMeta & {
-    queueName: string;
+    name: string;
     config?: PikkuWorkerConfig;
 }>;
 /**
  * Core queue processor definition
  */
 export type CoreQueueWorker<PikkuFunctionConfig extends CorePikkuFunctionConfig<any, any, any> = CorePikkuFunctionConfig<any, any, any>> = {
-    queueName: string;
+    name: string;
     func: PikkuFunctionConfig;
     config?: PikkuWorkerConfig;
     errors?: string[];

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

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

package/dist/wirings/rpc/index.js

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

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

@@ -1,32 +1,59 @@
-import { CoreServices, PikkuWire } from '../../types/core.types.js';
+import { CoreServices, CoreSingletonServices, PikkuWire } from '../../types/core.types.js';
+import type { SessionService } from '../../services/user-session-service.js';
+import type { CoreUserSession } from '../../types/core.types.js';
+import { PikkuError } from '../../errors/error-handler.js';
 import { PikkuRPC } from './rpc-types.js';
-type RPCServiceConfig = {
-    coerceDataFromSchema: boolean;
-};
+export declare class RPCNotFoundError extends PikkuError {
+    readonly rpcName: string;
+    constructor(rpcName: string);
+}
+import type { AIAgentInput } from '../ai-agent/ai-agent.types.js';
 export declare class ContextAwareRPCService {
     private services;
     private wire;
     private options;
     constructor(services: CoreServices, wire: PikkuWire, options: {
-        coerceDataFromSchema?: boolean;
         requiresAuth?: boolean;
+        sessionService?: SessionService<CoreUserSession>;
     });
     rpcExposed(funcName: string, data: any): Promise<any>;
     rpc<In = any, Out = any>(funcName: string, data: In): Promise<Out>;
+    /**
+     * Invoke a function from an external package
+     * External packages register their functions in pikkuState under their package name.
+     * The function is executed using the parent services (shared singleton services).
+     * @private
+     */
+    private invokeExternalPackageFunction;
     rpcWithWire<In = any, Out = any>(rpcName: string, data: In, wire: PikkuWire): Promise<Out>;
-    startWorkflow<In = any>(workflowName: string, input: In): Promise<{
+    startWorkflow<In = any>(workflowName: string, input: In, options?: {
+        startNode?: string;
+        wire?: {
+            type: string;
+            id?: string;
+            parentRunId?: string;
+        };
+    }): Promise<{
+        runId: string;
+    }>;
+    agent(agentName: string, input: AIAgentInput): Promise<{
         runId: string;
+        result: unknown;
+        usage: {
+            inputTokens: number;
+            outputTokens: number;
+        };
     }>;
+    remote<In = any, Out = any>(funcName: string, data: In): Promise<Out>;
 }
 export declare class PikkuRPCService<Services extends CoreServices, TypedRPC = PikkuRPC> {
-    private config?;
-    initialize(config: RPCServiceConfig): void;
-    getContextRPCService(services: Services, wire: PikkuWire, requiresAuth?: boolean | undefined, depth?: number): TypedRPC;
+    getContextRPCService(services: Services, wire: PikkuWire, requiresAuthOrOptions?: boolean | {
+        requiresAuth?: boolean;
+        sessionService?: SessionService<CoreUserSession>;
+    } | undefined, depth?: number): TypedRPC;
 }
-export declare const rpcService: PikkuRPCService<import("../../types/core.types.js").CoreSingletonServices<{
-    logLevel?: import("../../index.js").LogLevel;
+export declare const rpcService: PikkuRPCService<CoreSingletonServices<{
+    logLevel?: import("../../services/logger.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,11 +1,49 @@
 import { runPikkuFunc } from '../../function/function-runner.js';
 import { pikkuState } from '../../pikku-state.js';
 import { ForbiddenError } from '../../errors/errors.js';
+import { PikkuError } from '../../errors/error-handler.js';
+import { parseVersionedId } from '../../version.js';
+import { encryptJSON } from '../../crypto-utils.js';
+export class RPCNotFoundError extends PikkuError {
+    rpcName;
+    constructor(rpcName) {
+        super(`RPC function not found: ${rpcName}`);
+        this.rpcName = rpcName;
+    }
+}
+import { runAIAgent } from '../ai-agent/ai-agent-runner.js';
+/**
+ * Resolve a namespaced function reference to package and function names
+ * Uses pikkuState to look up the namespace -> package mapping
+ */
+const resolveNamespace = (namespacedFunction) => {
+    const colonIndex = namespacedFunction.indexOf(':');
+    if (colonIndex === -1) {
+        return null;
+    }
+    const namespace = namespacedFunction.substring(0, colonIndex);
+    const functionName = namespacedFunction.substring(colonIndex + 1);
+    const externalPackages = pikkuState(null, 'rpc', 'externalPackages');
+    const pkgConfig = externalPackages.get(namespace);
+    if (!pkgConfig) {
+        return null;
+    }
+    return {
+        package: pkgConfig.package,
+        function: functionName,
+    };
+};
 const getPikkuFunctionName = (rpcName) => {
-    const rpc = pikkuState('rpc', 'meta');
-    const rpcMeta = rpc[rpcName];
+    const rpc = pikkuState(null, 'rpc', 'meta');
+    let rpcMeta = rpc[rpcName];
     if (!rpcMeta) {
-        throw new Error(`RPC function not found: ${rpcName}`);
+        const { baseName, version } = parseVersionedId(rpcName);
+        if (version !== null) {
+            rpcMeta = rpc[baseName];
+        }
+    }
+    if (!rpcMeta) {
+        throw new RPCNotFoundError(rpcName);
     }
     return rpcMeta;
 };
@@ -20,7 +58,16 @@ export class ContextAwareRPCService {
         this.options = options;
     }
     async rpcExposed(funcName, data) {
-        const functionMeta = pikkuState('function', 'meta')[funcName];
+        let functionMeta;
+        if (funcName.includes(':')) {
+            const resolved = resolveNamespace(funcName);
+            if (resolved) {
+                functionMeta = pikkuState(resolved.package, 'function', 'meta')[resolved.function];
+            }
+        }
+        else {
+            functionMeta = pikkuState(null, 'function', 'meta')[funcName];
+        }
         if (!functionMeta) {
             throw new Error(`Function not found: ${funcName}`);
         }
@@ -41,16 +88,52 @@ export class ContextAwareRPCService {
                 }
                 : undefined,
         };
+        // Check if it's a namespaced function call (e.g., 'stripe:createCharge')
+        if (funcName.includes(':')) {
+            return this.invokeExternalPackageFunction(funcName, data, updatedWire);
+        }
+        // Main package function
         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,
             data: () => data,
-            coerceDataFromSchema: this.options.coerceDataFromSchema,
             wire: updatedWire,
         });
     }
+    /**
+     * Invoke a function from an external package
+     * External packages register their functions in pikkuState under their package name.
+     * The function is executed using the parent services (shared singleton services).
+     * @private
+     */
+    async invokeExternalPackageFunction(namespacedFunction, data, wire) {
+        // Resolve namespace to package name
+        const resolved = resolveNamespace(namespacedFunction);
+        if (!resolved) {
+            throw new Error(`Unknown namespace in function reference: ${namespacedFunction}. ` +
+                `Make sure the package is registered in externalPackages config.`);
+        }
+        // Get the function meta from the external package
+        // External packages use function meta, not RPC meta
+        const externalFunctionMeta = pikkuState(resolved.package, 'function', 'meta');
+        const funcMeta = externalFunctionMeta[resolved.function];
+        if (!funcMeta) {
+            throw new Error(`Function '${resolved.function}' not found in package '${resolved.package}'. ` +
+                `Available functions: ${Object.keys(externalFunctionMeta).join(', ') || '(none)'}`);
+        }
+        const funcName = funcMeta.pikkuFuncId || resolved.function;
+        // Execute the function using runPikkuFunc with the external package's state
+        // We use the parent services (this.services) since external packages share services
+        // Pass the function's tags so tag-based middleware/permissions are applied
+        return runPikkuFunc('rpc', namespacedFunction, funcName, {
+            auth: this.options.requiresAuth,
+            singletonServices: this.services,
+            data: () => data,
+            wire,
+            packageName: resolved.package,
+            tags: funcMeta.tags,
+        });
+    }
     async rpcWithWire(rpcName, data, wire) {
         const rpcDepth = this.wire.rpc?.depth || 0;
         const mergedWire = {
@@ -68,43 +151,126 @@ export class ContextAwareRPCService {
             auth: this.options.requiresAuth,
             singletonServices: this.services,
             data: () => data,
-            coerceDataFromSchema: this.options.coerceDataFromSchema,
             wire: mergedWire,
         });
     }
-    async startWorkflow(workflowName, input) {
+    async startWorkflow(workflowName, input, options) {
         if (!this.services.workflowService) {
             throw new Error('WorkflowService service not available');
         }
-        return this.services.workflowService.startWorkflow(workflowName, input, this);
+        const parentRunId = this.wire.workflowStep?.runId ?? this.wire.graph?.runId;
+        const wire = options?.wire ?? {
+            type: this.wire.wireType ?? 'unknown',
+            id: this.wire.wireId,
+            ...(parentRunId ? { parentRunId } : {}),
+        };
+        return this.services.workflowService.startWorkflow(workflowName, input, wire, this, options);
+    }
+    async agent(agentName, input) {
+        const result = await runAIAgent(agentName, input, {
+            singletonServices: this.services,
+            sessionService: this.options.sessionService,
+        });
+        return {
+            runId: result.runId,
+            result: result.object ?? result.text,
+            usage: result.usage,
+        };
+    }
+    async remote(funcName, data) {
+        let endpoint;
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        const colonIndex = funcName.indexOf(':');
+        if (colonIndex !== -1) {
+            const namespace = funcName.substring(0, colonIndex);
+            const externalPackages = pikkuState(null, 'rpc', 'externalPackages');
+            const pkgConfig = externalPackages.get(namespace);
+            endpoint = pkgConfig?.rpcEndpoint;
+        }
+        if (!endpoint && this.services.deploymentService) {
+            const deployments = await this.services.deploymentService.findFunction(funcName);
+            if (deployments.length > 0) {
+                endpoint = deployments[0].endpoint;
+            }
+        }
+        if (!endpoint) {
+            throw new Error(`No endpoint configured for remote RPC: ${funcName}. ` +
+                `Configure rpcEndpoint in externalPackages config or set up a DeploymentService.`);
+        }
+        let secret;
+        if (this.services.secrets) {
+            try {
+                secret = await this.services.secrets.getSecret('PIKKU_REMOTE_SECRET');
+            }
+            catch { }
+        }
+        if (secret) {
+            if (!this.services.jwt) {
+                throw new Error('PIKKU_REMOTE_SECRET is set but JWT service is not available');
+            }
+            const session = this.wire.getSession && typeof this.wire.getSession === 'function'
+                ? await this.wire.getSession()
+                : this.wire.session;
+            const sessionEnc = session
+                ? await encryptJSON(secret, { session })
+                : undefined;
+            const token = await this.services.jwt.encode({ value: 5, unit: 'minute' }, {
+                aud: 'pikku-remote',
+                fn: funcName,
+                iat: Date.now(),
+                session: sessionEnc,
+            });
+            headers.Authorization = `Bearer ${token}`;
+        }
+        const url = `${endpoint}/rpc/${encodeURIComponent(funcName)}`;
+        const timeoutMs = 30_000;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({ data }),
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!response.ok) {
+            let errorBody;
+            try {
+                errorBody = JSON.stringify(await response.json());
+            }
+            catch {
+                errorBody = await response.text();
+            }
+            throw new Error(`Remote RPC call failed: ${response.status} ${response.statusText}. ${errorBody}`);
+        }
+        try {
+            return (await response.json());
+        }
+        catch {
+            const text = await response.text();
+            throw new Error(`Remote RPC call returned non-JSON response: ${response.status} ${response.statusText}. ${text}`);
+        }
     }
 }
 // RPC Service class for the global interface
 export class PikkuRPCService {
-    config;
-    // Initialize the RPC service with configuration
-    initialize(config) {
-        this.config = config;
-    }
     // Convenience function for initializing
-    getContextRPCService(services, wire, requiresAuth, depth = 0) {
-        const serviceRPC = new ContextAwareRPCService(services, wire, {
-            coerceDataFromSchema: this.config?.coerceDataFromSchema,
-            requiresAuth,
-        });
+    getContextRPCService(services, wire, requiresAuthOrOptions, depth = 0) {
+        const options = typeof requiresAuthOrOptions === 'object' &&
+            requiresAuthOrOptions !== null
+            ? requiresAuthOrOptions
+            : { requiresAuth: requiresAuthOrOptions };
+        const serviceRPC = new ContextAwareRPCService(services, wire, options);
         return {
             depth,
             global: false,
             invoke: serviceRPC.rpc.bind(serviceRPC),
-            invokeExposed: serviceRPC.rpc.bind(serviceRPC),
+            remote: serviceRPC.remote.bind(serviceRPC),
+            exposed: serviceRPC.rpcExposed.bind(serviceRPC),
             startWorkflow: serviceRPC.startWorkflow.bind(serviceRPC),
+            agent: serviceRPC.agent.bind(serviceRPC),
             rpcWithWire: serviceRPC.rpcWithWire.bind(serviceRPC),
         };
     }
 }
 // Create a singleton instance
 export const rpcService = new PikkuRPCService();
-// Convenience function for initializing
-export const initialize = (config) => {
-    rpcService.initialize(config);
-};

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

@@ -1,12 +1,16 @@
-export type PikkuRPC<invoke extends Function = any> = {
+export type PikkuRPC<Invoke extends Function = any, Remote extends Function = any, startWorkflow extends Function = any, Agent extends Function = any> = {
     depth: number;
     global: boolean;
-    invoke: invoke;
+    invoke: Invoke;
+    remote: Remote;
+    exposed: (name: string, data: any) => Promise<any>;
+    startWorkflow: startWorkflow;
+    agent: Agent;
 };
 export type RPCMeta = {
-    pikkuFuncName: string;
+    pikkuFuncId: string;
     expose: boolean;
-    internal?: boolean;
+    remote?: boolean;
 };
 /**
  * Type for RPC handlers
@@ -15,3 +19,10 @@ export interface RPCHandler<Input, Output> {
     input: Input;
     output: Output;
 }
+/**
+ * Resolved function reference from namespace
+ */
+export interface ResolvedFunction {
+    package: string;
+    function: string;
+}

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

@@ -1,3 +1,3 @@
-export * from './scheduler.types.js';
-export { runScheduledTask, wireScheduler, getScheduledTasks, } from './scheduler-runner.js';
-export * from './log-schedulers.js';
+export { runScheduledTask, createSchedulerRuntimeHandlers, wireScheduler, getScheduledTasks, } from './scheduler-runner.js';
+export { logSchedulers } from './log-schedulers.js';
+export type { CoreScheduledTask, ScheduledTasksMeta, PikkuScheduledTask, } from './scheduler.types.js';

package/dist/wirings/scheduler/index.js

@@ -1,3 +1,2 @@
-export * from './scheduler.types.js';
-export { runScheduledTask, wireScheduler, getScheduledTasks, } from './scheduler-runner.js';
-export * from './log-schedulers.js';
+export { runScheduledTask, createSchedulerRuntimeHandlers, wireScheduler, getScheduledTasks, } from './scheduler-runner.js';
+export { logSchedulers } from './log-schedulers.js';

package/dist/wirings/scheduler/log-schedulers.js

@@ -4,7 +4,7 @@ import { pikkuState } from '../../pikku-state.js';
  * @param logger - A logger for logging information.
  */
 export const logSchedulers = (logger) => {
-    const scheduledTasks = pikkuState('scheduler', 'tasks');
+    const scheduledTasks = pikkuState(null, 'scheduler', 'tasks');
     if (scheduledTasks.size === 0) {
         logger.info('No scheduled tasks added');
         return;

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

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