@pikku/core 0.12.13 → 0.12.15

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

@@ -1,9 +1,8 @@
-import { NotFoundError, PikkuMissingMetaError } from '../../errors/errors.js';
+import { NotFoundError } from '../../errors/errors.js';
 import { closeWireServices, createWeakUID, isSerializable, } from '../../utils.js';
 import { getSingletonServices, getCreateWireServices, } from '../../pikku-state.js';
 import { PikkuSessionService } from '../../services/user-session-service.js';
 import { getErrorResponse } from '../../errors/error-handler.js';
-import { PikkuCredentialWireService, createMiddlewareCredentialWireProps, } from '../../services/credential-wire-service.js';
 import { handleHTTPError } from '../../handle-error.js';
 import { pikkuState } from '../../pikku-state.js';
 import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
@@ -113,7 +112,12 @@ export const wireHTTP = (httpWiring) => {
     const httpMeta = pikkuState(null, 'http', 'meta');
     const routeMeta = httpMeta[httpWiring.method][httpWiring.route];
     if (!routeMeta) {
-        throw new PikkuMissingMetaError(`Missing generated metadata for HTTP route '${httpWiring.method.toUpperCase()} ${httpWiring.route}'`);
+        // In deploy units with filtered metadata, wiring files may include
+        // routes for functions not in this unit. This happens when multiple
+        // wirings share a file — split them into separate files for better
+        // tree-shaking.
+        console.warn(`[pikku] Skipping HTTP route '${httpWiring.method.toUpperCase()} ${httpWiring.route}' — metadata not found. Consider moving this wiring to its own file.`);
+        return;
     }
     if (httpWiring.func) {
         addFunction(routeMeta.pikkuFuncId, httpWiring.func);
@@ -198,7 +202,6 @@ export const createHTTPWire = (request, response) => {
  */
 const executeRoute = async (services, matchedRoute, http, options) => {
     const userSession = new PikkuSessionService();
-    const credentialWire = new PikkuCredentialWireService();
     const { params, route, meta } = matchedRoute;
     const { singletonServices, createWireServices, skipUserSession, requestId } = services;
     // Attach URL parameters to the request object
@@ -253,13 +256,13 @@ const executeRoute = async (services, matchedRoute, http, options) => {
         };
     }
     const wire = {
+        traceId: requestId,
         http,
         channel,
         session: userSession.get(),
         setSession: (s) => userSession.setInitial(s),
         getSession: () => userSession.get(),
         hasSessionChanged: () => userSession.sessionChanged,
-        ...createMiddlewareCredentialWireProps(credentialWire),
     };
     result = await runPikkuFunc('http', `${meta.method}:${meta.route}`, meta.pikkuFuncId, {
         singletonServices,
@@ -274,7 +277,6 @@ const executeRoute = async (services, matchedRoute, http, options) => {
         tags: route.tags,
         wire,
         sessionService: userSession,
-        credentialWireService: credentialWire,
         packageName: meta.packageName,
     });
     if (!matchedRoute.route.sse) {
@@ -349,19 +351,25 @@ export const pikkuFetch = async (request, params = {}) => {
  * @param {RunHTTPWiringOptions} 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, { skipUserSession = false, respondWith404 = true, logWarningsForStatusCodes = [], coerceDataFromSchema = true, bubbleErrors = false, exposeErrors = false, generateRequestId, } = {}) => {
+export const fetchData = async (request, response, { skipUserSession = false, respondWith404 = true, logWarningsForStatusCodes = [], coerceDataFromSchema = true, bubbleErrors = false, exposeErrors = false, generateRequestId, traceId: externalTraceId, } = {}) => {
     const singletonServices = getSingletonServices();
     const createWireServices = getCreateWireServices();
     let wireServices;
     let result;
     // Combine the request and response into one wire object
     const pikkuRequest = request instanceof Request ? new PikkuFetchHTTPRequest(request) : request;
-    let requestId = null;
-    try {
-        requestId = pikkuRequest.header('x-request-id');
+    // Resolve traceId: external (e.g. CF-Ray) > x-request-id header > generated
+    let requestId = externalTraceId ?? null;
+    if (!requestId) {
+        try {
+            requestId = pikkuRequest.header('x-request-id');
+        }
+        catch { }
     }
-    catch { }
     requestId = requestId || generateRequestId?.() || createWeakUID();
+    // Scoped logger for HTTP runner internal logging (error handling, route matching)
+    // Functions/middleware receive singletonServices.logger directly for compatibility
+    const scopedLogger = singletonServices.logger.scope?.(requestId) ?? singletonServices.logger;
     const http = createHTTPWire(pikkuRequest, response);
     const apiType = http.request.method();
     const apiRoute = http.request.path();
@@ -379,7 +387,7 @@ export const fetchData = async (request, response, { skipUserSession = false, re
                 response.status(204).json(undefined);
                 return;
             }
-            singletonServices.logger.info({
+            scopedLogger.info({
                 message: 'Route not found',
                 apiRoute,
                 apiType,
@@ -399,7 +407,7 @@ export const fetchData = async (request, response, { skipUserSession = false, re
     catch (e) {
         if (matchedRoute?.route.sse) {
             // For SSE routes, send error through the stream since the response is already in stream mode
-            singletonServices.logger.error(e instanceof Error ? e.message : e);
+            scopedLogger.error(e instanceof Error ? e.message : e);
             try {
                 const errorResponse = getErrorResponse(e);
                 response.arrayBuffer(JSON.stringify({
@@ -409,12 +417,12 @@ export const fetchData = async (request, response, { skipUserSession = false, re
                 response.arrayBuffer(JSON.stringify({ type: 'done' }));
             }
             catch (streamErr) {
-                singletonServices.logger.error(`SSE error while sending error payload: ${streamErr instanceof Error ? streamErr.message : String(streamErr)}`);
+                scopedLogger.error(`SSE error while sending error payload: ${streamErr instanceof Error ? streamErr.message : String(streamErr)}`);
             }
             response.close?.();
         }
         else {
-            handleHTTPError(e, http, requestId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors, exposeErrors);
+            handleHTTPError(e, http, requestId, scopedLogger, logWarningsForStatusCodes, respondWith404, bubbleErrors, exposeErrors);
         }
     }
     finally {

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

@@ -17,6 +17,8 @@ export type RunHTTPWiringOptions = Partial<{
     bubbleErrors: boolean;
     exposeErrors: boolean;
     generateRequestId: () => string;
+    /** Pre-resolved trace ID (e.g. CF-Ray). Falls back to x-request-id header or generated ID. */
+    traceId: string;
 }>;
 /**
  * Represents the HTTP methods supported for API HTTP wirings.

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

@@ -3,7 +3,7 @@ import { closeWireServices } from '../../utils.js';
 import { pikkuState, getSingletonServices, getCreateWireServices, } from '../../pikku-state.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 import { resolveNamespace } from '../rpc/rpc-runner.js';
-import { BadRequestError, NotFoundError, PikkuMissingMetaError, } from '../../errors/errors.js';
+import { BadRequestError, NotFoundError } from '../../errors/errors.js';
 import { PikkuSessionService, createMiddlewareSessionWireProps, } from '../../services/user-session-service.js';
 export class MCPError extends Error {
     error;
@@ -18,7 +18,8 @@ export const wireMCPResource = (mcpResource) => {
     const resourcesMeta = pikkuState(null, 'mcp', 'resourcesMeta');
     const mcpResourceMeta = resourcesMeta[mcpResource.uri];
     if (!mcpResourceMeta) {
-        throw new PikkuMissingMetaError(`Missing generated metadata for MCP resource '${mcpResource.uri}'`);
+        console.warn(`[pikku] Skipping MCP resource '${mcpResource.uri}' — metadata not found. Consider moving this wiring to its own file.`);
+        return;
     }
     addFunction(mcpResourceMeta.pikkuFuncId, mcpResource.func);
     const resources = pikkuState(null, 'mcp', 'resources');
@@ -31,7 +32,8 @@ export const wireMCPPrompt = (mcpPrompt) => {
     const promptsMeta = pikkuState(null, 'mcp', 'promptsMeta');
     const mcpPromptMeta = promptsMeta[mcpPrompt.name];
     if (!mcpPromptMeta) {
-        throw new PikkuMissingMetaError(`Missing generated metadata for MCP prompt '${mcpPrompt.name}'`);
+        console.warn(`[pikku] Skipping MCP prompt '${mcpPrompt.name}' — metadata not found. Consider moving this wiring to its own file.`);
+        return;
     }
     addFunction(mcpPromptMeta.pikkuFuncId, mcpPrompt.func);
     const prompts = pikkuState(null, 'mcp', 'prompts');

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

@@ -28,7 +28,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({ job, updateProgress, }: {
+export declare function runQueueJob({ job, updateProgress, traceId, }: {
     job: QueueJob;
     updateProgress?: (progress: number | string | object) => Promise<void>;
+    /** Pre-resolved trace ID (e.g. from queue message metadata) */
+    traceId?: string;
 }): Promise<void>;

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

@@ -36,7 +36,8 @@ export const wireQueueWorker = (queueWorker) => {
     const meta = pikkuState(null, 'queue', 'meta');
     const processorMeta = meta[queueWorker.name];
     if (!processorMeta) {
-        throw new PikkuMissingMetaError(`Missing generated metadata for queue worker '${queueWorker.name}'`);
+        console.warn(`[pikku] Skipping queue worker '${queueWorker.name}' — metadata not found. Consider moving this wiring to its own file.`);
+        return;
     }
     // Register the function with pikku
     addFunction(processorMeta.pikkuFuncId, {
@@ -70,10 +71,12 @@ export async function removeQueueWorker(name) {
 /**
  * Process a single queue job - this function is called by queue consumers
  */
-export async function runQueueJob({ job, updateProgress, }) {
+export async function runQueueJob({ job, updateProgress, traceId, }) {
     const singletonServices = getSingletonServices();
     const createWireServices = getCreateWireServices();
-    const logger = singletonServices.logger;
+    const resolvedTraceId = traceId ?? `q-${job.id}`;
+    const logger = singletonServices.logger.scope?.(resolvedTraceId) ??
+        singletonServices.logger;
     const meta = pikkuState(null, 'queue', 'meta');
     const processorMeta = meta[job.queueName];
     if (!processorMeta) {
@@ -89,6 +92,7 @@ export async function runQueueJob({ job, updateProgress, }) {
     const queue = {
         queueName: job.queueName,
         jobId: job.id,
+        pikkuUserId: job.pikkuUserId,
         updateProgress: updateProgress ||
             (async (progress) => {
                 logger.info(`Job ${job.id} progress: ${progress}`);
@@ -104,6 +108,7 @@ export async function runQueueJob({ job, updateProgress, }) {
     try {
         logger.info(`Processing job ${job.id} in queue ${job.queueName}`);
         const wire = {
+            traceId: resolvedTraceId,
             queue,
         };
         // Execute the pikku function with the job data

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

@@ -87,6 +87,8 @@ export interface QueueJob<T = any, R = any> {
     result?: R;
     waitForCompletion?: (ttl?: number) => Promise<R>;
     metadata?: () => Promise<QueueJobMetadata> | QueueJobMetadata;
+    /** Pikku user ID propagated from the job producer */
+    pikkuUserId?: string;
 }
 /**
  * Job options for queue operations
@@ -102,6 +104,8 @@ export interface JobOptions {
     removeOnComplete?: number;
     removeOnFail?: number;
     jobId?: string;
+    /** Pikku user ID to propagate to the queue worker for credential resolution */
+    pikkuUserId?: string;
 }
 /**
  * Queue provider interface for job publishing operations
@@ -154,6 +158,8 @@ export interface PikkuQueue {
     queueName: string;
     /** The current job ID */
     jobId: string;
+    /** Pikku user ID propagated from the job producer for credential resolution */
+    pikkuUserId?: string;
     /** Update job progress (0-100 or custom value) */
     updateProgress: (progress: number | string | object) => Promise<void>;
     /** Fail the current job with optional reason */

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

@@ -3,7 +3,6 @@ import { pikkuState } from '../../pikku-state.js';
 import { ForbiddenError } from '../../errors/errors.js';
 import { PikkuError, addError } from '../../errors/error-handler.js';
 import { parseVersionedId } from '../../version.js';
-import { encryptJSON } from '../../crypto-utils.js';
 export class RPCNotFoundError extends PikkuError {
     rpcName;
     constructor(rpcName) {
@@ -95,17 +94,38 @@ export class ContextAwareRPCService {
                 }
                 : undefined,
         };
-        // Check if it's a namespaced function call (e.g., 'stripe:createCharge')
+        // Check addon namespace first (e.g. 'stripe:createCharge')
         if (funcName.includes(':')) {
-            return this.invokeAddonFunction(funcName, data, updatedWire);
+            try {
+                return await this.invokeAddonFunction(funcName, data, updatedWire);
+            }
+            catch (addonErr) {
+                if (!(addonErr instanceof RPCNotFoundError))
+                    throw addonErr;
+                // Not an addon — fall through to local lookup
+            }
+        }
+        // Try local function, then fall back to deployment service (remote)
+        try {
+            return await runPikkuFunc('rpc', funcName, getPikkuFunctionName(funcName), {
+                auth: this.options.requiresAuth,
+                singletonServices: this.services,
+                data: () => data,
+                wire: updatedWire,
+            });
+        }
+        catch (e) {
+            if (e instanceof RPCNotFoundError) {
+                // Fall back to deployment service (e.g. CF service binding, Lambda Invoke)
+                if (this.services.deploymentService) {
+                    const session = this.wire.getSession && typeof this.wire.getSession === 'function'
+                        ? await this.wire.getSession()
+                        : this.wire.session;
+                    return this.services.deploymentService.invoke(funcName, data, session, this.wire.traceId);
+                }
+            }
+            throw e;
         }
-        // Main package function
-        return runPikkuFunc('rpc', funcName, getPikkuFunctionName(funcName), {
-            auth: this.options.requiresAuth,
-            singletonServices: this.services,
-            data: () => data,
-            wire: updatedWire,
-        });
     }
     /**
      * Invoke a function from an addon package
@@ -117,16 +137,14 @@ export class ContextAwareRPCService {
         // 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 addons config.`);
+            throw new RPCNotFoundError(namespacedFunction);
         }
         // Get the function meta from the addon package
         // Addon packages use function meta, not RPC meta
         const addonFunctionMeta = pikkuState(resolved.package, 'function', 'meta');
         const funcMeta = addonFunctionMeta[resolved.function];
         if (!funcMeta) {
-            throw new Error(`Function '${resolved.function}' not found in package '${resolved.package}'. ` +
-                `Available functions: ${Object.keys(addonFunctionMeta).join(', ') || '(none)'}`);
+            throw new RPCNotFoundError(namespacedFunction);
         }
         const funcName = funcMeta.pikkuFuncId || resolved.function;
         const auth = resolved.addonConfig?.auth ?? this.options.requiresAuth;
@@ -162,12 +180,23 @@ export class ContextAwareRPCService {
         if (rpcName.includes(':')) {
             return this.invokeAddonFunction(rpcName, data, mergedWire);
         }
-        return runPikkuFunc('rpc', rpcName, getPikkuFunctionName(rpcName), {
-            auth: this.options.requiresAuth,
-            singletonServices: this.services,
-            data: () => data,
-            wire: mergedWire,
-        });
+        try {
+            return await runPikkuFunc('rpc', rpcName, getPikkuFunctionName(rpcName), {
+                auth: this.options.requiresAuth,
+                singletonServices: this.services,
+                data: () => data,
+                wire: mergedWire,
+            });
+        }
+        catch (e) {
+            if (e instanceof RPCNotFoundError && this.services.deploymentService) {
+                const session = this.wire.getSession && typeof this.wire.getSession === 'function'
+                    ? await this.wire.getSession()
+                    : this.wire.session;
+                return this.services.deploymentService.invoke(rpcName, data, session, this.wire.traceId);
+            }
+            throw e;
+        }
     }
     async startWorkflow(workflowName, input, options) {
         if (!this.services.workflowService) {
@@ -178,6 +207,7 @@ export class ContextAwareRPCService {
             type: this.wire.wireType ?? 'unknown',
             id: this.wire.wireId,
             ...(parentRunId ? { parentRunId } : {}),
+            ...(this.wire.pikkuUserId ? { pikkuUserId: this.wire.pikkuUserId } : {}),
         };
         return this.services.workflowService.startWorkflow(workflowName, input, wire, this, options);
     }
@@ -226,77 +256,14 @@ export class ContextAwareRPCService {
         };
     }
     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 addons = pikkuState(null, 'addons', 'packages');
-            const pkgConfig = addons.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 addons 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}`);
+        if (!this.services.deploymentService) {
+            throw new Error(`No DeploymentService configured for remote RPC: ${funcName}. ` +
+                `Set up a DeploymentService to enable remote function calls.`);
         }
+        const session = this.wire.getSession && typeof this.wire.getSession === 'function'
+            ? await this.wire.getSession()
+            : this.wire.session;
+        return this.services.deploymentService.invoke(funcName, data, session, this.wire.traceId);
     }
 }
 // RPC Service class for the global interface

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

@@ -4,7 +4,9 @@ import type { CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from '../.
 export type RunScheduledTasksParams = {
     name: string;
     session?: CoreUserSession;
+    /** Pre-resolved trace ID */
+    traceId?: string;
 };
 export declare const wireScheduler: <PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunctionSessionless<void, void>>>(scheduledTask: CoreScheduledTask<PikkuFunctionConfig>) => void;
-export declare function runScheduledTask({ name, session, }: RunScheduledTasksParams): Promise<void>;
+export declare function runScheduledTask({ name, session, traceId, }: RunScheduledTasksParams): Promise<void>;
 export declare const getScheduledTasks: () => Map<string, CoreScheduledTask>;

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

@@ -1,5 +1,4 @@
 import { getErrorResponse, PikkuError } from '../../errors/error-handler.js';
-import { PikkuMissingMetaError } from '../../errors/errors.js';
 import { getSingletonServices, getCreateWireServices, pikkuState, } from '../../pikku-state.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 import { PikkuSessionService, createMiddlewareSessionWireProps, } from '../../services/user-session-service.js';
@@ -7,7 +6,8 @@ export const wireScheduler = (scheduledTask) => {
     const meta = pikkuState(null, 'scheduler', 'meta');
     const taskMeta = meta[scheduledTask.name];
     if (!taskMeta) {
-        throw new PikkuMissingMetaError(`Missing generated metadata for scheduled task '${scheduledTask.name}'`);
+        console.warn(`[pikku] Skipping scheduled task '${scheduledTask.name}' — metadata not found. Consider moving this wiring to its own file.`);
+        return;
     }
     addFunction(taskMeta.pikkuFuncId, {
         func: scheduledTask.func.func,
@@ -33,9 +33,12 @@ class ScheduledTaskSkippedError extends PikkuError {
         this.name = 'ScheduledTaskSkippedError';
     }
 }
-export async function runScheduledTask({ name, session, }) {
+export async function runScheduledTask({ name, session, traceId, }) {
     const singletonServices = getSingletonServices();
     const createWireServices = getCreateWireServices();
+    const resolvedTraceId = traceId ?? `cron-${name}-${Date.now()}`;
+    const scopedLogger = singletonServices.logger.scope?.(resolvedTraceId) ??
+        singletonServices.logger;
     const task = pikkuState(null, 'scheduler', 'tasks').get(name);
     const meta = pikkuState(null, 'scheduler', 'meta')[name];
     const userSession = new PikkuSessionService();
@@ -50,6 +53,7 @@ export async function runScheduledTask({ name, session, }) {
     }
     // Create the scheduled task wire object
     const wire = {
+        traceId: resolvedTraceId,
         scheduledTask: {
             name,
             schedule: task.schedule,
@@ -61,7 +65,7 @@ export async function runScheduledTask({ name, session, }) {
         ...createMiddlewareSessionWireProps(userSession),
     };
     try {
-        singletonServices.logger.info(`Running schedule task: ${name} | schedule: ${task.schedule}`);
+        scopedLogger.info(`Running schedule task: ${name} | schedule: ${task.schedule}`);
         await runPikkuFunc('scheduler', meta.name, meta.pikkuFuncId, {
             singletonServices,
             createWireServices,
@@ -78,7 +82,7 @@ export async function runScheduledTask({ name, session, }) {
     catch (e) {
         const errorResponse = getErrorResponse(e);
         if (errorResponse != null) {
-            singletonServices.logger.error(e);
+            scopedLogger.error(e);
         }
         throw e;
     }

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

@@ -10,7 +10,8 @@ export const wireTrigger = (trigger) => {
     const meta = pikkuState(null, 'trigger', 'meta');
     const triggerMeta = meta[trigger.name];
     if (!triggerMeta) {
-        throw new PikkuMissingMetaError(`Missing generated metadata for trigger '${trigger.name}'`);
+        console.warn(`[pikku] Skipping trigger '${trigger.name}' — metadata not found. Consider moving this wiring to its own file.`);
+        return;
     }
     addFunction(triggerMeta.pikkuFuncId, trigger.func);
     const triggers = pikkuState(null, 'trigger', 'triggers');
@@ -25,7 +26,8 @@ export const wireTriggerSource = (source) => {
     const sourceMeta = pikkuState(null, 'trigger', 'sourceMeta');
     const triggerSourceMeta = sourceMeta[source.name];
     if (!triggerSourceMeta) {
-        throw new PikkuMissingMetaError(`Missing generated metadata for trigger source '${source.name}'`);
+        console.warn(`[pikku] Skipping trigger source '${source.name}' — metadata not found. Consider moving this wiring to its own file.`);
+        return;
     }
     const triggerSources = pikkuState(null, 'trigger', 'triggerSources');
     if (triggerSources.has(source.name)) {

package/dist/wirings/workflow/dsl/workflow-dsl.types.d.ts

@@ -281,6 +281,8 @@ export interface PikkuWorkflowWire {
     name: string;
     /** The current run ID */
     runId: string;
+    /** Pikku user ID propagated from the originating request for credential resolution */
+    pikkuUserId?: string;
     /** Get the current workflow run */
     getRun: () => Promise<WorkflowRun>;
     /** Execute a workflow step (overloaded - RPC or inline form) */

package/dist/wirings/workflow/dsl/workflow-runner.d.ts

@@ -2,4 +2,4 @@
  * Add a workflow to the system
  * This is called by the generated workflow wirings
  */
-export declare const addWorkflow: (workflowName: string, workflowFunc: any) => void;
+export declare const addWorkflow: (workflowName: string, workflowFunc: any, packageName?: string | null) => void;

package/dist/wirings/workflow/dsl/workflow-runner.js

@@ -1,23 +1,20 @@
 import { pikkuState } from '../../../pikku-state.js';
 import { addFunction } from '../../../function/function-runner.js';
-import { PikkuMissingMetaError } from '../../../errors/errors.js';
 /**
  * Add a workflow to the system
  * This is called by the generated workflow wirings
  */
-export const addWorkflow = (workflowName, workflowFunc) => {
-    // Get workflow metadata from inspector
-    const meta = pikkuState(null, 'workflows', 'meta');
+export const addWorkflow = (workflowName, workflowFunc, packageName = null) => {
+    const meta = pikkuState(packageName, 'workflows', 'meta');
     const workflowMeta = meta[workflowName];
     if (!workflowMeta) {
-        throw new PikkuMissingMetaError(`Missing generated metadata for workflow '${workflowName}'`);
+        console.warn(`[pikku] Skipping workflow '${workflowName}' — metadata not found. Consider moving this wiring to its own file.`);
+        return;
     }
-    // Store workflow definition in state
-    const registrations = pikkuState(null, 'workflows', 'registrations');
+    const registrations = pikkuState(packageName, 'workflows', 'registrations');
     registrations.set(workflowName, {
         name: workflowName,
         func: workflowFunc,
     });
-    // Register the function with pikku
-    addFunction(workflowMeta.pikkuFuncId, workflowFunc);
+    addFunction(workflowMeta.pikkuFuncId, workflowFunc, packageName);
 };

package/dist/wirings/workflow/graph/graph-runner.d.ts

@@ -11,6 +11,6 @@ export declare function continueGraph(workflowService: PikkuWorkflowService, run
 export declare function executeGraphStep(workflowService: PikkuWorkflowService, rpcService: any, runId: string, stepId: string, nodeId: string, rpcName: string, data: any, graphName: string): Promise<any>;
 export declare function onGraphNodeComplete(workflowService: PikkuWorkflowService, runId: string, graphName: string): Promise<void>;
 export declare function runFromMeta(workflowService: PikkuWorkflowService, runId: string, meta: WorkflowRuntimeMeta, _rpcService: any): Promise<void>;
-export declare function runWorkflowGraph(workflowService: PikkuWorkflowService, graphName: string, triggerInput: any, rpcService?: any, inline?: boolean, startNode?: string, wire?: WorkflowRunWire): Promise<{
+export declare function runWorkflowGraph(workflowService: PikkuWorkflowService, graphName: string, triggerInput: any, rpcService?: any, inline?: boolean, startNode?: string, wire?: WorkflowRunWire, overrideMeta?: WorkflowRuntimeMeta): Promise<{
     runId: string;
 }>;

package/dist/wirings/workflow/graph/graph-runner.js

@@ -90,8 +90,22 @@ function isTemplate(value) {
         typeof value.$template === 'object');
 }
 function getWorkflowMeta(name) {
-    const meta = pikkuState(null, 'workflows', 'meta');
-    return meta[name];
+    const rootMeta = pikkuState(null, 'workflows', 'meta');
+    if (rootMeta[name])
+        return rootMeta[name];
+    const colonIndex = name.indexOf(':');
+    if (colonIndex !== -1) {
+        const namespace = name.substring(0, colonIndex);
+        const localName = name.substring(colonIndex + 1);
+        const addons = pikkuState(null, 'addons', 'packages');
+        const pkgConfig = addons?.get(namespace);
+        if (pkgConfig) {
+            const addonMeta = pikkuState(pkgConfig.package, 'workflows', 'meta');
+            if (addonMeta?.[localName])
+                return addonMeta[localName];
+        }
+    }
+    return undefined;
 }
 function resolveNextFromConfig(next, branchKey) {
     if (!next)
@@ -543,8 +557,8 @@ async function continueGraphInline(workflowService, rpcService, runId, graphName
         }));
     }
 }
-export async function runWorkflowGraph(workflowService, graphName, triggerInput, rpcService, inline, startNode, wire) {
-    const meta = getWorkflowMeta(graphName);
+export async function runWorkflowGraph(workflowService, graphName, triggerInput, rpcService, inline, startNode, wire, overrideMeta) {
+    const meta = overrideMeta ?? getWorkflowMeta(graphName);
     if (!meta?.nodes) {
         throw new Error(`Workflow graph '${graphName}' not found`);
     }

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

@@ -5,6 +5,8 @@ export { PikkuWorkflowService, WorkflowCancelledException, WorkflowSuspendedExce
 export { addWorkflow } from './dsl/workflow-runner.js';
 export { template, type TemplateString } from './graph/template.js';
 export { pikkuWorkflowGraph, type PikkuWorkflowGraphConfig, type PikkuWorkflowGraphResult, } from './graph/wire-workflow-graph.js';
-export { workflow, workflowStart, workflowStatus, graphStart, } from './workflow-helpers.js';
-export type { WorkflowService, WorkflowServiceConfig, WorkflowRunWire, WorkflowStatus, WorkflowVersionStatus, StepStatus, WorkflowRun, StepState, WorkflowRunService, CoreWorkflow, PikkuWorkflow, ContextVariable, WorkflowContext, WorkflowsMeta, WorkflowRuntimeMeta, WorkflowsRuntimeMeta, WorkflowStepInput, WorkflowOrchestratorInput, WorkflowSleeperInput, } from './workflow.types.js';
+export { validateWorkflowWiring, computeEntryNodeIds, } from './graph/graph-validation.js';
+export { pikkuWorkflowWorkerFunc, pikkuWorkflowOrchestratorFunc, pikkuWorkflowSleeperFunc, } from './workflow-queue-workers.js';
+export type { WorkflowStepInput as WorkflowStepQueueInput, PikkuWorkflowOrchestratorInput, PikkuWorkflowSleeperInput, } from './workflow-queue-workers.js';
+export type { WorkflowService, WorkflowServiceConfig, WorkflowRunWire, WorkflowStatus, WorkflowVersionStatus, StepStatus, WorkflowRun, WorkflowRunStatus, StepState, WorkflowRunService, CoreWorkflow, PikkuWorkflow, ContextVariable, WorkflowContext, WorkflowsMeta, WorkflowRuntimeMeta, WorkflowsRuntimeMeta, WorkflowStepInput, WorkflowOrchestratorInput, WorkflowSleeperInput, } from './workflow.types.js';
 export type { WorkflowStepOptions, WorkflowWireDoRPC, WorkflowWireDoInline, WorkflowWireSleep, WorkflowWireSuspend, InputSource, OutputBinding, RpcStepMeta, SimpleCondition, Condition, BranchCase, BranchStepMeta, ParallelGroupStepMeta, FanoutStepMeta, ReturnStepMeta, InlineStepMeta, SleepStepMeta, CancelStepMeta, SetStepMeta, SwitchCaseMeta, SwitchStepMeta, FilterStepMeta, ArrayPredicateStepMeta, WorkflowStepMeta, WorkflowStepWire, PikkuWorkflowWire, } from './workflow.types.js';

package/dist/wirings/workflow/index.js

@@ -7,5 +7,7 @@ export { addWorkflow } from './dsl/workflow-runner.js';
 // Graph helpers (template, pikkuWorkflowGraph)
 export { template } from './graph/template.js';
 export { pikkuWorkflowGraph, } from './graph/wire-workflow-graph.js';
-// Workflow helpers (runtime factories for HTTP handlers)
-export { workflow, workflowStart, workflowStatus, graphStart, } from './workflow-helpers.js';
+// Graph validation and dynamic workflow utilities
+export { validateWorkflowWiring, computeEntryNodeIds, } from './graph/graph-validation.js';
+// Queue worker functions (registered by codegen, executed at runtime)
+export { pikkuWorkflowWorkerFunc, pikkuWorkflowOrchestratorFunc, pikkuWorkflowSleeperFunc, } from './workflow-queue-workers.js';