@pikku/core 0.12.13 → 0.12.15

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 {
@@ -28,7 +28,57 @@ export class ToolApprovalRequired extends PikkuError {
         this.agentRunId = agentRunId;
     }
 }
+export class ToolCredentialRequired extends PikkuError {
+    toolCallId;
+    toolName;
+    args;
+    credentialName;
+    credentialType;
+    connectUrl;
+    constructor(toolCallId, toolName, args, credentialName, credentialType, connectUrl) {
+        super(`Tool '${toolName}' requires credential '${credentialName}'`);
+        this.toolCallId = toolCallId;
+        this.toolName = toolName;
+        this.args = args;
+        this.credentialName = credentialName;
+        this.credentialType = credentialType;
+        this.connectUrl = connectUrl;
+    }
+}
+/**
+ * Given a list of tool names (e.g. ["oauth-api:getProfile"]),
+ * returns the wire OAuth credentials required by their addons.
+ */
+export function getAddonCredentialRequirements(toolNames) {
+    const requirements = new Map();
+    for (const toolName of toolNames) {
+        if (!toolName.includes(':'))
+            continue;
+        const resolved = resolveNamespace(toolName);
+        if (!resolved)
+            continue;
+        const credsMeta = pikkuState(resolved.package, 'package', 'credentialsMeta');
+        if (!credsMeta)
+            continue;
+        for (const [name, meta] of Object.entries(credsMeta)) {
+            if (meta.type === 'wire' && meta.oauth2 && !requirements.has(name)) {
+                requirements.set(name, {
+                    credentialName: name,
+                    displayName: meta.displayName ?? name,
+                    addonNamespace: toolName.split(':')[0],
+                    type: 'wire',
+                    oauth2: true,
+                });
+            }
+        }
+    }
+    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 };
@@ -54,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. ' +
@@ -65,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) {
@@ -119,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) {
@@ -150,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)
@@ -205,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,
@@ -293,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) {
@@ -324,6 +400,8 @@ export async function buildToolDefs(params, agentSessionMap, resourceId, agentNa
                 }
                 catch (err) {
                     execError = err;
+                    if (err?.payload?.error === 'missing_credential')
+                        throw err;
                     result = err instanceof Error ? err.message : String(err);
                 }
                 const durationMs = Date.now() - startTime;
@@ -357,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 =
@@ -298,7 +315,12 @@ export async function resumeAIAgentSync(runId, approvals, params, expectedAgentN
                         : JSON.stringify(toolResult);
             }
             catch (err) {
-                resultStr = `Error: ${err instanceof Error ? err.message : String(err)}`;
+                if (err?.payload?.error === 'missing_credential') {
+                    resultStr = JSON.stringify(err.payload);
+                }
+                else {
+                    resultStr = `Error: ${err instanceof Error ? err.message : String(err)}`;
+                }
             }
         }
         else {

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

@@ -1,7 +1,8 @@
 import type { AIStreamChannel } from './ai-agent.types.js';
 import type { AIAgentRunnerParams, AIAgentStepResult } from '../../services/ai-agent-runner-service.js';
-import { ToolApprovalRequired, type RunAIAgentParams, type StreamAIAgentOptions } from './ai-agent-prepare.js';
+import { ToolApprovalRequired, ToolCredentialRequired, type RunAIAgentParams, type StreamAIAgentOptions } from './ai-agent-prepare.js';
 export declare function checkForApprovals(stepResult: AIAgentStepResult, tools: AIAgentRunnerParams['tools'], runId: string): ToolApprovalRequired[];
+export declare function checkForCredentialRequests(stepResult: AIAgentStepResult, runId: string): ToolCredentialRequired[];
 export declare function appendStepMessages(runnerParams: AIAgentRunnerParams, stepResult: AIAgentStepResult): void;
 export declare function streamAIAgent(agentName: string, input: {
     message: string;

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

@@ -3,7 +3,7 @@ import { AIProviderNotConfiguredError } from '../../errors/errors.js';
 import { combineChannelMiddleware, wrapChannelWithMiddleware, } from '../channel/channel-middleware-runner.js';
 import { randomUUID } from 'crypto';
 import { parseWorkingMemory, deepMergeWorkingMemory, resolveMemoryServices, loadContextMessages, trimMessages, } from './ai-agent-memory.js';
-import { prepareAgentRun, resolveAgent, buildInstructions, buildToolDefs, createScopedChannel, ToolApprovalRequired, } from './ai-agent-prepare.js';
+import { prepareAgentRun, resolveAgent, buildInstructions, buildToolDefs, createScopedChannel, ToolApprovalRequired, ToolCredentialRequired, } from './ai-agent-prepare.js';
 import { resolveModelConfig } from './ai-agent-model-config.js';
 function createPersistingChannel(parent, storage, threadId) {
     let fullText = '';
@@ -197,6 +197,12 @@ async function runStreamStepLoop(params) {
             }
             return { outcome: 'approval', approvals: approvalsNeeded };
         }
+        const credentialRequests = checkForCredentialRequests(stepResult, runId);
+        if (credentialRequests.length > 0) {
+            // Append step messages so the tool result is preserved for resume
+            appendStepMessages(runnerParams, stepResult);
+            return { outcome: 'credential', credentialRequests };
+        }
         appendStepMessages(runnerParams, stepResult);
     }
     return { outcome: 'done' };
@@ -226,6 +232,19 @@ export function checkForApprovals(stepResult, tools, runId) {
     }
     return approvals;
 }
+export function checkForCredentialRequests(stepResult, runId) {
+    const requests = [];
+    for (const tr of stepResult.toolResults) {
+        if (tr.result &&
+            typeof tr.result === 'object' &&
+            '__credentialRequired' in tr.result) {
+            const r = tr.result;
+            const tc = stepResult.toolCalls.find((t) => t.toolCallId === tr.toolCallId);
+            requests.push(new ToolCredentialRequired(tr.toolCallId, tc?.toolName ?? 'unknown', tc?.args ?? {}, r.credentialName, r.credentialType, r.connectUrl));
+        }
+    }
+    return requests;
+}
 export function appendStepMessages(runnerParams, stepResult) {
     const assistantMsg = {
         id: randomUUID(),
@@ -293,6 +312,30 @@ function handleApprovals(approvals, runId, channel, aiRunState, persistingChanne
         channel.close();
     })();
 }
+function handleCredentialRequests(requests, runId, channel, aiRunState, persistingChannel) {
+    return (async () => {
+        await persistingChannel.flush();
+        const pendingApprovals = requests.map((req) => ({
+            type: 'credential-request',
+            toolCallId: req.toolCallId,
+            toolName: req.toolName,
+            args: req.args,
+            credentialName: req.credentialName,
+            credentialType: req.credentialType,
+            connectUrl: req.connectUrl,
+        }));
+        await aiRunState.updateRun(runId, {
+            status: 'suspended',
+            suspendReason: 'credential',
+            pendingApprovals,
+        });
+        // Don't send credential-request SSE events — the tool result with
+        // __credentialRequired was already streamed. The frontend detects it
+        // from the tool result and shows Connect/Ignore buttons.
+        channel.send({ type: 'done' });
+        channel.close();
+    })();
+}
 export async function streamAIAgent(agentName, input, channel, params, agentSessionMap, options) {
     const sessionMap = agentSessionMap ?? new Map();
     const normalizedInput = input;
@@ -419,6 +462,10 @@ export async function streamAIAgent(agentName, input, channel, params, agentSess
             await handleApprovals(loopResult.approvals, runId, channel, aiRunState, persistingChannel);
             return persistingChannel.fullText;
         }
+        if (loopResult.outcome === 'credential') {
+            await handleCredentialRequests(loopResult.credentialRequests, runId, channel, aiRunState, persistingChannel);
+            return persistingChannel.fullText;
+        }
         await postStreamCleanup(persistingChannel, aiMiddlewares, singletonServices, storage, memoryConfig, threadId, workingMemorySchemaName, runnerParams.messages, aiRunState, runId);
         channel.send({ type: 'done' });
         channel.close();
@@ -487,7 +534,8 @@ export async function resumeAIAgent(input, channel, params, options) {
                     toolResults: [
                         {
                             id: input.toolCallId,
-                            name: pending.type === 'tool-call'
+                            name: pending.type === 'tool-call' ||
+                                pending.type === 'credential-request'
                                 ? pending.toolName
                                 : pending.agentName,
                             result: denialResult,
@@ -573,7 +621,12 @@ export async function resumeAIAgent(input, channel, params, options) {
             toolResult = await matchingTool.execute(toolArgs);
         }
         catch (execErr) {
-            toolResult = `Error: ${execErr instanceof Error ? execErr.message : String(execErr)}`;
+            if (execErr?.payload?.error === 'missing_credential') {
+                toolResult = execErr.payload;
+            }
+            else {
+                toolResult = `Error: ${execErr instanceof Error ? execErr.message : String(execErr)}`;
+            }
             isError = true;
         }
         const resultStr = typeof toolResult === 'string' ? toolResult : JSON.stringify(toolResult);
@@ -680,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,
@@ -708,6 +762,10 @@ async function continueAfterToolResult(run, agent, packageName, resolvedName, st
             await handleApprovals(loopResult.approvals, run.runId, channel, aiRunState, persistingChannel);
             return;
         }
+        if (loopResult.outcome === 'credential') {
+            await handleCredentialRequests(loopResult.credentialRequests, run.runId, channel, aiRunState, persistingChannel);
+            return;
+        }
         await postStreamCleanup(persistingChannel, aiMiddlewares, singletonServices, storage, memoryConfig, run.threadId, workingMemorySchemaName, runnerParams.messages, aiRunState, run.runId);
         channel.send({ type: 'done' });
         channel.close();

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[];
@@ -256,6 +257,17 @@ export type AIStreamEvent = {
     reason?: string;
     agent?: string;
     session?: string;
+} | {
+    type: 'credential-request';
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+    credentialName: string;
+    credentialType: 'oauth2' | 'apikey';
+    connectUrl?: string;
+    runId: string;
+    agent?: string;
+    session?: string;
 } | {
     type: 'usage';
     tokens: {
@@ -307,6 +319,14 @@ export type PendingApproval = {
     agentRunId: string;
     displayToolName: string;
     displayArgs: unknown;
+} | {
+    type: 'credential-request';
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+    credentialName: string;
+    credentialType: 'oauth2' | 'apikey';
+    connectUrl?: string;
 };
 export interface AgentRunState {
     runId: string;
@@ -315,7 +335,7 @@ export interface AgentRunState {
     resourceId: string;
     status: 'running' | 'suspended' | 'completed' | 'failed';
     errorMessage?: string;
-    suspendReason?: 'approval' | 'rpc-missing';
+    suspendReason?: 'approval' | 'credential' | 'rpc-missing';
     missingRpcs?: string[];
     pendingApprovals?: PendingApproval[];
     usage: {
@@ -363,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/ai-agent/index.d.ts

@@ -1,6 +1,6 @@
 export { agent, agentStream, agentResume, agentApprove, } from './ai-agent-helpers.js';
 export { runAIAgent, resumeAIAgentSync } from './ai-agent-runner.js';
 export { streamAIAgent, resumeAIAgent } from './ai-agent-stream.js';
-export { type RunAIAgentParams, type StreamAIAgentOptions, ToolApprovalRequired, } from './ai-agent-prepare.js';
+export { type RunAIAgentParams, type StreamAIAgentOptions, ToolApprovalRequired, ToolCredentialRequired, } from './ai-agent-prepare.js';
 export { addAIAgent, approveAIAgent, getAIAgents, getAIAgentsMeta, } from './ai-agent-registry.js';
 export type { AIAgentInput, AIAgentInputAttachment, AIAgentMeta, AIAgentMemoryConfig, AIAgentStep, AIContentPart, AgentRunRow, AgentRunService, AgentRunState, AIMessage, AIStreamChannel, AIStreamEvent, AIThread, CoreAIAgent, PendingApproval, PikkuAIMiddlewareHooks, } from './ai-agent.types.js';

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

@@ -1,5 +1,5 @@
 export { agent, agentStream, agentResume, agentApprove, } from './ai-agent-helpers.js';
 export { runAIAgent, resumeAIAgentSync } from './ai-agent-runner.js';
 export { streamAIAgent, resumeAIAgent } from './ai-agent-stream.js';
-export { ToolApprovalRequired, } from './ai-agent-prepare.js';
+export { ToolApprovalRequired, ToolCredentialRequired, } from './ai-agent-prepare.js';
 export { addAIAgent, approveAIAgent, getAIAgents, getAIAgentsMeta, } from './ai-agent-registry.js';

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') || {};
@@ -110,7 +111,7 @@ function registerCLICommands(commands, path = [], inheritedOptions = {}, program
                 programs[program].commandMiddleware[commandId] = command.middleware;
             }
         }
-        addFunction(funcName, unwrapFunc(command));
+        addFunction(funcName, unwrapFunc(command), currentMeta?.packageName);
         // Register renderer if provided
         if (typeof command === 'object' && command.render) {
             if (programs[program]) {

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>;