@pikku/core 0.11.2 → 0.12.1

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

@@ -0,0 +1,313 @@
+import type { CorePermissionGroup, CorePikkuPermission } from '../../function/functions.types.js';
+import type { CorePikkuMiddleware, MiddlewareMetadata, PermissionMetadata } from '../../types/core.types.js';
+import type { PikkuChannel } from '../channel/channel.types.js';
+import type { CorePikkuChannelMiddleware } from '../channel/channel.types.js';
+export interface AIThread {
+    id: string;
+    resourceId: string;
+    title?: string;
+    metadata?: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface AIToolCall {
+    id: string;
+    name: string;
+    args: Record<string, unknown>;
+}
+export interface AIToolResult {
+    id: string;
+    name: string;
+    result: string;
+}
+export interface AIMessage {
+    id: string;
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content?: string;
+    toolCalls?: AIToolCall[];
+    toolResults?: AIToolResult[];
+    createdAt: Date;
+}
+export interface AIAgentStep {
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    toolCalls?: {
+        name: string;
+        args: Record<string, unknown>;
+        result: string;
+    }[];
+}
+export interface AIAgentInput {
+    message: string;
+    threadId: string;
+    resourceId: string;
+}
+export interface AIAgentOutput {
+    runId: string;
+    text: string;
+    object?: unknown;
+    threadId: string;
+    steps: AIAgentStep[];
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+}
+export interface AIAgentToolDef {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    execute: (input: unknown) => Promise<unknown>;
+    needsApproval?: boolean;
+}
+export interface PikkuAIMiddlewareHooks<State extends Record<string, unknown> = Record<string, unknown>, Services = any> {
+    modifyInput?: (services: Services, ctx: {
+        messages: AIMessage[];
+        instructions: string;
+    }) => Promise<{
+        messages: AIMessage[];
+        instructions: string;
+    }> | {
+        messages: AIMessage[];
+        instructions: string;
+    };
+    modifyOutputStream?: (services: Services, ctx: {
+        event: AIStreamEvent;
+        allEvents: readonly AIStreamEvent[];
+        state: State;
+    }) => Promise<AIStreamEvent | null> | AIStreamEvent | null;
+    modifyOutput?: (services: Services, ctx: {
+        text: string;
+        messages: AIMessage[];
+        usage: {
+            inputTokens: number;
+            outputTokens: number;
+        };
+    }) => Promise<{
+        text: string;
+        messages: AIMessage[];
+    }> | {
+        text: string;
+        messages: AIMessage[];
+    };
+    beforeToolCall?: (services: Services, ctx: {
+        toolName: string;
+        toolCallId: string;
+        args: Record<string, unknown>;
+    }) => Promise<{
+        args: Record<string, unknown>;
+    } | void> | {
+        args: Record<string, unknown>;
+    } | void;
+    afterToolCall?: (services: Services, ctx: {
+        toolName: string;
+        toolCallId: string;
+        args: Record<string, unknown>;
+        result: unknown;
+        durationMs: number;
+    }) => Promise<{
+        result: unknown;
+    } | void> | {
+        result: unknown;
+    } | void;
+    afterStep?: (services: Services, ctx: {
+        stepNumber: number;
+        text: string;
+        toolCalls: {
+            toolCallId: string;
+            toolName: string;
+            args: unknown;
+        }[];
+        toolResults: {
+            toolCallId: string;
+            toolName: string;
+            result: unknown;
+        }[];
+        usage: {
+            inputTokens: number;
+            outputTokens: number;
+        };
+        finishReason: string;
+    }) => Promise<void> | void;
+    onError?: (services: Services, ctx: {
+        error: Error;
+        stepNumber: number;
+        messages: AIMessage[];
+    }) => Promise<void> | void;
+}
+export type AIAgentMemoryConfig = {
+    storage?: string;
+    vector?: string;
+    embedder?: string;
+    lastMessages?: number;
+    workingMemory?: unknown;
+};
+export type CoreAIAgent<PikkuPermission = CorePikkuPermission<any, any>, PikkuMiddleware = CorePikkuMiddleware<any>> = {
+    name: string;
+    description: string;
+    summary?: string;
+    errors?: string[];
+    instructions: string | string[];
+    model: string;
+    temperature?: number;
+    tools?: unknown[];
+    agents?: unknown[];
+    memory?: AIAgentMemoryConfig;
+    maxSteps?: number;
+    toolChoice?: 'auto' | 'required' | 'none';
+    input?: unknown;
+    output?: unknown;
+    tags?: string[];
+    protocol?: 'ui-message-stream';
+    prepareStep?: (ctx: {
+        stepNumber: number;
+        messages: AIMessage[];
+        tools: AIAgentToolDef[];
+        toolChoice: 'auto' | 'required' | 'none';
+        model: string;
+        stop: () => void;
+    }) => void | Promise<void>;
+    middleware?: PikkuMiddleware[];
+    channelMiddleware?: CorePikkuChannelMiddleware<any, any>[];
+    aiMiddleware?: PikkuAIMiddlewareHooks<any, any>[];
+    permissions?: CorePermissionGroup<PikkuPermission>;
+};
+export type AIStreamEvent = {
+    type: 'step-start';
+    stepNumber: number;
+    agent?: string;
+    session?: string;
+} | {
+    type: 'text-delta';
+    text: string;
+    agent?: string;
+    session?: string;
+} | {
+    type: 'reasoning-delta';
+    text: string;
+    agent?: string;
+    session?: string;
+} | {
+    type: 'tool-call';
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+    agent?: string;
+    session?: string;
+} | {
+    type: 'tool-result';
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+    agent?: string;
+    session?: string;
+} | {
+    type: 'agent-call';
+    agentName: string;
+    session: string;
+    input: unknown;
+} | {
+    type: 'agent-result';
+    agentName: string;
+    session: string;
+    result: unknown;
+} | {
+    type: 'approval-request';
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+    reason?: string;
+    agent?: string;
+    session?: string;
+} | {
+    type: 'usage';
+    tokens: {
+        input: number;
+        output: number;
+    };
+    model: string;
+    agent?: string;
+    session?: string;
+} | {
+    type: 'error';
+    message: string;
+    agent?: string;
+    session?: string;
+} | {
+    type: 'suspended';
+    reason: 'rpc-missing';
+    missingRpcs: string[];
+} | {
+    type: 'done';
+};
+export interface AIStreamChannel extends PikkuChannel<unknown, AIStreamEvent> {
+}
+export type PendingApproval = {
+    type: 'tool-call';
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+} | {
+    type: 'agent-call';
+    toolCallId: string;
+    agentName: string;
+    agentRunId: string;
+    displayToolName: string;
+    displayArgs: unknown;
+};
+export interface AgentRunState {
+    runId: string;
+    agentName: string;
+    threadId: string;
+    resourceId: string;
+    status: 'running' | 'suspended' | 'completed' | 'failed';
+    suspendReason?: 'approval' | 'rpc-missing';
+    missingRpcs?: string[];
+    pendingApprovals?: PendingApproval[];
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        model: string;
+    };
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface AgentRunRow {
+    runId: string;
+    agentName: string;
+    threadId: string;
+    resourceId: string;
+    status: string;
+    suspendReason?: string;
+    missingRpcs?: string[];
+    usageInputTokens: number;
+    usageOutputTokens: number;
+    usageModel: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface AgentRunService {
+    listThreads(options?: {
+        agentName?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<AIThread[]>;
+    getThread(threadId: string): Promise<AIThread | null>;
+    getThreadMessages(threadId: string): Promise<AIMessage[]>;
+    getThreadRuns(threadId: string): Promise<AgentRunRow[]>;
+    deleteThread(threadId: string): Promise<boolean>;
+    getDistinctAgentNames(): Promise<string[]>;
+}
+export type AIAgentMeta = Record<string, Omit<CoreAIAgent, 'input' | 'output' | 'tools' | 'agents' | 'middleware' | 'channelMiddleware' | 'aiMiddleware' | 'permissions'> & {
+    tools?: string[];
+    agents?: string[];
+    inputSchema: string | null;
+    outputSchema: string | null;
+    workingMemorySchema: string | null;
+    middleware?: MiddlewareMetadata[];
+    channelMiddleware?: MiddlewareMetadata[];
+    aiMiddleware?: MiddlewareMetadata[];
+    permissions?: PermissionMetadata[];
+}>;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,7 @@
+export { agent, agentStream, agentResume, agentApprove, } from './ai-agent-helpers.js';
+export { runAIAgent } 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, AIAgentMeta, AIAgentMemoryConfig, AIAgentStep, AgentRunRow, AgentRunService, AgentRunState, AIMessage, AIStreamChannel, AIStreamEvent, AIThread, CoreAIAgent, PendingApproval, PikkuAIMiddlewareHooks, } from './ai-agent.types.js';

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

@@ -0,0 +1,6 @@
+export { agent, agentStream, agentResume, agentApprove, } from './ai-agent-helpers.js';
+export { runAIAgent } 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-common.d.ts

@@ -1,12 +1,13 @@
-import { CoreServices } from '../../types/core.types.js';
-import { CoreChannel, ChannelMessageMeta } from './channel.types.js';
+import type { CoreSingletonServices, MiddlewareMetadata } from '../../types/core.types.js';
+import type { CoreChannel, ChannelMessageMeta } from './channel.types.js';
 /**
  * Runs a channel lifecycle function (onConnect or onDisconnect) with proper middleware handling.
  *
  * This function:
  * 1. Extracts inline middleware from the lifecycle config if present
  * 2. Combines metadata middleware with inline middleware using combineMiddleware()
- * 3. Runs the lifecycle function with middleware support
+ * 3. Wraps the channel with channel middleware if present
+ * 4. Runs the lifecycle function with middleware support
  *
  * @param channelConfig - The channel configuration
  * @param meta - Metadata for the lifecycle function (connect or disconnect)
@@ -15,14 +16,16 @@ import { CoreChannel, ChannelMessageMeta } from './channel.types.js';
  * @param services - All services (singleton + session)
  * @param channel - The channel instance
  * @param data - Optional data to pass to the lifecycle function (for onConnect)
+ * @param channelMiddlewareMeta - Optional channel middleware metadata for wrapping channel.send()
  * @returns Promise<unknown> - Result from the lifecycle function (if any)
  */
-export declare const runChannelLifecycleWithMiddleware: ({ channelConfig, meta, lifecycleConfig, lifecycleType, services, channel, data, }: {
+export declare const runChannelLifecycleWithMiddleware: ({ channelConfig, meta, lifecycleConfig, lifecycleType, services, channel, data, channelMiddlewareMeta, }: {
     channelConfig: CoreChannel<unknown, any>;
     meta: ChannelMessageMeta;
     lifecycleConfig: any;
     lifecycleType: "connect" | "disconnect";
-    services: CoreServices;
+    services: CoreSingletonServices;
     channel: any;
     data?: unknown;
+    channelMiddlewareMeta?: MiddlewareMetadata[];
 }) => Promise<unknown>;

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

@@ -1,12 +1,14 @@
 import { combineMiddleware, runMiddleware } from '../../middleware-runner.js';
 import { runPikkuFuncDirectly } from '../../function/function-runner.js';
+import { combineChannelMiddleware, wrapChannelWithMiddleware, } from './channel-middleware-runner.js';
 /**
  * Runs a channel lifecycle function (onConnect or onDisconnect) with proper middleware handling.
  *
  * This function:
  * 1. Extracts inline middleware from the lifecycle config if present
  * 2. Combines metadata middleware with inline middleware using combineMiddleware()
- * 3. Runs the lifecycle function with middleware support
+ * 3. Wraps the channel with channel middleware if present
+ * 4. Runs the lifecycle function with middleware support
  *
  * @param channelConfig - The channel configuration
  * @param meta - Metadata for the lifecycle function (connect or disconnect)
@@ -15,25 +17,30 @@ import { runPikkuFuncDirectly } from '../../function/function-runner.js';
  * @param services - All services (singleton + session)
  * @param channel - The channel instance
  * @param data - Optional data to pass to the lifecycle function (for onConnect)
+ * @param channelMiddlewareMeta - Optional channel middleware metadata for wrapping channel.send()
  * @returns Promise<unknown> - Result from the lifecycle function (if any)
  */
-export const runChannelLifecycleWithMiddleware = async ({ channelConfig, meta, lifecycleConfig, lifecycleType, services, channel, data, }) => {
-    // Extract middleware if lifecycle config is an object
+export const runChannelLifecycleWithMiddleware = async ({ channelConfig, meta, lifecycleConfig, lifecycleType, services, channel, data, channelMiddlewareMeta, }) => {
     const lifecycleMiddleware = typeof lifecycleConfig === 'object' && 'middleware' in lifecycleConfig
         ? lifecycleConfig.middleware || []
         : [];
-    // Use combineMiddleware to properly resolve metadata + inline middleware
     const allMiddleware = combineMiddleware('channel', `${channelConfig.name}:${lifecycleType}`, {
         wireInheritedMiddleware: meta.middleware,
         wireMiddleware: lifecycleMiddleware,
     });
-    // Run the lifecycle function
+    const allChannelMiddleware = combineChannelMiddleware('channel', `${channelConfig.name}:${lifecycleType}:cm`, {
+        wireInheritedChannelMiddleware: channelMiddlewareMeta,
+        wireChannelMiddleware: channelConfig.channelMiddleware,
+    });
+    let wire = { channel };
+    if (allChannelMiddleware.length > 0) {
+        wire = wrapChannelWithMiddleware(wire, services, allChannelMiddleware);
+    }
     const runLifecycle = async () => {
-        return await runPikkuFuncDirectly(meta.pikkuFuncName, services, { channel }, data);
+        return await runPikkuFuncDirectly(meta.pikkuFuncId, services, wire, data);
     };
-    // Run with middleware if any
     if (allMiddleware.length > 0) {
-        return await runMiddleware(services, { channel }, allMiddleware, runLifecycle);
+        return await runMiddleware(services, wire, allMiddleware, runLifecycle);
     }
     else {
         return await runLifecycle();

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

@@ -1,4 +1,4 @@
-import { CoreServices, CoreUserSession } from '../../types/core.types.js';
-import { CoreChannel, PikkuChannelHandler } from './channel.types.js';
-import { SessionService } from '../../services/user-session-service.js';
+import type { CoreServices, CoreUserSession } from '../../types/core.types.js';
+import type { CoreChannel, PikkuChannelHandler } from './channel.types.js';
+import type { SessionService } from '../../services/user-session-service.js';
 export declare const processMessageHandlers: (services: CoreServices, channelConfig: CoreChannel<any, any>, channelHandler: PikkuChannelHandler, userSession?: SessionService<CoreUserSession>) => (rawData: any) => Promise<unknown>;

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

@@ -1,5 +1,9 @@
 import { pikkuState } from '../../pikku-state.js';
 import { runPikkuFunc } from '../../function/function-runner.js';
+import { createMiddlewareSessionWireProps } from '../../services/user-session-service.js';
+const getChannelMeta = (channelName) => {
+    return pikkuState(null, 'channel', 'meta')[channelName];
+};
 const getRouteMeta = (channelName, routingProperty, routerValue) => {
     const channelMeta = pikkuState(null, 'channel', 'meta')[channelName];
     if (!channelMeta) {
@@ -35,7 +39,7 @@ export const processMessageHandlers = (services, channelConfig, channelHandler,
     const logger = services.logger;
     const requiresSession = channelConfig.auth !== false;
     const processMessage = async (data, onMessage, routingProperty, routerValue) => {
-        if (!validateAuth(requiresSession, channelHandler, onMessage)) {
+        if (!validateAuth(requiresSession, userSession?.get(), onMessage)) {
             const routeMessage = routingProperty
                 ? `route '${routingProperty}:${routerValue}'`
                 : 'the default message route';
@@ -44,7 +48,7 @@ export const processMessageHandlers = (services, channelConfig, channelHandler,
             channelHandler.getChannel().send(`Unauthorized for ${routeMessage}`);
             return;
         }
-        const { pikkuFuncName, middleware: routeInheritedMiddleware, permissions: inheritedPermissions, } = getRouteMeta(channelConfig.name, routingProperty, routerValue);
+        const { pikkuFuncId, middleware: routeInheritedMiddleware, permissions: inheritedPermissions, } = getRouteMeta(channelConfig.name, routingProperty, routerValue);
         // Get wire middleware: channel-level middleware + message-specific middleware
         const channelWireMiddleware = channelConfig.middleware || [];
         // Check if onMessage is a wrapper object vs direct function config:
@@ -68,17 +72,22 @@ export const processMessageHandlers = (services, channelConfig, channelHandler,
         const cacheKey = routingProperty
             ? `${channelConfig.name}:${routingProperty}:${routerValue}`
             : `${channelConfig.name}:default`;
-        return await runPikkuFunc('channel', cacheKey, pikkuFuncName, {
+        const channelMeta = getChannelMeta(channelConfig.name);
+        const wireChannelMiddleware = channelConfig.channelMiddleware || [];
+        return await runPikkuFunc('channel', cacheKey, pikkuFuncId, {
             singletonServices: services,
             data: () => data,
             inheritedMiddleware,
             wireMiddleware,
+            inheritedChannelMiddleware: channelMeta?.channelMiddleware,
+            wireChannelMiddleware: wireChannelMiddleware,
             inheritedPermissions,
             wirePermissions,
             tags: channelConfig.tags,
+            sessionService: userSession,
             wire: {
                 channel: channelHandler.getChannel(),
-                session: userSession,
+                ...(userSession && createMiddlewareSessionWireProps(userSession)),
             },
         });
     };
@@ -91,7 +100,7 @@ export const processMessageHandlers = (services, channelConfig, channelHandler,
             try {
                 messageData = JSON.parse(rawData);
             }
-            catch (error) {
+            catch {
                 // Most likely a json error.. ignore
             }
             if (messageData) {
@@ -121,7 +130,7 @@ export const processMessageHandlers = (services, channelConfig, channelHandler,
         }
         if (!processed) {
             logger.error(`No handler found for message in channel ${channelConfig.name} for ${JSON.stringify(rawData)}`);
-            logger.error(`Channel ${JSON.stringify(channelConfig)}`);
+            logger.error(`Channel config name: ${channelConfig.name}`);
         }
         return result;
     };

package/dist/wirings/channel/channel-middleware-runner.d.ts

@@ -0,0 +1,9 @@
+import type { CoreSingletonServices, MiddlewareMetadata, PikkuWire } from '../../types/core.types.js';
+import type { CorePikkuChannelMiddleware } from './channel.types.js';
+export declare const addChannelMiddleware: (tag: string, middleware: CorePikkuChannelMiddleware[], packageName?: string | null) => CorePikkuChannelMiddleware[];
+export declare const combineChannelMiddleware: (wireType: string, uid: string, { wireInheritedChannelMiddleware, wireChannelMiddleware, packageName, }?: {
+    wireInheritedChannelMiddleware?: MiddlewareMetadata[];
+    wireChannelMiddleware?: CorePikkuChannelMiddleware[];
+    packageName?: string | null;
+}) => readonly CorePikkuChannelMiddleware[];
+export declare function wrapChannelWithMiddleware<Out>(wire: PikkuWire, services: CoreSingletonServices, middlewares: readonly CorePikkuChannelMiddleware[]): PikkuWire;

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

@@ -0,0 +1,73 @@
+import { pikkuState } from '../../pikku-state.js';
+import { freezeDedupe, getTagGroups } from '../../utils.js';
+export const addChannelMiddleware = (tag, middleware, packageName = null) => {
+    const tagGroups = pikkuState(packageName, 'channelMiddleware', 'tagGroup');
+    tagGroups[tag] = middleware;
+    return middleware;
+};
+const getChannelMiddlewareByName = (name) => {
+    const store = pikkuState(null, 'misc', 'channelMiddleware');
+    const middleware = store[name];
+    return middleware?.[0];
+};
+const channelMiddlewareCache = {};
+export const combineChannelMiddleware = (wireType, uid, { wireInheritedChannelMiddleware, wireChannelMiddleware, packageName = null, } = {}) => {
+    const cacheKey = `${wireType}:${uid}`;
+    if (channelMiddlewareCache[cacheKey]) {
+        return channelMiddlewareCache[cacheKey];
+    }
+    const resolved = [];
+    if (wireInheritedChannelMiddleware) {
+        for (const meta of wireInheritedChannelMiddleware) {
+            if (meta.type === 'tag') {
+                const groups = getTagGroups(pikkuState(packageName, 'channelMiddleware', 'tagGroup'), meta.tag);
+                for (const group of groups) {
+                    resolved.push(...group);
+                }
+            }
+            else if (meta.type === 'wire') {
+                const middleware = getChannelMiddlewareByName(meta.name);
+                if (middleware) {
+                    resolved.push(middleware);
+                }
+            }
+        }
+    }
+    if (wireChannelMiddleware) {
+        resolved.push(...wireChannelMiddleware);
+    }
+    channelMiddlewareCache[cacheKey] = freezeDedupe(resolved);
+    return channelMiddlewareCache[cacheKey];
+};
+export function wrapChannelWithMiddleware(wire, services, middlewares) {
+    if (middlewares.length === 0 || !wire.channel)
+        return wire;
+    const channel = wire.channel;
+    const originalSend = channel.send.bind(channel);
+    const dispatch = async (index, event) => {
+        if (index >= middlewares.length) {
+            await originalSend(event);
+            return;
+        }
+        const middleware = middlewares[index];
+        await middleware(services, event, async (result) => {
+            if (result === null || result === undefined)
+                return;
+            if (Array.isArray(result)) {
+                for (const item of result) {
+                    await dispatch(index + 1, item);
+                }
+            }
+            else {
+                await dispatch(index + 1, result);
+            }
+        });
+    };
+    return {
+        ...wire,
+        channel: {
+            ...channel,
+            send: ((data) => dispatch(0, data)),
+        },
+    };
+}

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

@@ -1,13 +1,13 @@
-import { CorePikkuPermission } from '../../function/functions.types.js';
-import { SessionService } from '../../services/user-session-service.js';
-import { CorePikkuMiddleware } from '../../types/core.types.js';
-import { ChannelMeta, CoreChannel, RunChannelOptions, RunChannelParams } from './channel.types.js';
+import type { CorePikkuPermission } from '../../function/functions.types.js';
+import type { SessionService } from '../../services/user-session-service.js';
+import type { CorePikkuMiddleware } from '../../types/core.types.js';
+import type { ChannelMeta, CoreChannel, RunChannelOptions, RunChannelParams } from './channel.types.js';
 /**
  * Adds a channel and registers all functions referenced in it using the
  * function names already stored in the channel metadata
  */
 export declare const wireChannel: <In, Channel extends string, PikkuPermission extends CorePikkuPermission<In>, PikkuMiddleware extends CorePikkuMiddleware, ChannelFunction>(channel: CoreChannel<In, Channel, PikkuPermission, PikkuMiddleware, ChannelFunction>) => void;
-export declare const openChannel: ({ route, singletonServices, coerceDataFromSchema, request, }: Pick<CoreChannel<unknown, string>, "route"> & RunChannelParams<unknown> & {
+export declare const openChannel: ({ route, coerceDataFromSchema, request, }: Pick<CoreChannel<unknown, string>, "route"> & RunChannelParams<unknown> & {
     userSession: SessionService<any>;
 } & RunChannelOptions) => Promise<{
     openingData: unknown;

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

@@ -1,6 +1,6 @@
-import { NotFoundError } from '../../errors/errors.js';
+import { NotFoundError, PikkuMissingMetaError } from '../../errors/errors.js';
 import { addFunction } from '../../function/function-runner.js';
-import { pikkuState } from '../../pikku-state.js';
+import { pikkuState, getSingletonServices } from '../../pikku-state.js';
 import { coerceTopLevelDataFromSchema, validateSchema } from '../../schema.js';
 import { httpRouter } from '../http/routers/http-router.js';
 /**
@@ -12,20 +12,20 @@ export const wireChannel = (channel) => {
     const channelsMeta = pikkuState(null, 'channel', 'meta');
     const channelMeta = channelsMeta[channel.name];
     if (!channelMeta) {
-        throw new Error(`Channel metadata not found for channel: ${channel.name}`);
+        throw new PikkuMissingMetaError(`Missing generated metadata for channel '${channel.name}'`);
     }
     pikkuState(null, 'channel', 'channels').set(channel.name, channel);
     // Register onConnect function if provided
     if (channel.onConnect && channelMeta.connect) {
-        addFunction(channelMeta.connect.pikkuFuncName, channel.onConnect);
+        addFunction(channelMeta.connect.pikkuFuncId, channel.onConnect);
     }
     // Register onDisconnect function if provided
     if (channel.onDisconnect && channelMeta.disconnect) {
-        addFunction(channelMeta.disconnect.pikkuFuncName, channel.onDisconnect);
+        addFunction(channelMeta.disconnect.pikkuFuncId, channel.onDisconnect);
     }
     // Register onMessage function if provided
-    if (channel.onMessage && channelMeta.message?.pikkuFuncName) {
-        addFunction(channelMeta.message.pikkuFuncName, channel.onMessage.func instanceof Function
+    if (channel.onMessage && channelMeta.message?.pikkuFuncId) {
+        addFunction(channelMeta.message.pikkuFuncId, channel.onMessage.func instanceof Function
             ? channel.onMessage
             : channel.onMessage.func);
     }
@@ -43,7 +43,7 @@ export const wireChannel = (channel) => {
                     return;
                 // Register the function using the pikku name from metadata
                 // It could be a FuncConfig or a wiring override with a funcConfig
-                addFunction(wiringMeta.pikkuFuncName, handler.func instanceof Function
+                addFunction(wiringMeta.pikkuFuncId, handler.func instanceof Function
                     ? handler
                     : handler.func);
             });
@@ -75,7 +75,8 @@ const getMatchingChannelConfig = (path) => {
         meta: channelMeta,
     };
 };
-export const openChannel = async ({ route, singletonServices, coerceDataFromSchema = true, request, }) => {
+export const openChannel = async ({ route, coerceDataFromSchema = true, request, }) => {
+    const singletonServices = getSingletonServices();
     const matchingChannel = getMatchingChannelConfig(route);
     if (!matchingChannel) {
         singletonServices.logger.info(`Channel not found: ${route}`);

package/dist/wirings/channel/channel-store.d.ts

@@ -1,4 +1,4 @@
-import { CoreUserSession } from '../../types/core.types.js';
+import type { CoreUserSession } from '../../types/core.types.js';
 export type Channel<ChannelType = unknown, OpeningData = unknown> = {
     channelId: string;
     channelName: string;