@pikku/core 0.12.14 → 0.12.15

package/dist/services/workflow-service.d.ts

@@ -1,5 +1,5 @@
 import type { SerializedError } from '../types/core.types.js';
-import type { WorkflowRun, WorkflowRunWire, StepState, WorkflowStatus, WorkflowVersionStatus } from '../wirings/workflow/workflow.types.js';
+import type { WorkflowRun, WorkflowRunWire, WorkflowRunStatus, StepState, WorkflowStatus, WorkflowVersionStatus } from '../wirings/workflow/workflow.types.js';
 /**
  * Interface for workflow orchestration
  * Handles workflow execution, replay, orchestration logic, and run-level state
@@ -7,6 +7,7 @@ import type { WorkflowRun, WorkflowRunWire, StepState, WorkflowStatus, WorkflowV
 export interface WorkflowService {
     createRun(workflowName: string, input: any, inline: boolean, graphHash: string, wire: WorkflowRunWire): Promise<string>;
     getRun(id: string): Promise<WorkflowRun | null>;
+    getRunStatus(id: string): Promise<WorkflowRunStatus | null>;
     getRunHistory(runId: string): Promise<Array<StepState & {
         stepName: string;
     }>>;
@@ -20,6 +21,10 @@ export interface WorkflowService {
     }): Promise<{
         runId: string;
     }>;
+    runToCompletion<I>(name: string, input: I, rpcService: any, options?: {
+        pollIntervalMs?: number;
+        wire?: WorkflowRunWire;
+    }): Promise<unknown>;
     runWorkflowJob(runId: string, rpcService: any): Promise<void>;
     orchestrateWorkflow(runId: string, rpcService: any): Promise<void>;
     executeWorkflowSleepCompleted(runId: string, stepId: string): Promise<void>;

package/dist/testing/service-tests.js

@@ -482,14 +482,6 @@ export function defineServiceTests(config) {
                     endpoint: 'http://localhost:3000',
                     functions: ['funcA', 'funcB'],
                 });
-                const infos = await service.findFunction('funcA');
-                assert.ok(infos.length >= 1);
-                assert.equal(infos[0].deploymentId, 'deploy-1');
-                assert.equal(infos[0].endpoint, 'http://localhost:3000');
-            });
-            test('findFunction returns empty for unknown function', async () => {
-                const infos = await service.findFunction('unknown-func');
-                assert.deepEqual(infos, []);
             });
         });
     }

package/dist/types/core.types.d.ts

@@ -24,6 +24,7 @@ import type { AgentRunService } from '../wirings/ai-agent/ai-agent.types.js';
 import type { PikkuAIMiddlewareHooks } from '../wirings/ai-agent/ai-agent.types.js';
 import type { WorkflowRunService } from '../wirings/workflow/workflow.types.js';
 import type { CredentialService } from '../services/credential-service.js';
+import type { MetaService } from '../services/meta-service.js';
 export type PikkuWiringTypes = 'http' | 'scheduler' | 'trigger' | 'channel' | 'rpc' | 'queue' | 'mcp' | 'cli' | 'workflow' | 'agent' | 'gateway';
 export interface FunctionServicesMeta {
     optimized: boolean;
@@ -75,6 +76,7 @@ export type FunctionRuntimeMeta = {
     remote?: boolean;
     mcp?: boolean;
     readonly?: boolean;
+    deploy?: 'serverless' | 'server' | 'auto';
     sessionless?: boolean;
     version?: number;
     approvalRequired?: boolean;
@@ -94,6 +96,8 @@ export type FunctionMeta = FunctionRuntimeMeta & Partial<{
     middleware: MiddlewareMetadata[];
     permissions: PermissionMetadata[];
     isDirectFunction: boolean;
+    sourceFile: string;
+    exportedName: string;
 } & CommonWireMeta>;
 export type FunctionsRuntimeMeta = Record<string, FunctionRuntimeMeta>;
 export type FunctionsMeta = Record<string, FunctionMeta>;
@@ -175,6 +179,8 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
     workflowRunService?: WorkflowRunService;
     /** Credential service for dynamic/managed credentials (OAuth tokens, per-user API keys) */
     credentialService?: CredentialService;
