@pikku/core 0.12.2 → 0.12.3

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

@@ -3,7 +3,6 @@ import { combineChannelMiddleware, wrapChannelWithMiddleware, } from '../channel
 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 { createAssistantUIChannel, parseAssistantUIInput, } from './ai-agent-assistant-ui.js';
 import { resolveModelConfig } from './ai-agent-model-config.js';
 function createPersistingChannel(parent, storage, threadId) {
     let fullText = '';
@@ -181,31 +180,52 @@ async function runStreamStepLoop(params) {
         }
         if (stepResult.toolCalls.length === 0)
             break;
-        const approvalNeeded = checkForApproval(stepResult, runnerParams.tools, runId);
-        if (approvalNeeded) {
-            return { outcome: 'approval', approval: approvalNeeded };
+        const approvalsNeeded = checkForApprovals(stepResult, runnerParams.tools, runId);
+        if (approvalsNeeded.length > 0) {
+            // For each approval, call approvalDescriptionFn if available
+            for (const approval of approvalsNeeded) {
+                const toolDef = runnerParams.tools.find((t) => t.name === approval.toolName);
+                if (toolDef?.approvalDescriptionFn && !approval.reason) {
+                    try {
+                        approval.reason = await toolDef.approvalDescriptionFn(approval.args);
+                    }
+                    catch {
+                        // If description generation fails, continue without it
+                    }
+                }
+            }
+            return { outcome: 'approval', approvals: approvalsNeeded };
         }
         appendStepMessages(runnerParams, stepResult);
     }
     return { outcome: 'done' };
 }
