@pikku/core 0.12.0 → 0.12.1

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

@@ -1,5 +1,5 @@
-import { CorePermissionGroup, CorePikkuPermission } from '../../function/functions.types.js';
-import { CorePikkuMiddleware, MiddlewareMetadata, PermissionMetadata } from '../../types/core.types.js';
+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 {
@@ -60,6 +60,7 @@ export interface AIAgentToolDef {
     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: {
@@ -91,6 +92,50 @@ export interface PikkuAIMiddlewareHooks<State extends Record<string, unknown> =
         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;
@@ -115,12 +160,26 @@ export type CoreAIAgent<PikkuPermission = CorePikkuPermission<any, any>, PikkuMi
     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;

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

@@ -1,5 +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 { AIAgentMeta, AIAgentMemoryConfig, AIAgentStep, AgentRunRow, AgentRunService, AgentRunState, AIMessage, AIStreamChannel, AIStreamEvent, AIThread, CoreAIAgent, PendingApproval, PikkuAIMiddlewareHooks, } from './ai-agent.types.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

@@ -1,4 +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,5 +1,5 @@
-import { CoreSingletonServices, MiddlewareMetadata } 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.
  *

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,6 +1,6 @@
 import { pikkuState } from '../../pikku-state.js';
 import { runPikkuFunc } from '../../function/function-runner.js';
-import { createMiddlewareSessionWireProps, } from '../../services/user-session-service.js';
+import { createMiddlewareSessionWireProps } from '../../services/user-session-service.js';
 const getChannelMeta = (channelName) => {
     return pikkuState(null, 'channel', 'meta')[channelName];
 };
@@ -39,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';
@@ -100,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) {
@@ -130,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-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, 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';
 /**
@@ -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;

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

@@ -1,9 +1,9 @@
-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';
+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 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';
+import type { CorePermissionGroup, CorePikkuFunction, CorePikkuFunctionConfig, CorePikkuFunctionSessionless, CorePikkuPermission } from '../../function/functions.types.js';
 export type RunChannelOptions = Partial<{
     skipUserSession: boolean;
     respondWith404: boolean;
@@ -13,10 +13,8 @@ export type RunChannelOptions = Partial<{
 }>;
 export type RunChannelParams<ChannelData> = {
     channelId: string;
-    singletonServices: CoreSingletonServices;
     request?: PikkuHTTPRequest<ChannelData>;
     response?: PikkuHTTPResponse;
-    createWireServices?: CreateWireServices;
 };
 export interface ChannelMessageMeta {
     pikkuFuncId: string;

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

@@ -1,3 +1,8 @@
-import { CoreChannel, RunChannelOptions, RunChannelParams } from '../channel.types.js';
+import type { CoreChannel, RunChannelOptions } from '../channel.types.js';
 import { PikkuLocalChannelHandler } from './local-channel-handler.js';
-export declare const runLocalChannel: ({ singletonServices, channelId, request, response, route, createWireServices, skipUserSession, respondWith404, coerceDataFromSchema, logWarningsForStatusCodes, bubbleErrors, }: Partial<Pick<CoreChannel<unknown, any>, "route">> & RunChannelOptions & RunChannelParams<unknown>) => Promise<PikkuLocalChannelHandler | void>;
+import type { PikkuHTTPRequest, PikkuHTTPResponse } from '../../http/http.types.js';
+export declare const runLocalChannel: ({ channelId, request, response, route, skipUserSession, respondWith404, coerceDataFromSchema, logWarningsForStatusCodes, bubbleErrors, }: Partial<Pick<CoreChannel<unknown, any>, "route">> & RunChannelOptions & {
+    channelId: string;
+    request?: PikkuHTTPRequest;
+    response?: PikkuHTTPResponse;
+}) => Promise<PikkuLocalChannelHandler | void>;

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

@@ -6,7 +6,10 @@ import { PikkuLocalChannelHandler } from './local-channel-handler.js';
 import { handleHTTPError } from '../../../handle-error.js';
 import { PikkuSessionService, createMiddlewareSessionWireProps, } from '../../../services/user-session-service.js';
 import { runChannelLifecycleWithMiddleware } from '../channel-common.js';
-export const runLocalChannel = async ({ singletonServices, channelId, request, response, route, createWireServices, skipUserSession = false, respondWith404 = true, coerceDataFromSchema = true, logWarningsForStatusCodes = [], bubbleErrors = false, }) => {
+import { getSingletonServices, getCreateWireServices, } from '../../../pikku-state.js';
+export const runLocalChannel = async ({ channelId, request, response, route, skipUserSession = false, respondWith404 = true, coerceDataFromSchema = true, logWarningsForStatusCodes = [], bubbleErrors = false, }) => {
+    const singletonServices = getSingletonServices();
+    const createWireServices = getCreateWireServices();
     let wireServices;
     let closedWireServices = false;
     let channelHandler;
@@ -21,12 +24,10 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
         ;
         ({ openingData, channelConfig, meta } = await openChannel({
             channelId,
-            createWireServices,
             respondWith404,
             request,
             response,
             route,
-            singletonServices,
             skipUserSession,
             coerceDataFromSchema,
             userSession,

package/dist/wirings/channel/local/local-eventhub-service.d.ts

@@ -1,5 +1,5 @@
-import { PikkuChannelHandler } from '../channel.types.js';
-import { EventHubService } from '../eventhub-service.js';
+import type { PikkuChannelHandler } from '../channel.types.js';
+import type { EventHubService } from '../eventhub-service.js';
 /**
  * Implementation of the SubscriptionService interface.
  * Manages subscriptions and publishes messages to subscribers.

package/dist/wirings/channel/log-channels.d.ts

@@ -1,4 +1,4 @@
-import { Logger } from '../../services/index.js';
+import type { Logger } from '../../services/index.js';
 /**
  * Logs all the loaded channels.
  * @param logger - A logger for logging information.

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

@@ -1,4 +1,4 @@
-import { PikkuChannel, PikkuChannelHandler } from './channel.types.js';
+import type { PikkuChannel, PikkuChannelHandler } from './channel.types.js';
 export declare abstract class PikkuAbstractChannelHandler<OpeningData = unknown, Out = unknown> implements PikkuChannelHandler<OpeningData, Out> {
     channelId: string;
     channelName: string;

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

@@ -1,10 +1,10 @@
 import type { CoreChannel, RunChannelOptions, RunChannelParams, PikkuChannelHandlerFactory } from '../channel.types.js';
-import { ChannelStore } from '../channel-store.js';
+import type { ChannelStore } from '../channel-store.js';
 export interface RunServerlessChannelParams<ChannelData> extends RunChannelParams<ChannelData> {
     channelStore: ChannelStore;
     channelHandlerFactory: PikkuChannelHandlerFactory;
     channelObject?: unknown;
 }
-export declare const runChannelConnect: ({ singletonServices, channelId, channelObject, request, response, route, createWireServices, channelStore, channelHandlerFactory, coerceDataFromSchema, logWarningsForStatusCodes, respondWith404, bubbleErrors, }: Pick<CoreChannel<unknown, any>, "route"> & RunChannelOptions & RunServerlessChannelParams<unknown>) => Promise<void>;
-export declare const runChannelDisconnect: ({ singletonServices, ...params }: RunServerlessChannelParams<unknown>) => Promise<void>;
-export declare const runChannelMessage: ({ singletonServices, ...params }: RunServerlessChannelParams<unknown>, data: unknown) => Promise<unknown>;
+export declare const runChannelConnect: ({ channelId, channelObject, request, response, route, channelStore, channelHandlerFactory, coerceDataFromSchema, logWarningsForStatusCodes, respondWith404, bubbleErrors, }: Pick<CoreChannel<unknown, any>, "route"> & RunChannelOptions & RunServerlessChannelParams<unknown>) => Promise<void>;
+export declare const runChannelDisconnect: ({ channelId, channelStore, channelHandlerFactory, }: RunServerlessChannelParams<unknown>) => Promise<void>;
+export declare const runChannelMessage: ({ channelId, channelStore, channelHandlerFactory, }: RunServerlessChannelParams<unknown>, data: unknown) => Promise<unknown>;

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

@@ -4,7 +4,7 @@ import { openChannel } from '../channel-runner.js';
 import { createHTTPWire } from '../../http/http-runner.js';
 import { handleHTTPError } from '../../../handle-error.js';
 import { PikkuSessionService, createMiddlewareSessionWireProps, } from '../../../services/user-session-service.js';
-import { pikkuState } from '../../../pikku-state.js';
+import { getSingletonServices, getCreateWireServices, pikkuState, } from '../../../pikku-state.js';
 import { PikkuFetchHTTPRequest } from '../../http/pikku-fetch-http-request.js';
 import { runChannelLifecycleWithMiddleware } from '../channel-common.js';
 const getVariablesForChannel = ({ channelId, channelName, channelHandlerFactory, openingData, }) => {
@@ -26,7 +26,9 @@ const getVariablesForChannel = ({ channelId, channelName, channelHandlerFactory,
         meta,
     };
 };
-export const runChannelConnect = async ({ singletonServices, channelId, channelObject, request, response, route, createWireServices, channelStore, channelHandlerFactory, coerceDataFromSchema = true, logWarningsForStatusCodes = [], respondWith404 = true, bubbleErrors = false, }) => {
+export const runChannelConnect = async ({ channelId, channelObject, request, response, route, channelStore, channelHandlerFactory, coerceDataFromSchema = true, logWarningsForStatusCodes = [], respondWith404 = true, bubbleErrors = false, }) => {
+    const singletonServices = getSingletonServices();
+    const createWireServices = getCreateWireServices();
     let wireServices;
     let http;
     if (request instanceof Request) {
@@ -35,10 +37,8 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
     const userSession = new PikkuSessionService(channelStore, channelId);
     const { channelConfig, openingData, meta } = await openChannel({
         channelId,
-        createWireServices,
         request,
         route,
-        singletonServices,
         coerceDataFromSchema,
         userSession,
     });
@@ -88,7 +88,9 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
         }
     }
 };
-export const runChannelDisconnect = async ({ singletonServices, ...params }) => {
+export const runChannelDisconnect = async ({ channelId, channelStore, channelHandlerFactory, }) => {
+    const singletonServices = getSingletonServices();
+    const createWireServices = getCreateWireServices();
     let wireServices;
     // Try to get channel from store. In serverless environments (especially with
     // serverless-offline or worker threads), disconnect can be called multiple times
@@ -96,26 +98,27 @@ export const runChannelDisconnect = async ({ singletonServices, ...params }) =>
     // there's nothing to disconnect, so we can return early.
     let channelData;
     try {
-        channelData = await params.channelStore.getChannelAndSession(params.channelId);
+        channelData = await channelStore.getChannelAndSession(channelId);
     }
-    catch (error) {
-        singletonServices.logger.info(`Channel ${params.channelId} not found during disconnect - already cleaned up`);
+    catch {
+        singletonServices.logger.info(`Channel ${channelId} not found during disconnect - already cleaned up`);
         return;
     }
     const { openingData, channelName, session } = channelData;
     const { channel, channelConfig, meta } = getVariablesForChannel({
-        ...params,
+        channelId,
+        channelHandlerFactory,
         openingData,
         channelName,
     });
-    const userSession = new PikkuSessionService(params.channelStore, params.channelId);
+    const userSession = new PikkuSessionService(channelStore, channelId);
     userSession.setInitial(session);
     const wire = {
         channel,
         ...createMiddlewareSessionWireProps(userSession),
     };
-    if (!wireServices && params.createWireServices) {
-        wireServices = await params.createWireServices(singletonServices, wire);
+    if (createWireServices) {
+        wireServices = await createWireServices(singletonServices, wire);
     }
     const services = {
         ...singletonServices,
@@ -137,27 +140,30 @@ export const runChannelDisconnect = async ({ singletonServices, ...params }) =>
             singletonServices.logger.error(`Error handling onDisconnect: ${e.message || e}`);
         }
     }
-    await params.channelStore.removeChannels([channel.channelId]);
+    await channelStore.removeChannels([channel.channelId]);
     if (wireServices) {
         await closeWireServices(singletonServices.logger, wireServices);
     }
 };
-export const runChannelMessage = async ({ singletonServices, ...params }, data) => {
+export const runChannelMessage = async ({ channelId, channelStore, channelHandlerFactory, }, data) => {
+    const singletonServices = getSingletonServices();
+    const createWireServices = getCreateWireServices();
     let wireServices;
-    const { openingData, channelName, session } = await params.channelStore.getChannelAndSession(params.channelId);
+    const { openingData, channelName, session } = await channelStore.getChannelAndSession(channelId);
     const { channel, channelHandler, channelConfig } = getVariablesForChannel({
-        ...params,
+        channelId,
+        channelHandlerFactory,
         openingData,
         channelName,
     });
-    const userSession = new PikkuSessionService(params.channelStore, params.channelId);
+    const userSession = new PikkuSessionService(channelStore, channelId);
     userSession.setInitial(session);
     const wire = {
         channel,
         ...createMiddlewareSessionWireProps(userSession),
     };
-    if (params.createWireServices) {
-        wireServices = await params.createWireServices(singletonServices, wire);
+    if (createWireServices) {
+        wireServices = await createWireServices(singletonServices, wire);
     }
     const services = {
         ...singletonServices,

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

@@ -1,4 +1,4 @@
-import { CorePikkuCLIRender } from '../cli.types.js';
+import type { CorePikkuCLIRender } from '../cli.types.js';
 /**
  * Execute a CLI program via WebSocket channel
  * This is the main entry point for CLI-over-Channel clients

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

@@ -1,5 +1,5 @@
-import { CorePikkuMiddleware, CoreUserSession } from '../../types/core.types.js';
-import { CoreCLI, CorePikkuCLIRender, CoreCLICommandConfig } from './cli.types.js';
+import type { CorePikkuMiddleware, CoreUserSession } from '../../types/core.types.js';
+import type { CoreCLI, CorePikkuCLIRender, CoreCLICommandConfig } from './cli.types.js';
 import type { CoreSingletonServices, CoreServices, CreateWireServices, CreateConfig, CreateSingletonServices } from '../../types/core.types.js';
 /**
  * CLI command execution error - thrown when CLI execution fails

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

@@ -1,6 +1,6 @@
-import { CorePikkuMiddleware, CoreSingletonServices, CoreUserSession, CoreServices, MiddlewareMetadata, PermissionMetadata } from '../../types/core.types.js';
-import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuFunction, CorePikkuFunctionSessionless } from '../../function/functions.types.js';
-import { PikkuChannel } from '../channel/channel.types.js';
+import type { CorePikkuMiddleware, CoreSingletonServices, CoreUserSession, CoreServices, MiddlewareMetadata, PermissionMetadata } from '../../types/core.types.js';
+import type { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuFunction, CorePikkuFunctionSessionless } from '../../function/functions.types.js';
+import type { PikkuChannel } from '../channel/channel.types.js';
 /**
  * CLI option definition
  */

package/dist/wirings/cli/command-parser.d.ts

@@ -1,4 +1,4 @@
-import { CLIMeta } from './cli.types.js';
+import type { CLIMeta } from './cli.types.js';
 /**
  * Result of parsing CLI arguments
  */

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

@@ -1,6 +1,6 @@
-import { CoreHTTPFunctionWiring, RunHTTPWiringOptions, RunHTTPWiringParams, PikkuHTTP, PikkuHTTPRequest, PikkuHTTPResponse } from './http.types.js';
-import { CorePikkuFunction, CorePikkuFunctionSessionless, CorePikkuPermission, CorePermissionGroup } from '../../function/functions.types.js';
-import { CorePikkuMiddleware, CorePikkuMiddlewareGroup } from '../../types/core.types.js';
+import type { CoreHTTPFunctionWiring, RunHTTPWiringOptions, PikkuHTTP, PikkuHTTPRequest, PikkuHTTPResponse } from './http.types.js';
+import type { CorePikkuFunction, CorePikkuFunctionSessionless, CorePikkuPermission, CorePermissionGroup } from '../../function/functions.types.js';
+import type { CorePikkuMiddleware, CorePikkuMiddlewareGroup } from '../../types/core.types.js';
 import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
 /**
  * Registers HTTP middleware for a specific route pattern.
@@ -101,10 +101,10 @@ export declare const createHTTPWire: (request: PikkuHTTPRequest | undefined, res
  * @template In Expected input data type.
  * @template Out Expected output data type.
  * @param {Request} request - The native Fetch API Request object.
- * @param {RunHTTPWiringOptions & RunHTTPWiringParams} params - Additional options including services and session management.
+ * @param {RunHTTPWiringOptions} params - Additional options including services and session management.
  * @returns {Promise<Response>} A promise that resolves to a Fetch API Response object.
  */
-export declare const fetch: <In, Out>(request: Request, params: RunHTTPWiringOptions & RunHTTPWiringParams) => Promise<Response>;
+export declare const fetch: <In, Out>(request: Request, params?: RunHTTPWiringOptions) => Promise<Response>;
 /**
  * Executes an HTTP route using a Pikku-specific request wrapper.
  *
@@ -114,10 +114,10 @@ export declare const fetch: <In, Out>(request: Request, params: RunHTTPWiringOpt
  * @template In Expected input data type.
  * @template Out Expected output data type.
  * @param {Request | PikkuHTTPRequest} request - The request object.
- * @param {RunHTTPWiringOptions & RunHTTPWiringParams} params - Execution options including services and session configuration.
+ * @param {RunHTTPWiringOptions} params - Execution options including services and session configuration.
  * @returns {Promise<PikkuFetchHTTPResponse>} A promise that resolves to a PikkuFetchHTTPResponse object.
  */
-export declare const pikkuFetch: <In, Out>(request: Request | PikkuHTTPRequest, params: RunHTTPWiringOptions & RunHTTPWiringParams) => Promise<PikkuFetchHTTPResponse>;
+export declare const pikkuFetch: <In, Out>(request: Request | PikkuHTTPRequest, params?: RunHTTPWiringOptions) => Promise<PikkuFetchHTTPResponse>;
 /**
  * Core function to process an HTTP request through route matching, validation,
  * middleware execution, error handling, and session service cleanup.
@@ -133,7 +133,7 @@ export declare const pikkuFetch: <In, Out>(request: Request | PikkuHTTPRequest,
  * @template Out Expected output data type.
  * @param {Request | PikkuHTTPRequest} request - The incoming HTTP request.
  * @param {PikkuHTTPResponse} response - The response object to be populated.
- * @param {RunHTTPWiringOptions & RunHTTPWiringParams} options - Options such as singleton services, session handling, and error configuration.
+ * @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, { singletonServices, createWireServices, skipUserSession, respondWith404, logWarningsForStatusCodes, coerceDataFromSchema, bubbleErrors, generateRequestId, }: RunHTTPWiringOptions & RunHTTPWiringParams) => Promise<Out | void>;
+export declare const fetchData: <In, Out>(request: Request | PikkuHTTPRequest, response: PikkuHTTPResponse, { skipUserSession, respondWith404, logWarningsForStatusCodes, coerceDataFromSchema, bubbleErrors, generateRequestId, }?: RunHTTPWiringOptions) => Promise<Out | void>;

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

@@ -1,6 +1,7 @@
 import { NotFoundError, PikkuMissingMetaError } from '../../errors/errors.js';
 import { closeWireServices, createWeakUID, isSerializable, } from '../../utils.js';
-import { PikkuSessionService, createMiddlewareSessionWireProps, } from '../../services/user-session-service.js';
+import { getSingletonServices, getCreateWireServices, } from '../../pikku-state.js';
+import { PikkuSessionService } from '../../services/user-session-service.js';
 import { handleHTTPError } from '../../handle-error.js';
 import { pikkuState } from '../../pikku-state.js';
 import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
@@ -8,6 +9,7 @@ import { PikkuFetchHTTPRequest } from './pikku-fetch-http-request.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 import { httpRouter } from './routers/http-router.js';
 import { validateSchema } from '../../schema.js';
+import { runMiddleware } from '../../middleware-runner.js';
 /**
  * Extract headers from a PikkuHTTPRequest based on the schema keys
  */
@@ -248,7 +250,10 @@ const executeRoute = async (services, matchedRoute, http, options) => {
     const wire = {
         http,
         channel,
-        ...createMiddlewareSessionWireProps(userSession),
+        session: userSession.get(),
+        setSession: (s) => userSession.setInitial(s),
+        getSession: () => userSession.get(),
+        hasSessionChanged: () => userSession.sessionChanged,
     };
     result = await runPikkuFunc('http', `${meta.method}:${meta.route}`, meta.pikkuFuncId, {
         singletonServices,
@@ -290,10 +295,10 @@ const executeRoute = async (services, matchedRoute, http, options) => {
  * @template In Expected input data type.
  * @template Out Expected output data type.
  * @param {Request} request - The native Fetch API Request object.
- * @param {RunHTTPWiringOptions & RunHTTPWiringParams} params - Additional options including services and session management.
+ * @param {RunHTTPWiringOptions} params - Additional options including services and session management.
  * @returns {Promise<Response>} A promise that resolves to a Fetch API Response object.
  */
-export const fetch = async (request, params) => {
+export const fetch = async (request, params = {}) => {
     const pikkuResponse = new PikkuFetchHTTPResponse();
     await fetchData(request, pikkuResponse, params);
     return pikkuResponse.toResponse();
@@ -307,10 +312,10 @@ export const fetch = async (request, params) => {
  * @template In Expected input data type.
  * @template Out Expected output data type.
  * @param {Request | PikkuHTTPRequest} request - The request object.
- * @param {RunHTTPWiringOptions & RunHTTPWiringParams} params - Execution options including services and session configuration.
+ * @param {RunHTTPWiringOptions} params - Execution options including services and session configuration.
  * @returns {Promise<PikkuFetchHTTPResponse>} A promise that resolves to a PikkuFetchHTTPResponse object.
  */
-export const pikkuFetch = async (request, params) => {
+export const pikkuFetch = async (request, params = {}) => {
     const pikkuResponse = new PikkuFetchHTTPResponse();
     await fetchData(request, pikkuResponse, params);
     return pikkuResponse;
@@ -330,24 +335,39 @@ export const pikkuFetch = async (request, params) => {
  * @template Out Expected output data type.
  * @param {Request | PikkuHTTPRequest} request - The incoming HTTP request.
  * @param {PikkuHTTPResponse} response - The response object to be populated.
- * @param {RunHTTPWiringOptions & RunHTTPWiringParams} options - Options such as singleton services, session handling, and error configuration.
+ * @param {RunHTTPWiringOptions} options - Options such as singleton services, session handling, and error configuration.
  * @returns {Promise<Out | void>} The output from the route handler or void if an error occurred.
  */
-export const fetchData = async (request, response, { singletonServices, createWireServices, skipUserSession = false, respondWith404 = true, logWarningsForStatusCodes = [], coerceDataFromSchema = true, bubbleErrors = false, generateRequestId, }) => {
-    const requestId = request.getHeader?.('x-request-id') ||
-        generateRequestId?.() ||
-        createWeakUID();
+export const fetchData = async (request, response, { skipUserSession = false, respondWith404 = true, logWarningsForStatusCodes = [], coerceDataFromSchema = true, bubbleErrors = false, generateRequestId, } = {}) => {
+    const singletonServices = getSingletonServices();
+    const createWireServices = getCreateWireServices();
     let wireServices;
     let result;
     // Combine the request and response into one wire object
-    const http = createHTTPWire(request instanceof Request ? new PikkuFetchHTTPRequest(request) : request, response);
+    const pikkuRequest = request instanceof Request ? new PikkuFetchHTTPRequest(request) : request;
+    let requestId = null;
+    try {
+        requestId = pikkuRequest.header('x-request-id');
+    }
+    catch { }
+    requestId = requestId || generateRequestId?.() || createWeakUID();
+    const http = createHTTPWire(pikkuRequest, response);
     const apiType = http.request.method();
     const apiRoute = http.request.path();
     // Locate the matching route based on the HTTP method and path
     const matchedRoute = getMatchingRoute(apiType, apiRoute);
     try {
-        // If no route matches, log the occurrence and throw a NotFoundError
         if (!matchedRoute) {
+            if (apiType.toLowerCase() === 'options') {
+                const httpGroups = pikkuState(null, 'middleware', 'httpGroup');
+                const globalMiddleware = httpGroups['*'];
+                const wire = { http: http };
+                if (globalMiddleware) {
+                    await runMiddleware(singletonServices, wire, globalMiddleware);
+                }
+                response.status(204).json(undefined);
+                return;
+            }
             singletonServices.logger.info({
                 message: 'Route not found',
                 apiRoute,
@@ -366,7 +386,6 @@ export const fetchData = async (request, response, { singletonServices, createWi
         return result;
     }
     catch (e) {
-        // Handle errors and, depending on configuration, bubble them up or respond with an error
         handleHTTPError(e, http, requestId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
     }
     finally {