@pikku/core 0.11.2 → 0.12.0

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

@@ -0,0 +1,254 @@
+import { CorePermissionGroup, CorePikkuPermission } from '../../function/functions.types.js';
+import { 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>;
+}
+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[];
+    };
+}
+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[];
+    middleware?: PikkuMiddleware[];
+    channelMiddleware?: CorePikkuChannelMiddleware<any, any>[];
+    aiMiddleware?: PikkuAIMiddlewareHooks<any, any>[];
+    permissions?: CorePermissionGroup<PikkuPermission>;
+};
+export type AIStreamEvent = {
+    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,5 @@
+export { runAIAgent } 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 { addAIAgent, approveAIAgent, getAIAgents, getAIAgentsMeta, } from './ai-agent-registry.js';
+export type { 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,4 @@
+export { runAIAgent } from './ai-agent-runner.js';
+export { streamAIAgent, resumeAIAgent } from './ai-agent-stream.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,4 +1,4 @@
-import { CoreServices } from '../../types/core.types.js';
+import { CoreSingletonServices, MiddlewareMetadata } from '../../types/core.types.js';
 import { CoreChannel, ChannelMessageMeta } from './channel.types.js';
 /**
  * Runs a channel lifecycle function (onConnect or onDisconnect) with proper middleware handling.
@@ -6,7 +6,8 @@ import { CoreChannel, ChannelMessageMeta } from './channel.types.js';
  * 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.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) {
@@ -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)),
             },
         });
     };

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.js

@@ -1,4 +1,4 @@
-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 { coerceTopLevelDataFromSchema, validateSchema } from '../../schema.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);
             });

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

@@ -1,6 +1,8 @@
 import { PikkuError } from '../../errors/error-handler.js';
 import { HTTPFunctionMetaInputTypes, PikkuHTTPRequest, PikkuHTTPResponse } from '../http/http.types.js';
 import { CoreSingletonServices, CreateWireServices, CorePikkuMiddleware, MiddlewareMetadata, PermissionMetadata } from '../../types/core.types.js';
+export type CorePikkuChannelMiddleware<Services = any, Event = unknown> = (services: Services, event: Event, next: (event: Event | Event[] | null) => Promise<void> | void) => Promise<void> | void;
+export type CorePikkuChannelMiddlewareFactory<In = any, Services = any, Event = unknown> = (input: In) => CorePikkuChannelMiddleware<Services, Event>;
 import { CorePermissionGroup, CorePikkuFunction, CorePikkuFunctionConfig, CorePikkuFunctionSessionless, CorePikkuPermission } from '../../function/functions.types.js';
 export type RunChannelOptions = Partial<{
     skipUserSession: boolean;
@@ -17,7 +19,7 @@ export type RunChannelParams<ChannelData> = {
     createWireServices?: CreateWireServices;
 };
 export interface ChannelMessageMeta {
-    pikkuFuncName: string;
+    pikkuFuncId: string;
     summary?: string;
     description?: string;
     errors?: string[];
@@ -42,6 +44,7 @@ export interface ChannelMeta {
     tags?: string[];
     middleware?: MiddlewareMetadata[];
     permissions?: PermissionMetadata[];
+    channelMiddleware?: MiddlewareMetadata[];
 }
 export type ChannelsMeta = Record<string, ChannelMeta>;
 export type CoreChannel<ChannelData, Channel extends string, ChannelConnect = CorePikkuFunctionConfig<CorePikkuFunction<void, unknown> | CorePikkuFunctionSessionless<void, unknown>, CorePikkuPermission<void>, CorePikkuMiddleware>, ChannelDisconnect = CorePikkuFunctionConfig<CorePikkuFunction<void, void> | CorePikkuFunctionSessionless<void, void>, CorePikkuPermission<void>, CorePikkuMiddleware>, ChannelFunctionMessage = CorePikkuFunctionConfig<CorePikkuFunction<unknown, unknown> | CorePikkuFunctionSessionless<unknown, unknown>, CorePikkuPermission<unknown>, CorePikkuMiddleware>, PikkuPermission = CorePikkuPermission<ChannelData>, PikkuMiddleware = CorePikkuMiddleware> = {
@@ -63,6 +66,7 @@ export type CoreChannel<ChannelData, Channel extends string, ChannelConnect = Co
         middleware?: PikkuMiddleware[];
     }>>;
     middleware?: PikkuMiddleware[];
+    channelMiddleware?: Array<CorePikkuChannelMiddleware | CorePikkuChannelMiddlewareFactory>;
     permissions?: CorePermissionGroup<PikkuPermission>;
     auth?: boolean;
     docs?: Partial<{

package/dist/wirings/channel/define-channel-routes.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Type-safe helper for defining channel message routes that can be composed.
+ * Returns the routes record as-is (identity function) for use with `wireChannel`.
+ *
+ * @example
+ * ```typescript
+ * export const chatRoutes = defineChannelRoutes({
+ *   greet: pikkuChannelFunc({ func: greetFunc }),
+ *   farewell: pikkuChannelFunc({ func: farewellFunc }),
+ * })
+ *
+ * wireChannel({
+ *   name: 'chat',
+ *   route: '/ws/chat',
+ *   onMessageWiring: {
+ *     command: chatRoutes,
+ *   }
+ * })
+ * ```
+ */
+export declare function defineChannelRoutes<T extends Record<string, any>>(routes: T): T;

package/dist/wirings/channel/define-channel-routes.js

@@ -0,0 +1,23 @@
+/**
+ * Type-safe helper for defining channel message routes that can be composed.
+ * Returns the routes record as-is (identity function) for use with `wireChannel`.
+ *
+ * @example
+ * ```typescript
+ * export const chatRoutes = defineChannelRoutes({
+ *   greet: pikkuChannelFunc({ func: greetFunc }),
+ *   farewell: pikkuChannelFunc({ func: farewellFunc }),
+ * })
+ *
+ * wireChannel({
+ *   name: 'chat',
+ *   route: '/ws/chat',
+ *   onMessageWiring: {
+ *     command: chatRoutes,
+ *   }
+ * })
+ * ```
+ */
+export function defineChannelRoutes(routes) {
+    return routes;
+}

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

@@ -1,8 +1,10 @@
-export * from './channel-runner.js';
-export * from './channel.types.js';
-export * from './log-channels.js';
-export * from './pikku-abstract-channel-handler.js';
-export * from './eventhub-service.js';
-export * from './eventhub-service.js';
-export * from './channel-store.js';
-export * from './eventhub-store.js';
+export { wireChannel, openChannel } from './channel-runner.js';
+export { addChannelMiddleware, combineChannelMiddleware, wrapChannelWithMiddleware, } from './channel-middleware-runner.js';
+export { logChannels } from './log-channels.js';
+export { PikkuAbstractChannelHandler } from './pikku-abstract-channel-handler.js';
+export type { EventHubService } from './eventhub-service.js';
+export { ChannelStore } from './channel-store.js';
+export type { Channel } from './channel-store.js';
+export { EventHubStore } from './eventhub-store.js';
+export type { ChannelsMeta, CoreChannel, CorePikkuChannelMiddleware, CorePikkuChannelMiddlewareFactory, ChannelMessageMeta, ChannelMeta, PikkuChannel, PikkuChannelHandlerFactory, } from './channel.types.js';
+export { defineChannelRoutes } from './define-channel-routes.js';

package/dist/wirings/channel/index.js

@@ -1,8 +1,7 @@
-export * from './channel-runner.js';
-export * from './channel.types.js';
-export * from './log-channels.js';
-export * from './pikku-abstract-channel-handler.js';
-export * from './eventhub-service.js';
-export * from './eventhub-service.js';
-export * from './channel-store.js';
-export * from './eventhub-store.js';
+export { wireChannel, openChannel } from './channel-runner.js';
+export { addChannelMiddleware, combineChannelMiddleware, wrapChannelWithMiddleware, } from './channel-middleware-runner.js';
+export { logChannels } from './log-channels.js';
+export { PikkuAbstractChannelHandler } from './pikku-abstract-channel-handler.js';
+export { ChannelStore } from './channel-store.js';
+export { EventHubStore } from './eventhub-store.js';
+export { defineChannelRoutes } from './define-channel-routes.js';

package/dist/wirings/channel/local/index.d.ts

@@ -1,3 +1,3 @@
-export * from './local-channel-handler.js';
-export * from './local-channel-runner.js';
-export * from './local-eventhub-service.js';
+export { PikkuLocalChannelHandler } from './local-channel-handler.js';
+export { runLocalChannel } from './local-channel-runner.js';
+export { LocalEventHubService } from './local-eventhub-service.js';

package/dist/wirings/channel/local/index.js

@@ -1,3 +1,3 @@
-export * from './local-channel-handler.js';
-export * from './local-channel-runner.js';
-export * from './local-eventhub-service.js';
+export { PikkuLocalChannelHandler } from './local-channel-handler.js';
+export { runLocalChannel } from './local-channel-runner.js';
+export { LocalEventHubService } from './local-eventhub-service.js';