-function checkForApproval(stepResult, tools, runId) {
+export function checkForApprovals(stepResult, tools, runId) {
+    const approvals = [];
     for (const tc of stepResult.toolCalls) {
         const toolDef = tools.find((t) => t.name === tc.toolName);
         if (toolDef?.needsApproval) {
-            return new ToolApprovalRequired(tc.toolCallId, tc.toolName, tc.args);
+            approvals.push(new ToolApprovalRequired(tc.toolCallId, tc.toolName, tc.args));
+            continue;
         }
         const tr = stepResult.toolResults.find((r) => r.toolCallId === tc.toolCallId);
         if (tr?.result &&
             typeof tr.result === 'object' &&
             '__approvalRequired' in tr.result) {
             const r = tr.result;
-            return new ToolApprovalRequired(tc.toolCallId, r.toolName, r.args, r.reason, r.displayToolName, r.displayArgs, r.agentRunId);
+            if (r.subApprovals?.length) {
+                for (const sub of r.subApprovals) {
+                    approvals.push(new ToolApprovalRequired(sub.toolCallId, r.toolName, r.args, undefined, sub.toolName, sub.args, r.agentRunId));
+                }
+            }
+            else {
+                approvals.push(new ToolApprovalRequired(tc.toolCallId, r.toolName, r.args, r.reason, r.displayToolName, r.displayArgs, r.agentRunId));
+            }
         }
     }
-    return null;
+    return approvals;
 }
-function appendStepMessages(runnerParams, stepResult) {
+export function appendStepMessages(runnerParams, stepResult) {
     const assistantMsg = {
         id: randomUUID(),
         role: 'assistant',
@@ -234,10 +254,10 @@ function appendStepMessages(runnerParams, stepResult) {
         runnerParams.messages.push(toolMsg);
     }
 }
-function handleApproval(err, runId, channel, aiRunState, persistingChannel) {
+function handleApprovals(approvals, runId, channel, aiRunState, persistingChannel) {
     return (async () => {
         await persistingChannel.flush();
-        const pendingApproval = err.agentRunId
+        const pendingApprovals = approvals.map((err) => err.agentRunId
             ? {
                 type: 'agent-call',
                 toolCallId: err.toolCallId,
@@ -251,40 +271,32 @@ function handleApproval(err, runId, channel, aiRunState, persistingChannel) {
                 toolCallId: err.toolCallId,
                 toolName: err.toolName,
                 args: err.args,
-            };
+            });
         await aiRunState.updateRun(runId, {
             status: 'suspended',
             suspendReason: 'approval',
-            pendingApprovals: [pendingApproval],
+            pendingApprovals,
         });
-        const approvalEvent = {
-            type: 'approval-request',
-            toolCallId: err.toolCallId,
-            toolName: err.displayToolName ?? err.toolName,
-            args: err.displayArgs ?? err.args,
-            reason: err.reason,
-            runId,
-        };
-        channel.send(approvalEvent);
+        for (const err of approvals) {
+            const approvalEvent = {
+                type: 'approval-request',
+                toolCallId: err.toolCallId,
+                toolName: err.displayToolName ?? err.toolName,
+                args: err.displayArgs ?? err.args,
+                reason: err.reason,
+                runId,
+            };
+            channel.send(approvalEvent);
+        }
         channel.send({ type: 'done' });
         channel.close();
     })();
 }
 export async function streamAIAgent(agentName, input, channel, params, agentSessionMap, options) {
     const sessionMap = agentSessionMap ?? new Map();
-    const { agent: resolvedAgentForProtocol } = resolveAgent(agentName);
-    const inputRecord = input;
-    const useUIMessageStream = resolvedAgentForProtocol.protocol === 'ui-message-stream' ||
-        Array.isArray(inputRecord.messages);
-    let normalizedInput;
-    if (useUIMessageStream) {
-        normalizedInput = parseAssistantUIInput(inputRecord);
-        channel = createAssistantUIChannel(channel);
-    }
-    else {
-        normalizedInput = input;
-    }
+    const normalizedInput = input;
     const streamContext = { channel, options };
+    // delegateState is attached after prepareAgentRun resolves the agent config
     const { agent, packageName, resolvedName, agentRunner, storage, memoryConfig, threadId, userMessage, runnerParams, maxSteps, missingRpcs, workingMemorySchemaName, } = await prepareAgentRun(agentName, normalizedInput, params, sessionMap, streamContext);
     const singletonServices = getSingletonServices();
     const { aiRunState } = singletonServices;
@@ -305,7 +317,7 @@ export async function streamAIAgent(agentName, input, channel, params, agentSess
         });
         channel.send({ type: 'suspended', reason: 'rpc-missing', missingRpcs });
         channel.send({ type: 'done' });
-        return;
+        return '';
     }
     const aiMiddlewares = agent.aiMiddleware ?? [];
     let modifiedMessages = runnerParams.messages;
@@ -369,7 +381,28 @@ export async function streamAIAgent(agentName, input, channel, params, agentSess
     const wrappedChannel = allChannelMiddleware.length > 0
         ? wrapChannelWithMiddleware({ channel }, singletonServices, allChannelMiddleware).channel
         : channel;
-    const persistingChannel = createPersistingChannel(wrappedChannel, storage, threadId);
+    // In delegate mode (default), suppress parent's text from reaching the client
+    // AFTER a sub-agent has been called. If the parent responds directly (no delegation),
+    // its text goes through normally. Sub-agent text bypasses this path entirely
+    // (goes through subChannel → channel directly).
+    const isDelegateMode = agent.agentMode !== 'supervise' && meta.agents?.length;
+    const delegateState = { delegated: false };
+    if (isDelegateMode) {
+        streamContext.delegateState = delegateState;
+    }
+    const outputChannel = isDelegateMode
+        ? {
+            ...wrappedChannel,
+            send: (event) => {
+                if (delegateState.delegated &&
+                    (event.type === 'text-delta' || event.type === 'reasoning-delta'))
+                    return;
+                wrappedChannel.send(event);
+            },
+            delegateState,
+        }
+        : wrappedChannel;
+    const persistingChannel = createPersistingChannel(outputChannel, storage, threadId);
     try {
         const loopResult = await runStreamStepLoop({
             agent,
@@ -382,12 +415,13 @@ export async function streamAIAgent(agentName, input, channel, params, agentSess
             aiMiddlewares,
         });
         if (loopResult.outcome === 'approval') {
-            await handleApproval(loopResult.approval, runId, channel, aiRunState, persistingChannel);
-            return;
+            await handleApprovals(loopResult.approvals, 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();
+        return persistingChannel.fullText;
     }
     catch (err) {
         for (const mw of aiMiddlewares) {
@@ -404,13 +438,17 @@ export async function streamAIAgent(agentName, input, channel, params, agentSess
                 }
             }
         }
-        await aiRunState.updateRun(runId, { status: 'failed' });
+        await aiRunState.updateRun(runId, {
+            status: 'failed',
+            errorMessage: err instanceof Error ? err.message : String(err),
+        });
         channel.send({
             type: 'error',
             message: err instanceof Error ? err.message : String(err),
         });
         channel.send({ type: 'done' });
         channel.close();
+        return persistingChannel.fullText;
     }
 }
 export async function resumeAIAgent(input, channel, params, options) {
@@ -439,7 +477,7 @@ export async function resumeAIAgent(input, channel, params, options) {
         if (pending.type === 'agent-call') {
             await aiRunState.updateRun(pending.agentRunId, { status: 'failed' });
         }
-        const denialResult = 'Tool call was not approved by the user';
+        const denialResult = 'The user explicitly declined this action. Inform them that it was declined and do not retry.';
         if (storage) {
             await storage.saveMessages(run.threadId, [
                 {
@@ -458,6 +496,15 @@ export async function resumeAIAgent(input, channel, params, options) {
                 },
             ]);
         }
+        // Check remaining pending approvals
+        const updatedRun = await aiRunState.getRun(run.runId);
+        const remaining = updatedRun?.pendingApprovals ?? [];
+        if (remaining.length > 0) {
+            // Still waiting for more approvals - don't continue step loop
+            channel.send({ type: 'done' });
+            channel.close();
+            return;
+        }
         await aiRunState.updateRun(run.runId, { status: 'running' });
         await continueAfterToolResult(run, agent, packageName, resolvedName, storage, memoryConfig, agentRunner, channel, params, aiRunState, options);
         return;
@@ -467,7 +514,8 @@ export async function resumeAIAgent(input, channel, params, options) {
         if (!subRun) {
             throw new Error(`Sub-agent run not found: ${pending.agentRunId}`);
         }
-        const subPending = subRun.pendingApprovals?.[0];
+        const subPending = subRun.pendingApprovals?.find((p) => p.toolCallId === input.toolCallId) ??
+            subRun.pendingApprovals?.[0];
         if (!subPending) {
             throw new Error(`No pending approval on sub-agent run ${pending.agentRunId}`);
         }
@@ -512,18 +560,20 @@ export async function resumeAIAgent(input, channel, params, options) {
             options: { ...options, requiresToolApproval: false },
         };
         const aiMiddlewaresForResume = agent.aiMiddleware ?? [];
-        const { tools } = buildToolDefs(params, new Map(), run.resourceId, resolvedName, packageName, streamContext, aiMiddlewaresForResume);
+        const { tools } = await buildToolDefs(params, new Map(), run.resourceId, resolvedName, packageName, streamContext, aiMiddlewaresForResume);
         const matchingTool = tools.find((t) => t.name === pending.toolName);
         if (!matchingTool) {
             throw new Error(`Tool "${pending.toolName}" not found in agent definition`);
         }
         const toolArgs = typeof pending.args === 'string' ? JSON.parse(pending.args) : pending.args;
         let toolResult;
+        let isError = false;
         try {
             toolResult = await matchingTool.execute(toolArgs);
         }
         catch (execErr) {
             toolResult = `Error: ${execErr instanceof Error ? execErr.message : String(execErr)}`;
+            isError = true;
         }
         const resultStr = typeof toolResult === 'string' ? toolResult : JSON.stringify(toolResult);
         if (storage) {
@@ -547,8 +597,18 @@ export async function resumeAIAgent(input, channel, params, options) {
             toolCallId: input.toolCallId,
             toolName: pending.toolName,
             result: toolResult,
+            ...(isError ? { isError: true } : {}),
         });
     }
+    // Check remaining pending approvals after processing this one
+    const updatedRun = await aiRunState.getRun(run.runId);
+    const remaining = updatedRun?.pendingApprovals ?? [];
+    if (remaining.length > 0) {
+        // Still waiting for more approvals - don't continue step loop
+        channel.send({ type: 'done' });
+        channel.close();
+        return;
+    }
     await aiRunState.updateRun(run.runId, { status: 'running' });
     await continueAfterToolResult(run, agent, packageName, resolvedName, storage, memoryConfig, agentRunner, channel, params, aiRunState, options);
 }
@@ -568,7 +628,7 @@ async function continueAfterToolResult(run, agent, packageName, resolvedName, st
     const contextMessages = await loadContextMessages(memoryConfig, storage, { message: '', threadId: run.threadId, resourceId: run.resourceId }, workingMemoryJsonSchema);
     const allMessages = [...contextMessages, ...messages];
     const trimmedMessages = trimMessages(allMessages);
-    const instructions = buildInstructions(resolvedName, packageName);
+    const instructions = await buildInstructions(resolvedName, packageName);
     const aiMiddlewares = agent.aiMiddleware ?? [];
     let modifiedMessages = trimmedMessages;
     let modifiedInstructions = instructions;
@@ -617,7 +677,7 @@ async function continueAfterToolResult(run, agent, packageName, resolvedName, st
         : channel;
     const persistingChannel = createPersistingChannel(wrappedChannel, storage, run.threadId);
     const streamContext = { channel, options };
-    const resumeTools = buildToolDefs(params, new Map(), run.resourceId, resolvedName, packageName, streamContext, aiMiddlewares).tools;
+    const resumeTools = (await buildToolDefs(params, new Map(), run.resourceId, resolvedName, packageName, streamContext, aiMiddlewares)).tools;
     const resolved = resolveModelConfig(resolvedName, agent);
     const maxSteps = resolved.maxSteps ?? 10;
     const runnerParams = {
@@ -644,7 +704,7 @@ async function continueAfterToolResult(run, agent, packageName, resolvedName, st
             aiMiddlewares,
         });
         if (loopResult.outcome === 'approval') {
-            await handleApproval(loopResult.approval, run.runId, channel, aiRunState, persistingChannel);
+            await handleApprovals(loopResult.approvals, run.runId, channel, aiRunState, persistingChannel);
             return;
         }
         await postStreamCleanup(persistingChannel, aiMiddlewares, singletonServices, storage, memoryConfig, run.threadId, workingMemorySchemaName, runnerParams.messages, aiRunState, run.runId);
@@ -666,7 +726,10 @@ async function continueAfterToolResult(run, agent, packageName, resolvedName, st
                 }
             }
         }
-        await aiRunState.updateRun(run.runId, { status: 'failed' });
+        await aiRunState.updateRun(run.runId, {
+            status: 'failed',
+            errorMessage: err instanceof Error ? err.message : String(err),
+        });
         channel.send({
             type: 'error',
             message: err instanceof Error ? err.message : String(err),

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

@@ -66,6 +66,8 @@ export interface AIAgentInput {
     threadId: string;
     resourceId: string;
     attachments?: AIAgentInputAttachment[];
+    model?: string;
+    temperature?: number;
 }
 export interface AIAgentOutput {
     runId: string;
@@ -77,6 +79,14 @@ export interface AIAgentOutput {
         inputTokens: number;
         outputTokens: number;
     };
+    status?: 'completed' | 'suspended';
+    pendingApprovals?: Array<{
+        toolCallId: string;
+        toolName: string;
+        args: unknown;
+        reason?: string;
+        runId: string;
+    }>;
 }
 export interface AIAgentToolDef {
     name: string;
@@ -84,6 +94,7 @@ export interface AIAgentToolDef {
     inputSchema: Record<string, unknown>;
     execute: (input: unknown) => Promise<unknown>;
     needsApproval?: boolean;
+    approvalDescriptionFn?: (input: unknown) => Promise<string>;
 }
 export interface PikkuAIMiddlewareHooks<State extends Record<string, unknown> = Record<string, unknown>, Services = any> {
     modifyInput?: (services: Services, ctx: {
@@ -177,13 +188,14 @@ export type CoreAIAgent<PikkuPermission = CorePikkuPermission<any, any>, PikkuMi
     temperature?: number;
     tools?: unknown[];
     agents?: unknown[];
+    agentMode?: 'delegate' | 'supervise';
     memory?: AIAgentMemoryConfig;
     maxSteps?: number;
     toolChoice?: 'auto' | 'required' | 'none';
+    dynamicWorkflows?: 'read' | 'always' | 'ask';
     input?: unknown;
     output?: unknown;
     tags?: string[];
-    protocol?: 'ui-message-stream';
     prepareStep?: (ctx: {
         stepNumber: number;
         messages: AIMessage[];
@@ -268,6 +280,12 @@ export type AIStreamEvent = {
     type: 'audio-done';
     agent?: string;
     session?: string;
+} | {
+    type: 'workflow-created';
+    workflowName: string;
+    graph: any;
+    agent?: string;
+    session?: string;
 } | {
     type: 'suspended';
     reason: 'rpc-missing';
@@ -296,6 +314,7 @@ export interface AgentRunState {
     threadId: string;
     resourceId: string;
     status: 'running' | 'suspended' | 'completed' | 'failed';
+    errorMessage?: string;
     suspendReason?: 'approval' | 'rpc-missing';
     missingRpcs?: string[];
     pendingApprovals?: PendingApproval[];
@@ -313,6 +332,7 @@ export interface AgentRunRow {
     threadId: string;
     resourceId: string;
     status: string;
+    errorMessage?: string;
     suspendReason?: string;
     missingRpcs?: string[];
     usageInputTokens: number;
@@ -343,4 +363,5 @@ export type AIAgentMeta = Record<string, Omit<CoreAIAgent, 'input' | 'output' |
     channelMiddleware?: MiddlewareMetadata[];
     aiMiddleware?: MiddlewareMetadata[];
     permissions?: PermissionMetadata[];
+    dynamicWorkflows?: 'read' | 'always' | 'ask';
 }>;

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

@@ -1,7 +1,6 @@
 export { agent, agentStream, agentResume, agentApprove, } from './ai-agent-helpers.js';
-export { runAIAgent } from './ai-agent-runner.js';
+export { runAIAgent, resumeAIAgentSync } from './ai-agent-runner.js';
 export { streamAIAgent, resumeAIAgent } from './ai-agent-stream.js';
-export { createAssistantUIChannel, parseAssistantUIInput, } from './ai-agent-assistant-ui.js';
 export { type RunAIAgentParams, type StreamAIAgentOptions, ToolApprovalRequired, } 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,6 +1,5 @@
 export { agent, agentStream, agentResume, agentApprove, } from './ai-agent-helpers.js';
-export { runAIAgent } from './ai-agent-runner.js';
+export { runAIAgent, resumeAIAgentSync } from './ai-agent-runner.js';
 export { streamAIAgent, resumeAIAgent } from './ai-agent-stream.js';
-export { createAssistantUIChannel, parseAssistantUIInput, } from './ai-agent-assistant-ui.js';
 export { ToolApprovalRequired, } from './ai-agent-prepare.js';
 export { addAIAgent, approveAIAgent, getAIAgents, getAIAgentsMeta, } from './ai-agent-registry.js';

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

@@ -48,7 +48,9 @@ export const processMessageHandlers = (services, channelConfig, channelHandler,
             channelHandler.getChannel().send(`Unauthorized for ${routeMessage}`);
             return;
         }
-        const { pikkuFuncId, middleware: routeInheritedMiddleware, permissions: inheritedPermissions, } = getRouteMeta(channelConfig.name, routingProperty, routerValue);
+        const routeMeta = getRouteMeta(channelConfig.name, routingProperty, routerValue);
+        const { packageName, middleware: routeInheritedMiddleware, permissions: inheritedPermissions, } = routeMeta;
+        const pikkuFuncId = routeMeta.pikkuFuncId;
         // Get wire middleware: channel-level middleware + message-specific middleware
         const channelWireMiddleware = channelConfig.middleware || [];
         // Check if onMessage is a wrapper object vs direct function config:
@@ -83,12 +85,14 @@ export const processMessageHandlers = (services, channelConfig, channelHandler,
             wireChannelMiddleware: wireChannelMiddleware,
             inheritedPermissions,
             wirePermissions,
+            coerceDataFromSchema: true,
             tags: channelConfig.tags,
             sessionService: userSession,
             wire: {
                 channel: channelHandler.getChannel(),
                 ...(userSession && createMiddlewareSessionWireProps(userSession)),
             },
+            packageName,
         });
     };
     const onMessage = async (rawData) => {

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

@@ -1,4 +1,3 @@
-import type { PikkuError } from '../../errors/error-handler.js';
 import type { HTTPFunctionMetaInputTypes, PikkuHTTPRequest, PikkuHTTPResponse } from '../http/http.types.js';
 import type { CorePikkuMiddleware, MiddlewareMetadata, PermissionMetadata } from '../../types/core.types.js';
 export type BinaryData = ArrayBuffer | Uint8Array;
@@ -19,6 +18,7 @@ export type RunChannelParams<ChannelData> = {
 };
 export interface ChannelMessageMeta {
     pikkuFuncId: string;
+    packageName?: string;
     summary?: string;
     description?: string;
     errors?: string[];
@@ -71,12 +71,6 @@ export type CoreChannel<ChannelData, Channel extends string, ChannelConnect = Co
     auth?: boolean;
     binary?: boolean | null;
     onBinaryMessage?: (services: any, data: BinaryData, channel: PikkuChannel<ChannelData, any>) => Promise<BinaryData | void> | BinaryData | void;
-    docs?: Partial<{
-        description: string;
-        response: string;
-        errors: Array<typeof PikkuError>;
-        tags: string[];
-    }>;
     tags?: string[];
 };
 export interface PikkuChannel<OpeningData, out Out> {

package/dist/wirings/channel/local/local-channel-handler.d.ts

@@ -4,7 +4,7 @@ export declare class PikkuLocalChannelHandler<OpeningData = unknown, Out = unkno
     private onMessageCallback?;
     private onBinaryMessageCallback?;
     private openCallBack?;
-    private closeCallback?;
+    private closeCallbacks;
     private sendCallback?;
     private sendBinaryCallback?;
     registerOnOpen(callback: () => void): void;

package/dist/wirings/channel/local/local-channel-handler.js

@@ -3,7 +3,7 @@ export class PikkuLocalChannelHandler extends PikkuAbstractChannelHandler {
     onMessageCallback;
     onBinaryMessageCallback;
     openCallBack;
-    closeCallback;
+    closeCallbacks = [];
     sendCallback;
     sendBinaryCallback;
     registerOnOpen(callback) {
@@ -28,14 +28,16 @@ export class PikkuLocalChannelHandler extends PikkuAbstractChannelHandler {
         return this.onBinaryMessageCallback?.(data);
     }
     registerOnClose(callback) {
-        this.closeCallback = callback;
+        this.closeCallbacks.push(callback);
     }
     close() {
         if (this.getChannel().state === 'closed') {
             return;
         }
         super.close();
-        this.closeCallback?.();
+        for (const cb of this.closeCallbacks) {
+            cb();
+        }
     }
     registerOnSend(send) {
         this.sendCallback = send;

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

@@ -75,7 +75,10 @@ export const runLocalChannel = async ({ channelId, request, response, route, ski
                     }
                     catch (e) {
                         singletonServices.logger.error(`Error handling onConnect: ${e}`);
-                        channel.send({ error: e.message || 'Unknown error' });
+                        channel.send({
+                            error: e.message || 'Unknown error',
+                            errorName: e.constructor?.name,
+                        });
                     }
                 }
             });
@@ -94,7 +97,10 @@ export const runLocalChannel = async ({ channelId, request, response, route, ski
                     }
                     catch (e) {
                         singletonServices.logger.error(`Error handling onDisconnect: ${e}`);
-                        channel.send({ error: e.message || 'Unknown error' });
+                        channel.send({
+                            error: e.message || 'Unknown error',
+                            errorName: e.constructor?.name,
+                        });
                     }
                 }
                 await closeServices();
@@ -106,8 +112,12 @@ export const runLocalChannel = async ({ channelId, request, response, route, ski
                     await channel.send(result);
                 }
                 catch (e) {
-                    singletonServices.logger.error(`Error handling message: ${e.message}`);
-                    channel.send({ error: e.message || 'Unknown error' });
+                    singletonServices.logger.error(e);
+                    channel.send({
+                        error: e.message || 'Unknown error',
+                        errorName: e.constructor?.name,
+                    });
+                    setTimeout(() => channel.close(), 200);
                 }
             });
             if (onBinaryMessage) {

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

@@ -176,7 +176,10 @@ export const runChannelMessage = async ({ channelId, channelStore, channelHandle
     }
     catch (e) {
         singletonServices.logger.error(`Error processing message: ${e.message || e}`);
-        return { error: e.message || 'Unknown error' };
+        return {
+            error: e.message || 'Unknown error',
+            errorName: e.constructor?.name,
+        };
     }
     finally {
         if (wireServices) {

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

@@ -130,14 +130,20 @@ function pluckCLIData(mergedData, funcName, availableOptions) {
     const funcMeta = pikkuState(null, 'function', 'meta')[funcName];
     const schemaName = funcMeta?.inputSchemaName;
     const schema = schemaName
-        ? pikkuState(null, 'misc', 'schemas').get(schemaName)
+        ? pikkuState(funcMeta?.packageName ?? null, 'misc', 'schemas').get(schemaName)
         : null;
     if (schema && schema.properties) {
         // If we have a schema, only include fields that are in the schema
         const result = {};
         for (const key of Object.keys(schema.properties)) {
             if (key in mergedData) {
-                result[key] = mergedData[key];
+                let value = mergedData[key];
+                // CLI passes all values as strings — coerce to array when schema expects one
+                const propSchema = schema.properties[key];
+                if (propSchema?.type === 'array' && !Array.isArray(value)) {
+                    value = typeof value === 'string' ? value.split(',') : [value];
+                }
+                result[key] = value;
             }
             else if (availableOptions[key]?.default !== undefined) {
                 // Apply default if not provided
@@ -237,9 +243,11 @@ export async function runCLICommand({ program, commandPath, data, singletonServi
             wireMiddleware: allWireMiddleware,
             inheritedPermissions: currentCommand.permissions,
             wirePermissions: undefined,
+            coerceDataFromSchema: true,
             tags: programData?.tags,
             wire,
             sessionService: userSession,
+            packageName: currentCommand.packageName,
         });
         // Apply renderer one final time with the final output (if renderer exists)
         // Skip if result is undefined (void functions handle their own output)

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

@@ -52,6 +52,7 @@ export interface CLIProgramState {
 export interface CLICommandMeta {
     parameters?: string;
     pikkuFuncId: string;
+    packageName?: string;
     positionals: CLIPositional[];
     options: Record<string, CLIOption>;
     renderName?: string;

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

@@ -113,7 +113,6 @@ function registerRoute(route, groupConfig) {
         contentType: route.contentType,
         timeout: route.timeout,
         headers: route.headers,
-        docs: route.docs,
         sse: route.sse,
     });
 }

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