+    /** Meta service for reading .pikku metadata files (filesystem on Node, R2/KV on CF) */
+    metaService?: MetaService;
 }
 /**
  * Represents different forms of wire within Pikku and the outside world.
@@ -182,6 +188,8 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
 export type PikkuWire<In = unknown, Out = unknown, HasInitialSession extends boolean = false, UserSession extends CoreUserSession = CoreUserSession, TypedRPC extends PikkuRPC = PikkuRPC, IsChannel extends true | null = null, MCPTools extends string | never = never, TypedWorkflow extends PikkuWorkflowWire | never = PikkuWorkflowWire, TriggerOutput = unknown> = Partial<{
     wireType: PikkuWiringTypes;
     wireId: string;
+    /** Trace ID for distributed tracing — propagated across remote RPC calls via x-trace-id header */
+    traceId: string;
     http: PikkuHTTP<In>;
     mcp: PikkuMCP<MCPTools>;
     rpc: TypedRPC;

package/dist/types/state.types.d.ts

@@ -130,8 +130,6 @@ export interface PikkuPackageState {
         } | null;
         /** Cached singleton services for this package */
         singletonServices: CoreSingletonServices | null;
-        /** Absolute path to this package's .pikku directory */
-        metaDir: string | null;
         /** Credential metadata for this addon package */
         credentialsMeta: Record<string, {
             name: string;
@@ -139,5 +137,7 @@ export interface PikkuPackageState {
             type: string;
             oauth2?: boolean;
         }> | null;
+        /** Services this addon needs from the parent project */
+        requiredParentServices: string[] | null;
     };
 }

package/dist/wirings/ai-agent/ai-agent-prepare.js

@@ -1,4 +1,5 @@
 import { PikkuError } from '../../errors/error-handler.js';
+import { checkAuthPermissions } from '../../permissions.js';
 import { AIProviderNotConfiguredError } from '../../errors/errors.js';
 import { pikkuState, getSingletonServices } from '../../pikku-state.js';
 import { createMiddlewareSessionWireProps } from '../../services/user-session-service.js';
@@ -6,7 +7,6 @@ import { randomUUID } from 'crypto';
 import { streamAIAgent } from './ai-agent-stream.js';
 import { runAIAgent } from './ai-agent-runner.js';
 import { resolveNamespace, ContextAwareRPCService, } from '../../wirings/rpc/rpc-runner.js';
