@pikku/core 0.12.1 → 0.12.2

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 ## 0.12.0
 
+## 0.12.2
+
+### Patch Changes
+
+- cc4c9e9: Add gateway meta-wiring for messaging platforms:
+
+  - New `wireGateway()` API with three transport types: webhook, websocket, listener
+  - `GatewayAdapter` interface for platform-specific parse/send logic
+  - `PikkuGateway` wire object (`wire.gateway`) with senderId, platform, and send()
+  - `GatewayService` interface and `LocalGatewayService` for listener gateway lifecycle
+  - `createListenerMessageHandler()` helper for building listener message callbacks
+  - Add `'gateway'` to `PikkuWiringTypes` and `gateway` to `PikkuWire`
+  - Add `gateway` state block to `PikkuPackageState`
+
+- 3e04565: chore: update dependencies to latest minor/patch versions
+
 ## 0.12.1
 
 ### Patch Changes

package/dist/middleware-runner.js

@@ -96,6 +96,7 @@ const middlewareCache = {
     agent: {},
     cli: {},
     workflow: {},
+    gateway: {},
 };
 /**
  * Combines wiring-specific middleware with function-level middleware.

package/dist/permissions.js

@@ -99,6 +99,7 @@ const combinedPermissionsCache = {
     agent: {},
     cli: {},
     workflow: {},
+    gateway: {},
 };
 /**
  * Combines wiring-specific permissions with function-level permissions.

package/dist/pikku-state.js

@@ -92,6 +92,10 @@ const createEmptyPackageState = () => ({
         agents: new Map(),
         agentsMeta: {},
     },
+    gateway: {
+        gateways: new Map(),
+        meta: {},
+    },
     cli: {
         meta: { programs: {}, renderers: {} },
         programs: {},

package/dist/services/gateway-service.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Abstract GatewayService interface.
+ *
+ * Implementations manage listener gateway lifecycle — initializing adapters
+ * and delivering messages to handler functions.
+ *
+ * A `LocalGatewayService` starts all listeners unconditionally;
+ * a distributed implementation could check leader election first.
+ */
+export interface GatewayService {
+    /**
+     * Start all listener gateways
+     */
+    start(): Promise<void>;
+    /**
+     * Stop all listener gateways
+     */
+    stop(): Promise<void>;
+}

package/dist/services/gateway-service.js

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

package/dist/services/index.d.ts

@@ -12,6 +12,7 @@ export { ConsoleLogger } from './logger-console.js';
 export { InMemoryWorkflowService } from './in-memory-workflow-service.js';
 export { InMemoryTriggerService } from './in-memory-trigger-service.js';
 export { InMemoryAIRunStateService } from './in-memory-ai-run-state-service.js';
+export { LocalGatewayService } from './local-gateway-service.js';
 export type { ContentService } from './content-service.js';
 export type { JWTService } from './jwt-service.js';
 export type { Logger } from './logger.js';
@@ -21,6 +22,7 @@ export type { SchemaService } from './schema-service.js';
 export type { SessionService } from './user-session-service.js';
 export type { ScheduledTaskSummary, ScheduledTaskInfo, SchedulerService, } from './scheduler-service.js';
 export type { TriggerService } from './trigger-service.js';
+export type { GatewayService } from './gateway-service.js';
 export type { DeploymentService, DeploymentConfig, DeploymentInfo, DeploymentServiceConfig, } from './deployment-service.js';
 export type { AIStorageService } from './ai-storage-service.js';
 export type { AIAgentRunnerParams, AIAgentRunnerResult, AIAgentStepResult, AIAgentRunnerService, } from './ai-agent-runner-service.js';

package/dist/services/index.js

@@ -12,3 +12,4 @@ export { ConsoleLogger } from './logger-console.js';
 export { InMemoryWorkflowService } from './in-memory-workflow-service.js';
 export { InMemoryTriggerService } from './in-memory-trigger-service.js';
 export { InMemoryAIRunStateService } from './in-memory-ai-run-state-service.js';
+export { LocalGatewayService } from './local-gateway-service.js';

package/dist/services/local-gateway-service.d.ts

