@pikku/core 0.11.0 → 0.11.2

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) {
@@ -15,39 +14,39 @@ export class MCPError extends Error {
     }
 }
 export const wireMCPResource = (mcpResource) => {
-    const resourcesMeta = pikkuState('mcp', 'resourcesMeta');
+    const resourcesMeta = pikkuState(null, 'mcp', 'resourcesMeta');
     const mcpResourceMeta = resourcesMeta[mcpResource.uri];
     if (!mcpResourceMeta) {
         throw new Error(`MCP resource metadata not found for '${mcpResource.uri}'`);
     }
     addFunction(mcpResourceMeta.pikkuFuncName, mcpResource.func);
-    const resources = pikkuState('mcp', 'resources');
+    const resources = pikkuState(null, 'mcp', 'resources');
     if (resources.has(mcpResource.uri)) {
         throw new Error(`MCP resource already exists: ${mcpResource.uri}`);
     }
     resources.set(mcpResource.uri, mcpResource);
 };
 export const wireMCPTool = (mcpTool) => {
-    const toolsMeta = pikkuState('mcp', 'toolsMeta');
+    const toolsMeta = pikkuState(null, 'mcp', 'toolsMeta');
     const mcpToolMeta = toolsMeta[mcpTool.name];
     if (!mcpToolMeta) {
         throw new Error(`MCP tool metadata not found for '${mcpTool.name}'`);
     }
     addFunction(mcpToolMeta.pikkuFuncName, mcpTool.func);
-    const tools = pikkuState('mcp', 'tools');
+    const tools = pikkuState(null, 'mcp', 'tools');
     if (tools.has(mcpTool.name)) {
         throw new Error(`MCP tool already exists: ${mcpTool.name}`);
     }
     tools.set(mcpTool.name, mcpTool);
 };
 export const wireMCPPrompt = (mcpPrompt) => {
-    const promptsMeta = pikkuState('mcp', 'promptsMeta');
+    const promptsMeta = pikkuState(null, 'mcp', 'promptsMeta');
     const mcpPromptMeta = promptsMeta[mcpPrompt.name];
     if (!mcpPromptMeta) {
         throw new Error(`MCP prompt metadata not found for '${mcpPrompt.name}'`);
     }
     addFunction(mcpPromptMeta.pikkuFuncName, mcpPrompt.func);
-    const prompts = pikkuState('mcp', 'prompts');
+    const prompts = pikkuState(null, 'mcp', 'prompts');
     if (prompts.has(mcpPrompt.name)) {
         throw new Error(`MCP prompt already exists: ${mcpPrompt.name}`);
     }
@@ -57,8 +56,8 @@ export async function runMCPResource(request, params, uri) {
     let endpoint;
     let pikkuFuncName;
     let extractedParams = {};
-    const metas = pikkuState('mcp', 'resourcesMeta');
-    const endpoints = pikkuState('mcp', 'resources');
+    const metas = pikkuState(null, 'mcp', 'resourcesMeta');
+    const endpoints = pikkuState(null, 'mcp', 'resources');
     if (endpoints.has(uri)) {
         endpoint = endpoints.get(uri);
         pikkuFuncName = metas[uri]?.pikkuFuncName;
@@ -88,20 +87,20 @@ export async function runMCPResource(request, params, uri) {
     }, 'resource', uri, endpoint, pikkuFuncName, { ...params, mcp: { ...params.mcp, uri } });
 }
 export async function runMCPTool(request, params, name) {
-    const endpoint = pikkuState('mcp', 'tools').get(name);
-    const meta = pikkuState('mcp', 'toolsMeta')[name];
+    const endpoint = pikkuState(null, 'mcp', 'tools').get(name);
+    const meta = pikkuState(null, 'mcp', 'toolsMeta')[name];
     return await runMCPPikkuFunc(request, 'tool', name, endpoint, meta?.pikkuFuncName, params);
 }
 export async function runMCPPrompt(request, params, name) {
-    const endpoint = pikkuState('mcp', 'prompts').get(name);
-    const meta = pikkuState('mcp', 'promptsMeta')[name];
+    const endpoint = pikkuState(null, 'mcp', 'prompts').get(name);
+    const meta = pikkuState(null, 'mcp', 'promptsMeta')[name];
     return await runMCPPikkuFunc(request, 'prompt', name, endpoint, meta?.pikkuFuncName, params);
 }
 /**
  * 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,37 +113,31 @@ 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;
         if (type === 'resource') {
-            meta = pikkuState('mcp', 'resourcesMeta')[name];
+            meta = pikkuState(null, 'mcp', 'resourcesMeta')[name];
         }
         else if (type === 'tool') {
-            meta = pikkuState('mcp', 'toolsMeta')[name];
+            meta = pikkuState(null, 'mcp', 'toolsMeta')[name];
         }
         else if (type === 'prompt') {
-            meta = pikkuState('mcp', 'promptsMeta')[name];
+            meta = pikkuState(null, '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,26 +167,26 @@ async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncName, { single
         }
     }
     finally {
-        if (sessionServices) {
-            await closeSessionServices(singletonServices.logger, sessionServices);
+        if (wireServices) {
+            await closeWireServices(singletonServices.logger, wireServices);
         }
     }
 }
 export const getMCPTools = () => {
-    return pikkuState('mcp', 'tools');
+    return pikkuState(null, 'mcp', 'tools');
 };
 export const getMCPResources = () => {
-    return pikkuState('mcp', 'resources');
+    return pikkuState(null, 'mcp', 'resources');
 };
 export const getMCPResourcesMeta = () => {
-    return pikkuState('mcp', 'resourcesMeta');
+    return pikkuState(null, 'mcp', 'resourcesMeta');
 };
 export const getMCPToolsMeta = () => {
-    return pikkuState('mcp', 'toolsMeta');
+    return pikkuState(null, 'mcp', 'toolsMeta');
 };
 export const getMCPPrompts = () => {
-    return pikkuState('mcp', 'prompts');
+    return pikkuState(null, 'mcp', 'prompts');
 };
 export const getMCPPromptsMeta = () => {
-    return pikkuState('mcp', 'promptsMeta');
+    return pikkuState(null, 'mcp', 'promptsMeta');
 };

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
  */
@@ -34,7 +32,7 @@ export class QueueJobDiscardedError extends PikkuError {
  */
 export const wireQueueWorker = (queueWorker) => {
     // Get processor metadata
-    const meta = pikkuState('queue', 'meta');
+    const meta = pikkuState(null, '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.`);
@@ -46,23 +44,22 @@ 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');
+    const registrations = pikkuState(null, 'queue', 'registrations');
     registrations.set(queueWorker.queueName, 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);
@@ -72,20 +69,20 @@ 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 meta = pikkuState(null, 'queue', 'meta');
     const processorMeta = meta[job.queueName];
     if (!processorMeta) {
         throw new Error(`Processor metadata not found for: ${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}`);
     }
-    // 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/index.d.ts

@@ -1,2 +1,2 @@
-export { initialize, PikkuRPCService, rpcService } from './rpc-runner.js';
+export { 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, rpcService } from './rpc-runner.js';
+export { PikkuRPCService, rpcService } from './rpc-runner.js';

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

@@ -1,30 +1,31 @@
-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: {
-        coerceDataFromSchema?: boolean;
+    constructor(services: CoreServices, wire: PikkuWire, options: {
         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>;
+    /**
+     * 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<{
         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 initialize: (config: RPCServiceConfig) => void;
-export {};
+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>;

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

@@ -1,9 +1,29 @@
-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';
+/**
+ * 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 packageName = externalPackages.get(namespace);
+    if (!packageName) {
+        return null;
+    }
+    return {
+        package: packageName,
+        function: functionName,
+    };
+};
 const getPikkuFunctionName = (rpcName) => {
-    const rpc = pikkuState('rpc', 'meta');
+    const rpc = pikkuState(null, 'rpc', 'meta');
     const rpcMeta = rpc[rpcName];
     if (!rpcMeta) {
         throw new Error(`RPC function not found: ${rpcName}`);
@@ -13,15 +33,15 @@ 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) {
-        const functionMeta = pikkuState('function', 'meta')[funcName];
+        const functionMeta = pikkuState(null, 'function', 'meta')[funcName];
         if (!functionMeta) {
             throw new Error(`Function not found: ${funcName}`);
         }
@@ -31,52 +51,83 @@ 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,
+        };
+        // 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,
-            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,
+    /**
+     * 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.pikkuFuncName || 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 = {
+            ...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) {
@@ -88,34 +139,20 @@ export class ContextAwareRPCService {
 }
 // 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
-    injectRPCService(services, interaction, requiresAuth, depth = 0) {
-        const serviceCopy = {
-            ...services,
-        };
-        const serviceRPC = new ContextAwareRPCService(serviceCopy, interaction, {
-            coerceDataFromSchema: this.config?.coerceDataFromSchema,
+    getContextRPCService(services, wire, requiresAuth, depth = 0) {
+        const serviceRPC = new ContextAwareRPCService(services, wire, {
             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
 export const rpcService = new PikkuRPCService();
-// Convenience function for initializing
-export const initialize = (config) => {
-    rpcService.initialize(config);
-};

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

@@ -15,3 +15,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/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;