-import { buildDynamicWorkflowInstructions, buildWorkflowTools, } from './agent-dynamic-workflow.js';
 import { resolveMemoryServices, loadContextMessages, trimMessages, } from './ai-agent-memory.js';
 import { resolveModelConfig } from './ai-agent-model-config.js';
 export class ToolApprovalRequired extends PikkuError {
@@ -75,6 +75,10 @@ export function getAddonCredentialRequirements(toolNames) {
     return [...requirements.values()];
 }
 export const resolveAgent = (agentName) => {
+    if (!agentName) {
+        console.error('[resolveAgent] agentName is undefined/null! Stack:', new Error().stack);
+        throw new Error('resolveAgent called with undefined agentName');
+    }
     const mainAgent = pikkuState(null, 'agent', 'agents').get(agentName);
     if (mainAgent) {
         return { agent: mainAgent, packageName: null, resolvedName: agentName };
@@ -100,10 +104,23 @@ export const resolveAgent = (agentName) => {
 };
 export async function buildInstructions(agentName, packageName) {
     const meta = pikkuState(packageName, 'agent', 'agentsMeta')[agentName];
-    const rawInstructions = meta?.instructions ?? '';
-    let instructions = Array.isArray(rawInstructions)
-        ? rawInstructions.join('\n')
-        : rawInstructions;
+    const parts = [];
+    if (meta?.role)
+        parts.push(meta.role);
+    if (meta?.personality)
+        parts.push(meta.personality);
+    if (meta?.goal)
+        parts.push(meta.goal);
+    let instructions = parts.join('\n\n');
+    if (meta?.tools?.length) {
+        instructions +=
+            '\n\nTool usage rules:\n' +
+                '- Act immediately with the information given. Do NOT ask clarifying questions unless a required field is truly missing.\n' +
+                '- Only use fields defined in your tool schemas. Never mention or ask for fields that do not exist.\n' +
+                '- Never fill optional fields with placeholder or zero values. Omit them entirely unless the user provides a real value.\n' +
+                '- Never stuff unrelated information into the wrong field.\n' +
+                '- Keep responses concise.';
+    }
     if (meta?.agents?.length) {
         instructions +=
             '\n\nWhen calling a sub-agent, provide a short session name that describes the task. ' +
@@ -111,9 +128,6 @@ export async function buildInstructions(agentName, packageName) {
                 'Use a new session name for a new independent task. ' +
                 'When a request involves multiple actions for the same domain, combine them into a single sub-agent call rather than making separate calls.';
     }
-    if (meta?.dynamicWorkflows && meta.tools?.length) {
-        instructions += buildDynamicWorkflowInstructions(meta.tools, meta.dynamicWorkflows);
-    }
     return instructions;
 }
 export function createScopedChannel(parent, agentName, session) {
@@ -165,6 +179,10 @@ export async function buildToolDefs(params, agentSessionMap, resourceId, agentNa
     const meta = pikkuState(packageName, 'agent', 'agentsMeta')[agentName];
     if (!meta)
         return { tools, missingRpcs };
+    // Get session for permission filtering
+    const session = params.sessionService
+        ? await params.sessionService.get()
+        : null;
     const metaTools = meta.tools;
     const metaAgents = meta.agents;
     if (metaTools?.length) {
@@ -196,6 +214,14 @@ export async function buildToolDefs(params, agentSessionMap, resourceId, agentNa
                 missingRpcs.push(toolName);
                 continue;
             }
+            // Filter out tools the user doesn't have auth for
+            if (fnMeta.permissions?.length) {
+                if (!session)
+                    continue;
+                const allowed = await checkAuthPermissions(fnMeta.permissions, session, singletonServices, resolvedPkg);
+                if (!allowed)
+                    continue;
+            }
             const inputSchemaName = fnMeta?.inputSchemaName;
             let inputSchema = inputSchemaName
                 ? schemas.get(inputSchemaName)
@@ -251,6 +277,14 @@ export async function buildToolDefs(params, agentSessionMap, resourceId, agentNa
                 singletonServices.logger.warn(`Sub-agent '${subAgentName}' not found in agent registry`);
                 continue;
             }
+            // Filter out sub-agents the user doesn't have auth for
+            if (subMeta.permissions?.length) {
+                if (!session)
+                    continue;
+                const allowed = await checkAuthPermissions(subMeta.permissions, session, singletonServices);
+                if (!allowed)
+                    continue;
+            }
             tools.push({
                 name: subAgentName,
                 description: subMeta.description,
@@ -339,10 +373,6 @@ export async function buildToolDefs(params, agentSessionMap, resourceId, agentNa
             });
         }
     }
-    if (meta.dynamicWorkflows) {
-        const workflowTools = buildWorkflowTools(agentName, packageName, meta.tools ?? [], meta.dynamicWorkflows, streamContext, params.sessionService);
-        tools.push(...workflowTools);
-    }
     const hasToolHooks = aiMiddlewares?.some((mw) => mw.beforeToolCall || mw.afterToolCall);
     if (hasToolHooks) {
         for (const tool of tools) {
@@ -405,15 +435,6 @@ export async function prepareAgentRun(agentName, input, params, agentSessionMap,
     if (!agentRunner) {
         throw new AIProviderNotConfiguredError();
     }
-    if (agent.dynamicWorkflows && singletonServices.workflowService) {
-        const persisted = await singletonServices.workflowService.getAIGeneratedWorkflows(resolvedName);
-        const allMeta = pikkuState(null, 'workflows', 'meta');
-        for (const wf of persisted) {
-            if (!allMeta[wf.workflowName]) {
-                allMeta[wf.workflowName] = wf.graph;
-            }
-        }
-    }
     const { storage } = resolveMemoryServices(agent, singletonServices);
     const memoryConfig = agent.memory;
     const threadId = input.threadId;

package/dist/wirings/ai-agent/ai-agent-registry.js

@@ -1,10 +1,10 @@
 import { pikkuState } from '../../pikku-state.js';
-import { PikkuMissingMetaError } from '../../errors/errors.js';
 export const addAIAgent = (agentName, agent, packageName = null) => {
     const agentsMeta = pikkuState(packageName, 'agent', 'agentsMeta');
     const agentMeta = agentsMeta[agentName];
     if (!agentMeta) {
-        throw new PikkuMissingMetaError(`Missing generated metadata for AI agent '${agentName}'`);
+        console.warn(`[pikku] Skipping AI agent '${agentName}' — metadata not found. Consider moving this wiring to its own file.`);
+        return;
     }
     const agents = pikkuState(packageName, 'agent', 'agents');
     if (agents.has(agentName)) {

package/dist/wirings/ai-agent/ai-agent-runner.js

@@ -4,6 +4,21 @@ import { checkForApprovals, appendStepMessages } from './ai-agent-stream.js';
 import { pikkuState, getSingletonServices } from '../../pikku-state.js';
 import { resolveModelConfig } from './ai-agent-model-config.js';
 import { AIProviderNotConfiguredError } from '../../errors/errors.js';
+function stripNulls(obj) {
+    if (obj === null)
+        return undefined;
+    if (Array.isArray(obj))
+        return obj.map(stripNulls);
+    if (typeof obj !== 'object')
+        return obj;
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (value !== null) {
+            result[key] = stripNulls(value);
+        }
+    }
+    return result;
+}
 import { randomUUID } from 'crypto';
 export async function runAIAgent(agentName, input, params, agentSessionMap) {
     const sessionMap = agentSessionMap ?? new Map();
@@ -287,9 +302,11 @@ export async function resumeAIAgentSync(runId, approvals, params, expectedAgentN
             if (!matchingTool) {
                 throw new Error(`Tool "${pending.toolName}" not found in agent definition`);
             }
-            const toolArgs = typeof pending.args === 'string'
+            const rawArgs = typeof pending.args === 'string'
                 ? JSON.parse(pending.args)
                 : pending.args;
+            // Strip null values recursively — LLMs send null for optional fields but Zod expects undefined
+            const toolArgs = stripNulls(rawArgs) ?? {};
             try {
                 const toolResult = await matchingTool.execute(toolArgs);
                 resultStr =

package/dist/wirings/ai-agent/ai-agent-stream.js

@@ -733,6 +733,7 @@ async function continueAfterToolResult(run, agent, packageName, resolvedName, st
     const streamContext = { channel, options };
     const resumeTools = (await buildToolDefs(params, new Map(), run.resourceId, resolvedName, packageName, streamContext, aiMiddlewares)).tools;
     const resolved = resolveModelConfig(resolvedName, agent);
+    console.log('[DEBUG resume] resolvedName:', resolvedName, 'agent.model:', agent.model, 'resolved.model:', resolved.model);
     const maxSteps = resolved.maxSteps ?? 10;
     const runnerParams = {
         model: resolved.model,

package/dist/wirings/ai-agent/ai-agent.types.d.ts

@@ -183,7 +183,9 @@ export type CoreAIAgent<PikkuPermission = CorePikkuPermission<any, any>, PikkuMi
     description: string;
     summary?: string;
     errors?: string[];
-    instructions: string | string[];
+    role?: string;
+    personality?: string;
+    goal: string;
     model: string;
     temperature?: number;
     tools?: unknown[];
@@ -192,7 +194,6 @@ export type CoreAIAgent<PikkuPermission = CorePikkuPermission<any, any>, PikkuMi
     memory?: AIAgentMemoryConfig;
     maxSteps?: number;
     toolChoice?: 'auto' | 'required' | 'none';
-    dynamicWorkflows?: 'read' | 'always' | 'ask';
     input?: unknown;
     output?: unknown;
     tags?: string[];
@@ -382,5 +383,6 @@ export type AIAgentMeta = Record<string, Omit<CoreAIAgent, 'input' | 'output' |
     channelMiddleware?: MiddlewareMetadata[];
     aiMiddleware?: MiddlewareMetadata[];
     permissions?: PermissionMetadata[];
-    dynamicWorkflows?: 'read' | 'always' | 'ask';
+    sourceFile?: string;
+    exportedName?: string;
 }>;

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

@@ -1,4 +1,4 @@
-import { NotFoundError, PikkuMissingMetaError } from '../../errors/errors.js';
+import { NotFoundError } from '../../errors/errors.js';
 import { addFunction } from '../../function/function-runner.js';
 import { pikkuState, getSingletonServices } from '../../pikku-state.js';
 import { coerceTopLevelDataFromSchema, validateSchema } from '../../schema.js';
@@ -12,9 +12,9 @@ export const wireChannel = (channel) => {
     const channelsMeta = pikkuState(null, 'channel', 'meta');
     const channelMeta = channelsMeta[channel.name];
     if (!channelMeta) {
-        throw new PikkuMissingMetaError(`Missing generated metadata for channel '${channel.name}'`);
+        console.warn(`[pikku] Skipping channel '${channel.name}' — metadata not found. Consider moving this wiring to its own file.`);
+        return;
     }
-    pikkuState(null, 'channel', 'channels').set(channel.name, channel);
     // Register onConnect function if provided
     if (channel.onConnect && channelMeta.connect) {
         addFunction(channelMeta.connect.pikkuFuncId, channel.onConnect);

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

@@ -1,4 +1,4 @@
-import { NotFoundError, PikkuMissingMetaError } from '../../errors/errors.js';
+import { NotFoundError } from '../../errors/errors.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 import { pikkuState } from '../../pikku-state.js';
 import { PikkuSessionService, createMiddlewareSessionWireProps, } from '../../services/user-session-service.js';
@@ -29,7 +29,8 @@ export const wireCLI = (cli) => {
     // Get the existing metadata that was generated during inspection
     const cliMeta = pikkuState(null, 'cli', 'meta') || {};
     if (!cliMeta.programs?.[cli.program]) {
-        throw new PikkuMissingMetaError(`CLI metadata not found for program '${cli.program}'`);
+        console.warn(`[pikku] Skipping CLI program '${cli.program}' — metadata not found. Consider moving this wiring to its own file.`);
+        return;
     }
     // Get existing programs state and add this program
     const programs = pikkuState(null, 'cli', 'programs') || {};

package/dist/wirings/cli/command-parser.js

@@ -1,3 +1,7 @@
+/** Convert kebab-case to camelCase: "from-plan" → "fromPlan" */
+function toCamelCase(str) {
+    return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
 /**
  * Parses raw CLI arguments into structured data for a specific program
  */
@@ -81,11 +85,11 @@ export function parseCLIArguments(args, programName, allMeta) {
     while (currentIndex < args.length) {
         const arg = args[currentIndex];
         if (arg.startsWith('--')) {
-            // Long option
+            // Long option (--from-plan → fromPlan)
             const equalIndex = arg.indexOf('=');
             if (equalIndex > 0) {
                 // --option=value format
-                const key = arg.slice(2, equalIndex);
+                const key = toCamelCase(arg.slice(2, equalIndex));
                 const optionDef = availableOptions[key];
                 // Unknown options are allowed for forward compatibility
                 const value = arg.slice(equalIndex + 1);
@@ -93,7 +97,7 @@ export function parseCLIArguments(args, programName, allMeta) {
             }
             else {
                 // --option value format
-                const key = arg.slice(2);
+                const key = toCamelCase(arg.slice(2));
                 const optionDef = availableOptions[key];
                 // Unknown options are allowed for forward compatibility
                 if (optionDef && optionDef.array) {

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

@@ -136,4 +136,4 @@ export declare const pikkuFetch: <In, Out>(request: Request | PikkuHTTPRequest,
  * @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 declare const fetchData: <In, Out>(request: Request | PikkuHTTPRequest, response: PikkuHTTPResponse, { skipUserSession, respondWith404, logWarningsForStatusCodes, coerceDataFromSchema, bubbleErrors, exposeErrors, generateRequestId, }?: RunHTTPWiringOptions) => Promise<Out | void>;
+export declare const fetchData: <In, Out>(request: Request | PikkuHTTPRequest, response: PikkuHTTPResponse, { skipUserSession, respondWith404, logWarningsForStatusCodes, coerceDataFromSchema, bubbleErrors, exposeErrors, generateRequestId, traceId: externalTraceId, }?: RunHTTPWiringOptions) => Promise<Out | void>;

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

@@ -1,4 +1,4 @@
-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';
@@ -112,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);
@@ -251,6 +256,7 @@ const executeRoute = async (services, matchedRoute, http, options) => {
         };
     }
     const wire = {
+        traceId: requestId,
         http,
         channel,
         session: userSession.get(),
@@ -345,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();
@@ -375,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,
@@ -395,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({
@@ -405,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) {
@@ -105,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