@@ -0,0 +1,22 @@
+import type { GatewayService } from './gateway-service.js';
+/**
+ * Local GatewayService implementation.
+ *
+ * Starts all registered listener gateways unconditionally (single-process).
+ * For distributed deployments, implement `GatewayService` with leader
+ * election or similar coordination.
+ *
+ * @example
+ * ```typescript
+ * const gatewayService = new LocalGatewayService()
+ * await gatewayService.start()
+ *
+ * // On shutdown
+ * await gatewayService.stop()
+ * ```
+ */
+export declare class LocalGatewayService implements GatewayService {
+    private activeAdapters;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/services/local-gateway-service.js

@@ -0,0 +1,51 @@
+import { pikkuState, getSingletonServices } from '../pikku-state.js';
+import { createListenerMessageHandler } from '../wirings/gateway/gateway-runner.js';
+/**
+ * Local GatewayService implementation.
+ *
+ * Starts all registered listener gateways unconditionally (single-process).
+ * For distributed deployments, implement `GatewayService` with leader
+ * election or similar coordination.
+ *
+ * @example
+ * ```typescript
+ * const gatewayService = new LocalGatewayService()
+ * await gatewayService.start()
+ *
+ * // On shutdown
+ * await gatewayService.stop()
+ * ```
+ */
+export class LocalGatewayService {
+    activeAdapters = new Map();
+    async start() {
+        const singletonServices = getSingletonServices();
+        const gateways = pikkuState(null, 'gateway', 'gateways');
+        for (const [name, config] of gateways) {
+            if (config.type !== 'listener')
+                continue;
+            if (this.activeAdapters.has(name))
+                continue;
+            const handleMessage = createListenerMessageHandler(name, config, singletonServices);
+            await config.adapter.init(handleMessage);
+            this.activeAdapters.set(name, config.adapter);
+            singletonServices.logger.info(`Started listener gateway: ${name}`);
+        }
+    }
+    async stop() {
+        for (const [name, adapter] of this.activeAdapters) {
+            try {
+                await adapter.close();
+            }
+            catch (e) {
+                try {
+                    getSingletonServices().logger.error(`Error closing listener gateway '${name}':`, e);
+                }
+                catch {
+                    // logger may not be available during shutdown
+                }
+            }
+        }
+        this.activeAdapters.clear();
+    }
+}

package/dist/types/core.types.d.ts

@@ -13,6 +13,7 @@ import type { PikkuCLI } from '../wirings/cli/cli.types.js';
 import type { PikkuWorkflowWire, WorkflowService, WorkflowServiceConfig, WorkflowStepWire } from '../wirings/workflow/workflow.types.js';
 import type { PikkuGraphWire } from '../wirings/workflow/graph/workflow-graph.types.js';
 import type { PikkuTrigger } from '../wirings/trigger/trigger.types.js';
+import type { PikkuGateway } from '../wirings/gateway/gateway.types.js';
 import type { SchedulerService } from '../services/scheduler-service.js';
 import type { DeploymentService } from '../services/deployment-service.js';
 import type { AIStorageService } from '../services/ai-storage-service.js';
@@ -20,7 +21,7 @@ import type { ContentService } from '../services/content-service.js';
 import type { AIAgentRunnerService } from '../services/ai-agent-runner-service.js';
 import type { AIRunStateService } from '../services/ai-run-state-service.js';
 import type { PikkuAIMiddlewareHooks } from '../wirings/ai-agent/ai-agent.types.js';
-export type PikkuWiringTypes = 'http' | 'scheduler' | 'trigger' | 'channel' | 'rpc' | 'queue' | 'mcp' | 'cli' | 'workflow' | 'agent';
+export type PikkuWiringTypes = 'http' | 'scheduler' | 'trigger' | 'channel' | 'rpc' | 'queue' | 'mcp' | 'cli' | 'workflow' | 'agent' | 'gateway';
 export interface FunctionServicesMeta {
     optimized: boolean;
     services: string[];
@@ -182,6 +183,7 @@ export type PikkuWire<In = unknown, Out = unknown, HasInitialSession extends boo
     workflowStep: WorkflowStepWire;
     graph: PikkuGraphWire;
     trigger: PikkuTrigger<TriggerOutput>;
+    gateway: PikkuGateway;
     session: HasInitialSession extends true ? UserSession : UserSession | undefined;
     /** Update and persist the current session */
     setSession: (session: CoreUserSession) => Promise<void> | void;

package/dist/types/state.types.d.ts

@@ -6,6 +6,7 @@ import type { CLIMeta, CLIProgramState } from '../wirings/cli/cli.types.js';
 import type { HTTPMethod, CoreHTTPFunctionWiring, HTTPWiringsMeta } from '../wirings/http/http.types.js';
 import type { CoreMCPResource, MCPResourceMeta, MCPToolMeta, CoreMCPPrompt, MCPPromptMeta } from '../wirings/mcp/mcp.types.js';
 import type { CoreAIAgent, AIAgentMeta } from '../wirings/ai-agent/ai-agent.types.js';
+import type { CoreGateway, GatewaysMeta } from '../wirings/gateway/gateway.types.js';
 import type { CoreQueueWorker, QueueWorkersMeta } from '../wirings/queue/queue.types.js';
 import type { CoreScheduledTask, ScheduledTasksMeta } from '../wirings/scheduler/scheduler.types.js';
 import type { CoreWorkflow, WorkflowsRuntimeMeta } from '../wirings/workflow/workflow.types.js';
@@ -74,6 +75,10 @@ export interface PikkuPackageState {
         agents: Map<string, CoreAIAgent>;
         agentsMeta: AIAgentMeta;
     };
+    gateway: {
+        gateways: Map<string, CoreGateway>;
+        meta: GatewaysMeta;
+    };
     cli: {
         meta: CLIMeta | Record<string, any>;
         programs: Record<string, CLIProgramState>;

package/dist/utils.js

@@ -82,7 +82,7 @@ const stopService = async (logger, name, service) => {
 export const stopSingletonServices = async () => {
     const singletonServices = getSingletonServices();
     const logger = singletonServices.logger;
-    // First, stop all addon package singleton services
+    // Stop all addon package singleton services
     const stateMap = getAllPackageStates();
     if (stateMap.size > 0) {
         for (const [packageName, packageState] of stateMap) {

package/dist/wirings/ai-agent/ai-agent-assistant-ui.js

@@ -29,6 +29,7 @@ export function createAssistantUIChannel(parent) {
             return parent.state;
         },
         close: () => parent.close(),
+        sendBinary: (data) => parent.sendBinary(data),
         send: (event) => {
             switch (event.type) {
                 case 'text-delta':
@@ -39,6 +40,14 @@ export function createAssistantUIChannel(parent) {
                     ensureStarted();
                     sendChunk({ type: 'reasoning-delta', delta: event.text });
                     break;
+                case 'audio-delta':
+                    ensureStarted();
+                    sendChunk({ type: 'audio-delta', data: event });
+                    break;
+                case 'audio-done':
+                    ensureStarted();
+                    sendChunk({ type: 'audio-done', data: event });
+                    break;
                 case 'tool-call':
                     ensureStarted();
                     hasToolCalls = true;
@@ -126,21 +135,34 @@ export function parseAssistantUIInput(input, defaults) {
         throw new Error('No user message found in assistant-ui input');
     }
     let messageText;
+    let attachments;
+    const extractFromParts = (parts) => {
+        const textParts = parts.filter((p) => p.type === 'text');
+        messageText = textParts.map((p) => String(p.text)).join(' ') || '';
+        const nonTextParts = parts.filter((p) => p.type === 'image' || p.type === 'file');
+        if (nonTextParts.length > 0) {
+            attachments = nonTextParts.map((p) => ({
+                type: p.type,
+                data: p.data,
+                url: p.url,
+                mediaType: p.mediaType,
+                filename: p.filename,
+            }));
+        }
+    };
     if (typeof lastUserMessage.content === 'string') {
         messageText = lastUserMessage.content;
     }
     else if (Array.isArray(lastUserMessage.parts)) {
-        const textPart = lastUserMessage.parts.find((p) => p.type === 'text');
-        messageText = textPart ? String(textPart.text) : '';
+        extractFromParts(lastUserMessage.parts);
     }
     else if (Array.isArray(lastUserMessage.content)) {
-        const textPart = lastUserMessage.content.find((p) => p.type === 'text');
-        messageText = textPart ? String(textPart.text) : '';
+        extractFromParts(lastUserMessage.content);
     }
     else {
         messageText = '';
     }
     const threadId = input.threadId ?? input.id ?? randomUUID();
     const resourceId = defaults?.resourceId ?? 'default';
-    return { message: messageText, threadId, resourceId };
+    return { message: messageText, threadId, resourceId, attachments };
 }

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

@@ -175,8 +175,19 @@ function sanitizeToolMessages(messages) {
 }
 function estimateTokens(msg) {
     let chars = 0;
-    if (msg.content)
-        chars += msg.content.length;
+    if (msg.content) {
+        if (typeof msg.content === 'string') {
+            chars += msg.content.length;
+        }
+        else {
+            for (const part of msg.content) {
+                if (part.type === 'text')
+                    chars += part.text.length;
+                else
+                    chars += 1000;
+            }
+        }
+    }
     if (msg.toolCalls)
         chars += JSON.stringify(msg.toolCalls).length;
     if (msg.toolResults)

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

@@ -73,6 +73,7 @@ export function createScopedChannel(parent, agentName, session) {
             return capturedApproval;
         },
         close: () => { },
+        sendBinary: (data) => parent.sendBinary(data),
         send: (event) => {
             if (event.type === 'done')
                 return;
@@ -307,10 +308,22 @@ export async function prepareAgentRun(agentName, input, params, agentSessionMap,
         });
     }
     const contextMessages = await loadContextMessages(memoryConfig, storage, input, workingMemoryJsonSchema);
+    const userContent = input.attachments?.length
+        ? [
+            { type: 'text', text: input.message },
+            ...input.attachments.map((a) => ({
+                type: a.type,
+                data: a.data,
+                url: a.url,
+                mediaType: a.mediaType,
+                ...(a.filename ? { filename: a.filename } : {}),
+            })),
+        ]
+        : input.message;
     const userMessage = {
         id: randomUUID(),
         role: 'user',
-        content: input.message,
+        content: userContent,
         createdAt: new Date(),
     };
     const allMessages = [...contextMessages, ...messages, userMessage];

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

@@ -57,6 +57,7 @@ function createPersistingChannel(parent, storage, threadId) {
         },
         flush: flushStep,
         close: () => parent.close(),
+        sendBinary: (data) => parent.sendBinary(data),
         send: (event) => {
             if (storage) {
                 switch (event.type) {
@@ -345,8 +346,15 @@ export async function streamAIAgent(agentName, input, channel, params, agentSess
                 allEvents,
                 state,
             });
-            if (result != null)
+            if (result == null)
+                return;
+            if (Array.isArray(result)) {
+                for (const r of result)
+                    await next(r);
+            }
+            else {
                 await next(result);
+            }
         };
     });
     const agentsMeta = pikkuState(packageName, 'agent', 'agentsMeta');
@@ -586,8 +594,15 @@ async function continueAfterToolResult(run, agent, packageName, resolvedName, st
                 allEvents,
                 state,
             });
-            if (result != null)
+            if (result == null)
+                return;
+            if (Array.isArray(result)) {
+                for (const r of result)
+                    await next(r);
+            }
+            else {
                 await next(result);
+            }
         };
     });
     const allChannelMiddleware = combineChannelMiddleware('agent', `stream:${run.agentName}`, {

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

@@ -10,6 +10,21 @@ export interface AIThread {
     createdAt: Date;
     updatedAt: Date;
 }
+export type AIContentPart = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    data?: string;
+    url?: string;
+    mediaType?: string;
+} | {
+    type: 'file';
+    data?: string;
+    url?: string;
+    mediaType: string;
+    filename?: string;
+};
 export interface AIToolCall {
     id: string;
     name: string;
@@ -23,7 +38,7 @@ export interface AIToolResult {
 export interface AIMessage {
     id: string;
     role: 'system' | 'user' | 'assistant' | 'tool';
-    content?: string;
+    content?: string | AIContentPart[];
     toolCalls?: AIToolCall[];
     toolResults?: AIToolResult[];
     createdAt: Date;
@@ -39,10 +54,18 @@ export interface AIAgentStep {
         result: string;
     }[];
 }
+export interface AIAgentInputAttachment {
+    type: 'image' | 'file';
+    data?: string;
+    url?: string;
+    mediaType?: string;
+    filename?: string;
+}
 export interface AIAgentInput {
     message: string;
     threadId: string;
     resourceId: string;
+    attachments?: AIAgentInputAttachment[];
 }
 export interface AIAgentOutput {
     runId: string;
@@ -77,7 +100,7 @@ export interface PikkuAIMiddlewareHooks<State extends Record<string, unknown> =
         event: AIStreamEvent;
         allEvents: readonly AIStreamEvent[];
         state: State;
-    }) => Promise<AIStreamEvent | null> | AIStreamEvent | null;
+    }) => Promise<AIStreamEvent | AIStreamEvent[] | null> | AIStreamEvent | AIStreamEvent[] | null;
     modifyOutput?: (services: Services, ctx: {
         text: string;
         messages: AIMessage[];
@@ -235,6 +258,16 @@ export type AIStreamEvent = {
     message: string;
     agent?: string;
     session?: string;
+} | {
+    type: 'audio-delta';
+    data: string;
+    format: string;
+    agent?: string;
+    session?: string;
+} | {
+    type: 'audio-done';
+    agent?: string;
+    session?: string;
 } | {
     type: 'suspended';
     reason: 'rpc-missing';

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

@@ -4,4 +4,4 @@ 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';
+export type { AIAgentInput, AIAgentInputAttachment, AIAgentMeta, AIAgentMemoryConfig, AIAgentStep, AIContentPart, AgentRunRow, AgentRunService, AgentRunState, AIMessage, AIStreamChannel, AIStreamEvent, AIThread, CoreAIAgent, PendingApproval, PikkuAIMiddlewareHooks, } from './ai-agent.types.js';

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

@@ -1,4 +1,7 @@
 import type { CoreServices, CoreUserSession } from '../../types/core.types.js';
-import type { CoreChannel, PikkuChannelHandler } from './channel.types.js';
+import type { BinaryData, 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>;
+export declare const processMessageHandlers: (services: CoreServices, channelConfig: CoreChannel<any, any>, channelHandler: PikkuChannelHandler, userSession?: SessionService<CoreUserSession>) => {
+    onMessage: (rawData: unknown) => Promise<unknown>;
+    onBinaryMessage: ((data: BinaryData) => Promise<BinaryData | void>) | undefined;
+};

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

@@ -91,7 +91,7 @@ export const processMessageHandlers = (services, channelConfig, channelHandler,
             },
         });
     };
-    return async (rawData) => {
+    const onMessage = async (rawData) => {
         let result;
         let processed = false;
         // Route-specific handling
@@ -134,4 +134,14 @@ export const processMessageHandlers = (services, channelConfig, channelHandler,
         }
         return result;
     };
+    const onBinaryMessage = channelConfig.onBinaryMessage
+        ? async (data) => {
+            if (!validateAuth(requiresSession, userSession?.get(), channelConfig)) {
+                logger.error(`Channel ${channelConfig.name} with id ${channelHandler.getChannel().channelId} requires a session for binary message`);
+                return;
+            }
+            return channelConfig.onBinaryMessage(services, data, channelHandler.getChannel());
+        }
+        : undefined;
+    return { onMessage, onBinaryMessage };
 };

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

@@ -68,6 +68,7 @@ export function wrapChannelWithMiddleware(wire, services, middlewares) {
         channel: {
             ...channel,
             send: ((data) => dispatch(0, data)),
+            sendBinary: channel.sendBinary,
         },
     };
 }

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

@@ -1,6 +1,7 @@
 import type { PikkuError } from '../../errors/error-handler.js';
 import type { HTTPFunctionMetaInputTypes, PikkuHTTPRequest, PikkuHTTPResponse } from '../http/http.types.js';
 import type { CorePikkuMiddleware, MiddlewareMetadata, PermissionMetadata } from '../../types/core.types.js';
+export type BinaryData = ArrayBuffer | Uint8Array;
 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 type { CorePermissionGroup, CorePikkuFunction, CorePikkuFunctionConfig, CorePikkuFunctionSessionless, CorePikkuPermission } from '../../function/functions.types.js';
@@ -36,6 +37,7 @@ export interface ChannelMeta {
     disconnect: ChannelMessageMeta | null;
     message: ChannelMessageMeta | null;
     messageWirings: Record<string, Record<string, ChannelMessageMeta>>;
+    binary?: boolean | null;
     summary?: string;
     description?: string;
     errors?: string[];
@@ -67,6 +69,8 @@ export type CoreChannel<ChannelData, Channel extends string, ChannelConnect = Co
     channelMiddleware?: Array<CorePikkuChannelMiddleware | CorePikkuChannelMiddlewareFactory>;
     permissions?: CorePermissionGroup<PikkuPermission>;
     auth?: boolean;
+    binary?: boolean | null;
+    onBinaryMessage?: (services: any, data: BinaryData, channel: PikkuChannel<ChannelData, any>) => Promise<BinaryData | void> | BinaryData | void;
     docs?: Partial<{
         description: string;
         response: string;
@@ -79,11 +83,13 @@ export interface PikkuChannel<OpeningData, out Out> {
     channelId: string;
     openingData: OpeningData;
     send(data: Out, isBinary?: boolean): Promise<void> | void;
+    sendBinary(data: BinaryData): Promise<void> | void;
     close(): Promise<void> | void;
     state: 'initial' | 'open' | 'closed';
 }
 export interface PikkuChannelHandler<OpeningData = unknown, Out = unknown> {
     send(message: Out, isBinary?: boolean): Promise<void> | void;
+    sendBinary(data: BinaryData): Promise<void> | void;
     getChannel(): PikkuChannel<OpeningData, Out>;
 }
 export type PikkuChannelHandlerFactory<OpeningData = unknown, Out = unknown> = (channelId: string, channelName: string, openingData: OpeningData) => PikkuChannelHandler<OpeningData, Out>;

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

@@ -6,5 +6,5 @@ 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 type { BinaryData, ChannelsMeta, CoreChannel, CorePikkuChannelMiddleware, CorePikkuChannelMiddlewareFactory, ChannelMessageMeta, ChannelMeta, PikkuChannel, PikkuChannelHandlerFactory, } from './channel.types.js';
 export { defineChannelRoutes } from './define-channel-routes.js';

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

@@ -1,15 +1,22 @@
+import type { BinaryData } from '../channel.types.js';
 import { PikkuAbstractChannelHandler } from '../pikku-abstract-channel-handler.js';
 export declare class PikkuLocalChannelHandler<OpeningData = unknown, Out = unknown> extends PikkuAbstractChannelHandler<OpeningData, Out> {
     private onMessageCallback?;
+    private onBinaryMessageCallback?;
     private openCallBack?;
     private closeCallback?;
     private sendCallback?;
+    private sendBinaryCallback?;
     registerOnOpen(callback: () => void): void;
     open(): void;
     registerOnMessage(callback: (data: any) => Promise<unknown>): void;
     message(data: unknown): Promise<unknown>;
+    registerOnBinaryMessage(callback: (data: BinaryData) => Promise<BinaryData | void> | BinaryData | void): void;
+    binaryMessage(data: BinaryData): Promise<BinaryData | void>;
     registerOnClose(callback: () => void): void;
     close(): void;
     registerOnSend(send: (message: Out) => void): void;
     send(message: Out, isBinary?: boolean): void;
+    registerOnSendBinary(send: (data: BinaryData) => void): void;
+    sendBinary(data: BinaryData): void;
 }

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

@@ -1,9 +1,11 @@
 import { PikkuAbstractChannelHandler } from '../pikku-abstract-channel-handler.js';
 export class PikkuLocalChannelHandler extends PikkuAbstractChannelHandler {
     onMessageCallback;
+    onBinaryMessageCallback;
     openCallBack;
     closeCallback;
     sendCallback;
+    sendBinaryCallback;
     registerOnOpen(callback) {
         this.openCallBack = callback;
     }
@@ -19,6 +21,12 @@ export class PikkuLocalChannelHandler extends PikkuAbstractChannelHandler {
     async message(data) {
         return this.onMessageCallback?.(data);
     }
+    registerOnBinaryMessage(callback) {
+        this.onBinaryMessageCallback = callback;
+    }
+    async binaryMessage(data) {
+        return this.onBinaryMessageCallback?.(data);
+    }
     registerOnClose(callback) {
         this.closeCallback = callback;
     }
@@ -38,4 +46,13 @@ export class PikkuLocalChannelHandler extends PikkuAbstractChannelHandler {
         }
         return this.sendCallback?.(message, isBinary);
     }
+    registerOnSendBinary(send) {
+        this.sendBinaryCallback = send;
+    }
+    sendBinary(data) {
+        if (!this.sendBinaryCallback) {
+            throw new Error('No sendBinary callback registered');
+        }
+        this.sendBinaryCallback(data);
+    }
 }

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

@@ -99,7 +99,7 @@ export const runLocalChannel = async ({ channelId, request, response, route, ski
                 }
                 await closeServices();
             });
-            const onMessage = processMessageHandlers(services, channelConfig, channelHandler, userSession);
+            const { onMessage, onBinaryMessage } = processMessageHandlers(services, channelConfig, channelHandler, userSession);
             channelHandler.registerOnMessage(async (data) => {
                 try {
                     const result = await onMessage(data);
@@ -110,6 +110,19 @@ export const runLocalChannel = async ({ channelId, request, response, route, ski
                     channel.send({ error: e.message || 'Unknown error' });
                 }
             });
+            if (onBinaryMessage) {
+                channelHandler.registerOnBinaryMessage(async (data) => {
+                    try {
+                        const result = await onBinaryMessage(data);
+                        if (result) {
+                            await channel.sendBinary(result);
+                        }
+                    }
+                    catch (e) {
+                        singletonServices.logger.error(`Error handling binary message: ${e.message}`);
+                    }
+                });
+            }
         }
         catch (e) {
             handleHTTPError(e, http, channelId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);