@pikku/core 0.12.17 → 0.12.19

package/CHANGELOG.md

@@ -1,5 +1,25 @@
+## 0.12.19
+
+### Patch Changes
+
+- b9ed73e: Add deterministic workflow planned-step metadata support and SSE init stream payload generation.
+  - Persist `deterministic` and `plannedSteps` on workflow runs in core and service adapters.
+  - Expose planned-step metadata on workflow run status responses.
+  - Emit an initial `type: 'init'` SSE event for deterministic workflow streams before incremental updates.
+  - Add CLI tests covering serialized stream route output for init/update/done event behavior.
+
 ## 0.12.4
 
+## 0.12.18
+
+### Patch Changes
+
+- 311c0c4: Unify session persistence through SessionStore, remove session blob from ChannelStore
+  - PikkuSessionService now persists sessions via SessionStore on set()/clear() instead of every function call
+  - ChannelStore no longer stores session data — maps channelId to pikkuUserId only
+  - ChannelStore API: setUserSession/getChannelAndSession replaced with setPikkuUserId/getChannel
+  - Serverless channel runner resolves sessions from SessionStore using pikkuUserId from ChannelStore
+
 ## 0.12.17
 
 ### Patch Changes
@@ -39,14 +59,12 @@
 ### Patch Changes
 
 - 9e8605f: Add Workers for Platforms dispatch namespace support and AI agent fixes.
-
   - deploy-cloudflare: Thread dispatchNamespace through deploy pipeline, reads CF_DISPATCH_NAMESPACE env var
   - core: Fix auth-gated tools visible to unauthenticated sessions (null session now hides permission-gated items)
   - core: Recursive null stripping in AI agent tool call resume path
   - ai-vercel: Handle anyOf/oneOf/array types when making optional fields nullable for strict providers
 
 - 624097e: Add deploy pipeline with provider-agnostic architecture
-
   - Add MetaService with explicit typed API, absorb WiringService reads
   - Add deployment service, traceId propagation, scoped logger
   - Rewrite analyzer: one function = one worker, gateways dispatch via RPC
@@ -69,7 +87,6 @@
 ### Patch Changes
 
 - f85c234: Add unified credential system with per-user OAuth and AI agent pre-flight checks
-
   - Unified CredentialService with lazy loading per user via pikkuUserId
   - wire.getCredential() for typed single credential lookup
   - MissingCredentialError with structured payload for client-side connect flows
@@ -176,7 +193,6 @@
 - 7d369f3: Fix agent sub-agent tool execution failures: use UUID for sub-agent thread IDs (was exceeding varchar(36) DB column), and synthesize error results for failed tool calls in non-streaming run() to prevent "Tool result is missing" cascading errors.
 - 508a796: Fix MCP server not exposing addon tools: resolve namespaced function IDs in MCP runner, load addon schemas after schema generation, and use resolveFunctionMeta for MCP JSON serialization
 - ffe83af: Add Web Response passthrough support and fix close() flushing
-
   - HTTP runner detects when a function returns a Web `Response` object and applies it directly via `applyWebResponse()`, enabling seamless integration with libraries like Auth.js
   - Add `send()` method to `PikkuHTTPResponse` for setting body without Content-Type headers
   - Add `headers()` method to `PikkuHTTPRequest` for retrieving all headers as a record
@@ -190,7 +206,6 @@
 ### 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()
@@ -207,7 +222,6 @@
 
 - 62a8725: Rename 'external' to 'addon' throughout the codebase. All types, functions, config keys, and CLI options previously named `external` or `External` are now named `addon` or `Addon` (e.g. `ExternalPackageConfig` → `AddonConfig`, `externalPackages` → `addons`, `function-external` → `function-addon`).
 - a3bdb0d: Add AI middleware hooks for per-tool-call lifecycle and post-step observability:
-
   - `beforeToolCall` / `afterToolCall`: per-tool-call hooks for logging, caching, input sanitization, and result transformation
   - `afterStep`: post-step observation hook with full step context (text, toolCalls, toolResults, usage, finishReason)
   - `onError`: error-specific hook for alerting and diagnostics (non-throwing, won't affect error flow)
@@ -306,18 +320,15 @@
 - ea652dc: Refactor channel middleware handling and add lifecycle middleware support
 
   **Breaking Changes:**
-
   - Improved middleware resolution for channel message handlers to properly combine channel-level and message-level middleware
   - Fixed cache key collisions when multiple message handlers use the same function
 
   **New Features:**
-
   - Add `runChannelLifecycleWithMiddleware` helper in `channel-common.ts` for consistent lifecycle function execution
   - Support middleware on `onConnect` and `onDisconnect` lifecycle functions
   - Channel-level middleware now properly applies to all messages in the channel
 
   **Bug Fixes:**
-
   - Fix middleware ordering: channel middleware → message middleware → inherited middleware
   - Fix cache key generation to include routing information (prevents cache collisions)
   - Properly detect wrapper objects vs direct function configs for message handlers
@@ -325,13 +336,11 @@
 - 4349ec5: Add file-based storage implementations for serverless environments
 
   **New Services:**
-
   - Add `FileChannelStore` for file-based channel storage (suitable for AWS Lambda /tmp)
   - Add `FileEventHubStore` for file-based event hub subscriptions
   - Export new services in package.json for use in serverless runtimes
 
   **Bug Fixes:**
-
   - Fix serverless channel runner to handle disconnect gracefully when channel is already cleaned up
   - Fix MCP runner to pass `mcp` service to functions and use correct function type
 
@@ -407,7 +416,6 @@ For complete details, see https://pikku.dev/changelogs/0_10_0.md
   ### Ordered Execution System
 
   Both middleware and permissions now execute in a specific hierarchical order:
-
   1. **Wiring Tags** - Tag-based middleware/permissions from wiring level (e.g., HTTP route tags)
   2. **Wiring Middleware/Permissions** - Direct wiring-level middleware/permissions
   3. **Function Middleware** - Function-level middleware
@@ -472,7 +480,6 @@ For complete details, see https://pikku.dev/changelogs/0_10_0.md
 - 7c592b8: feat: support for required services and improved service configuration
 
   This release includes several enhancements to service management and configuration:
-
   - Added support for required services configuration
   - Improved service discovery and registration
   - Added typed RPC clients for service communication

package/dist/function/function-runner.js

@@ -4,11 +4,31 @@ import { runPermissions } from '../permissions.js';
 import { pikkuState } from '../pikku-state.js';
 import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js';
 import { parseVersionedId } from '../version.js';
-import { createFunctionSessionWireProps } from '../services/user-session-service.js';
+import { PikkuSessionService, createFunctionSessionWireProps, } from '../services/user-session-service.js';
 import { ForbiddenError, ReadonlySessionError } from '../errors/errors.js';
 import { PikkuCredentialWireService, createWireServicesCredentialWireProps, } from '../services/credential-wire-service.js';
+import { defaultPikkuUserIdResolver } from '../services/pikku-user-id.js';
 import { rpcService } from '../wirings/rpc/rpc-runner.js';
 import { closeWireServices } from '../utils.js';
+async function resolveSession(wire, singletonServices, sessionService) {
+    const pikkuUserId = defaultPikkuUserIdResolver(wire);
+    if (pikkuUserId) {
+        wire.pikkuUserId = pikkuUserId;
+        if (sessionService instanceof PikkuSessionService) {
+            sessionService.setPikkuUserId(pikkuUserId);
+        }
+    }
+    const { sessionStore } = singletonServices;
+    if (!sessionStore || !pikkuUserId)
+        return;
+    if (!wire.session) {
+        const stored = await sessionStore.get(pikkuUserId);
+        if (stored) {
+            wire.session = stored;
+            sessionService?.setInitial(stored);
+        }
+    }
+}
 /**
  * Get or create singleton services for an addon package.
  * Services are cached in pikkuState to avoid recreation on each call.
@@ -134,6 +154,7 @@ export const runPikkuFunc = async (wireType, wireId, funcName, { singletonServic
     }
     // Helper function to run permissions and execute the function
     const executeFunction = async () => {
+        await resolveSession(resolvedWire, resolvedSingletonServices, sessionService);
         if (sessionService) {
             resolvedWire.session = sessionService.freezeInitial();
             resolvedWire.setSession = (s) => sessionService.set(s);

package/dist/function/functions.types.d.ts

@@ -146,6 +146,7 @@ export type CorePikkuFunctionConfig<PikkuFunction extends CorePikkuFunction<any,
     remote?: boolean;
     mcp?: boolean;
     readonly?: boolean;
+    deploy?: 'serverless' | 'server' | 'auto';
     approvalRequired?: boolean;
     approvalDescription?: any;
     func: PikkuFunction;

package/dist/services/in-memory-session-store.d.ts

@@ -0,0 +1,8 @@
+import type { CoreUserSession } from '../types/core.types.js';
+import type { SessionStore } from './session-store.js';
+export declare class InMemorySessionStore<UserSession extends CoreUserSession = CoreUserSession> implements SessionStore<UserSession> {
+    private sessions;
+    get(pikkuUserId: string): Promise<UserSession | undefined>;
+    set(pikkuUserId: string, session: UserSession): Promise<void>;
+    clear(pikkuUserId: string): Promise<void>;
+}

package/dist/services/in-memory-session-store.js

@@ -0,0 +1,12 @@
+export class InMemorySessionStore {
+    sessions = new Map();
+    async get(pikkuUserId) {
+        return this.sessions.get(pikkuUserId);
+    }
+    async set(pikkuUserId, session) {
+        this.sessions.set(pikkuUserId, session);
+    }
+    async clear(pikkuUserId) {
+        this.sessions.delete(pikkuUserId);
+    }
+}

package/dist/services/in-memory-workflow-service.d.ts

@@ -1,6 +1,6 @@
 import { PikkuWorkflowService } from '../wirings/workflow/pikku-workflow-service.js';
 import type { SerializedError } from '../types/core.types.js';
-import type { WorkflowRun, WorkflowRunService, WorkflowRunWire, StepState, WorkflowStatus, WorkflowVersionStatus, WorkflowStepOptions } from '../wirings/workflow/workflow.types.js';
+import type { WorkflowPlannedStep, WorkflowRun, WorkflowRunService, WorkflowRunWire, StepState, WorkflowStatus, WorkflowVersionStatus, WorkflowStepOptions } from '../wirings/workflow/workflow.types.js';
 /**
  * In-memory implementation of WorkflowService for inline-only execution
  *
@@ -24,7 +24,10 @@ export declare class InMemoryWorkflowService extends PikkuWorkflowService implem
     private runState;
     private branchKeys;
     private workflowVersions;
-    createRun(workflowName: string, input: any, inline: boolean, graphHash: string, wire: WorkflowRunWire): Promise<string>;
+    createRun(workflowName: string, input: any, inline: boolean, graphHash: string, wire: WorkflowRunWire, options?: {
+        deterministic?: boolean;
+        plannedSteps?: WorkflowPlannedStep[];
+    }): Promise<string>;
     getRun(id: string): Promise<WorkflowRun | null>;
     getRunHistory(runId: string): Promise<Array<StepState & {
         stepName: string;

package/dist/services/in-memory-workflow-service.js

@@ -23,7 +23,7 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
     runState = new Map(); // keyed by runId
     branchKeys = new Map(); // keyed by stepId
     workflowVersions = new Map(); // keyed by `${name}:${graphHash}`
-    async createRun(workflowName, input, inline, graphHash, wire) {
+    async createRun(workflowName, input, inline, graphHash, wire, options) {
         const runId = randomUUID();
         const now = new Date();
         const run = {
@@ -33,6 +33,8 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
             input,
             inline,
             graphHash,
+            deterministic: options?.deterministic,
+            plannedSteps: options?.plannedSteps,
             wire,
             createdAt: now,
             updatedAt: now,

package/dist/services/index.d.ts

@@ -36,4 +36,6 @@ export { TypedCredentialService } from './typed-credential-service.js';
 export type { CredentialStatusInfo, CredentialMetaInfo, } from './typed-credential-service.js';
 export type { VariableStatus, VariableMeta } from './typed-variables-service.js';
 export type { MetaService } from './meta-service.js';
+export type { SessionStore } from './session-store.js';
+export { InMemorySessionStore } from './in-memory-session-store.js';
 export type { MCPMeta, RPCMetaRecord, ServiceMeta, ServicesMetaRecord, MiddlewareDefinitionMeta, MiddlewareInstanceMeta, GroupMeta, MiddlewareGroupsMeta, PermissionDefinitionMeta, PermissionsGroupsMeta, FunctionsMeta, FunctionMeta, MiddlewareMeta, PermissionMeta, AgentsMeta, AgentMeta, } from './meta-service.js';

package/dist/services/index.js

@@ -17,3 +17,4 @@ 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 { TypedCredentialService } from './typed-credential-service.js';
+export { InMemorySessionStore } from './in-memory-session-store.js';

package/dist/services/session-store.d.ts

@@ -0,0 +1,6 @@
+import type { CoreUserSession } from '../types/core.types.js';
+export interface SessionStore<UserSession extends CoreUserSession = CoreUserSession> {
+    get(pikkuUserId: string): Promise<UserSession | undefined>;
+    set(pikkuUserId: string, session: UserSession): Promise<void>;
+    clear(pikkuUserId: string): Promise<void>;
+}

package/dist/services/session-store.js

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

package/dist/services/user-session-service.d.ts

@@ -1,5 +1,5 @@
-import type { ChannelStore } from '../wirings/channel/channel-store.js';
 import type { CoreUserSession } from '../types/core.types.js';
+import type { SessionStore } from './session-store.js';
 export interface SessionService<UserSession extends CoreUserSession> {
     sessionChanged: boolean;
     initial: UserSession | undefined;
@@ -7,31 +7,33 @@ export interface SessionService<UserSession extends CoreUserSession> {
     freezeInitial(): UserSession | undefined;
     set(session: UserSession): Promise<void> | void;
     clear(): Promise<void> | void;
-    get(): Promise<UserSession> | UserSession | undefined;
+    get(): UserSession | undefined;
 }
 export declare class PikkuSessionService<UserSession extends CoreUserSession> implements SessionService<UserSession> {
-    private channelStore?;
-    private channelId?;
+    private sessionStore?;
     sessionChanged: boolean;
     initial: UserSession | undefined;
     private session;
-    constructor(channelStore?: ChannelStore<unknown, unknown, UserSession> | undefined, channelId?: string | undefined);
+    private pikkuUserId?;
+    constructor(sessionStore?: SessionStore<UserSession> | undefined);
+    setPikkuUserId(id: string): void;
+    getPikkuUserId(): string | undefined;
     setInitial(session: UserSession): void;
     freezeInitial(): UserSession | undefined;
-    set(session: UserSession): void | Promise<void> | undefined;
-    clear(): void | Promise<void> | undefined;
-    get(): Promise<UserSession> | UserSession | undefined;
+    set(session: UserSession): Promise<void>;
+    clear(): Promise<void>;
+    get(): UserSession | undefined;
 }
 export declare function createMiddlewareSessionWireProps<UserSession extends CoreUserSession>(session: SessionService<UserSession>): {
     session: UserSession | undefined;
     setSession: (s: UserSession) => void;
-    getSession: () => UserSession | Promise<UserSession> | undefined;
+    getSession: () => UserSession | undefined;
     hasSessionChanged: () => boolean;
 };
 export declare function createFunctionSessionWireProps<UserSession extends CoreUserSession>(session: SessionService<UserSession>): {
     session: UserSession | undefined;
     setSession: (s: UserSession) => void | Promise<void>;
     clearSession: () => void | Promise<void>;
-    getSession: () => UserSession | Promise<UserSession> | undefined;
+    getSession: () => UserSession | undefined;
     hasSessionChanged: () => boolean;
 };

package/dist/services/user-session-service.js

@@ -1,15 +1,17 @@
 export class PikkuSessionService {
-    channelStore;
-    channelId;
+    sessionStore;
     sessionChanged = false;
     initial;
     session;
-    constructor(channelStore, channelId) {
-        this.channelStore = channelStore;
-        this.channelId = channelId;
-        if (channelStore && !channelId) {
-            throw new Error('Channel ID is required when using channel store');
-        }
+    pikkuUserId;
+    constructor(sessionStore) {
+        this.sessionStore = sessionStore;
+    }
+    setPikkuUserId(id) {
+        this.pikkuUserId = id;
+    }
+    getPikkuUserId() {
+        return this.pikkuUserId;
     }
     setInitial(session) {
         this.session = session;
@@ -20,26 +22,21 @@ export class PikkuSessionService {
         }
         return this.initial;
     }
-    set(session) {
+    async set(session) {
         this.sessionChanged = true;
         this.session = session;
-        return this.channelStore?.setUserSession(this.channelId, session);
+        if (this.sessionStore && this.pikkuUserId) {
+            await this.sessionStore.set(this.pikkuUserId, session);
+        }
     }
-    clear() {
+    async clear() {
         this.sessionChanged = true;
         this.session = undefined;
-        return this.channelStore?.setUserSession(this.channelId, null);
+        if (this.sessionStore && this.pikkuUserId) {
+            await this.sessionStore.clear(this.pikkuUserId);
+        }
     }
     get() {
-        if (this.channelStore) {
-            const channel = this.channelStore.getChannelAndSession(this.channelId);
-            if (channel instanceof Promise) {
-                return channel.then(({ session }) => session);
-            }
-            else {
-                return channel.session;
-            }
-        }
         return this.session;
     }
 }

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

@@ -1,11 +1,14 @@
 import type { SerializedError } from '../types/core.types.js';
-import type { WorkflowRun, WorkflowRunWire, WorkflowRunStatus, StepState, WorkflowStatus, WorkflowVersionStatus } from '../wirings/workflow/workflow.types.js';
+import type { WorkflowRun, WorkflowPlannedStep, WorkflowRunWire, WorkflowRunStatus, StepState, WorkflowStatus, WorkflowVersionStatus } from '../wirings/workflow/workflow.types.js';
 /**
  * Interface for workflow orchestration
  * Handles workflow execution, replay, orchestration logic, and run-level state
  */
 export interface WorkflowService {
-    createRun(workflowName: string, input: any, inline: boolean, graphHash: string, wire: WorkflowRunWire): Promise<string>;
+    createRun(workflowName: string, input: any, inline: boolean, graphHash: string, wire: WorkflowRunWire, options?: {
+        deterministic?: boolean;
+        plannedSteps?: WorkflowPlannedStep[];
+    }): Promise<string>;
     getRun(id: string): Promise<WorkflowRun | null>;
     getRunStatus(id: string): Promise<WorkflowRunStatus | null>;
     getRunHistory(runId: string): Promise<Array<StepState & {

package/dist/testing/service-tests.d.ts

@@ -8,6 +8,7 @@ import type { AIRunStateService } from '../services/ai-run-state-service.js';
 import type { SecretService } from '../services/secret-service.js';
 import type { CredentialService } from '../services/credential-service.js';
 import type { AgentRunService } from '../wirings/ai-agent/ai-agent.types.js';
+import type { SessionStore } from '../services/session-store.js';
 export interface ServiceTestConfig {
     name: string;
     services: {
@@ -34,6 +35,7 @@ export interface ServiceTestConfig {
         }) => Promise<CredentialService & {
             rotateKEK?(): Promise<number>;
         }>;
+        sessionStore?: () => Promise<SessionStore>;
     };
 }
 export declare function defineServiceTests(config: ServiceTestConfig): void;

package/dist/testing/service-tests.js

@@ -9,27 +9,31 @@ export function defineServiceTests(config) {
             before(async () => {
                 store = await factory();
             });
-            test('addChannel and getChannelAndSession', async () => {
+            test('addChannel and getChannel', async () => {
                 await store.addChannel({
                     channelId: 'ch-1',
                     channelName: 'test-channel',
                     openingData: { foo: 'bar' },
                 });
-                const result = await store.getChannelAndSession('ch-1');
+                const result = await store.getChannel('ch-1');
                 assert.equal(result.channelId, 'ch-1');
                 assert.equal(result.channelName, 'test-channel');
                 assert.deepEqual(result.openingData, { foo: 'bar' });
-                assert.deepEqual(result.session, {});
+                assert.equal(result.pikkuUserId, undefined);
             });
-            test('setUserSession', async () => {
-                const session = { userId: 'user-1' };
-                await store.setUserSession('ch-1', session);
-                const result = await store.getChannelAndSession('ch-1');
-                assert.deepEqual(result.session, session);
+            test('setPikkuUserId', async () => {
+                await store.setPikkuUserId('ch-1', 'user-1');
+                const result = await store.getChannel('ch-1');
+                assert.equal(result.pikkuUserId, 'user-1');
             });
-            test('getChannelAndSession throws for missing channel', async () => {
+            test('setPikkuUserId to null', async () => {
+                await store.setPikkuUserId('ch-1', null);
+                const result = await store.getChannel('ch-1');
+                assert.equal(result.pikkuUserId, undefined);
+            });
+            test('getChannel throws for missing channel', async () => {
                 await assert.rejects(async () => {
-                    await store.getChannelAndSession('missing');
+                    await store.getChannel('missing');
                 }, { message: 'Channel not found: missing' });
             });
             test('removeChannels', async () => {
@@ -39,7 +43,7 @@ export function defineServiceTests(config) {
                 });
                 await store.removeChannels(['ch-2']);
                 await assert.rejects(async () => {
-                    await store.getChannelAndSession('ch-2');
+                    await store.getChannel('ch-2');
                 });
             });
             test('removeChannels with empty array is no-op', async () => {
@@ -693,4 +697,39 @@ export function defineServiceTests(config) {
             });
         });
     }
+    if (services.sessionStore) {
+        const factory = services.sessionStore;
+        describe(`SessionStore [${name}]`, () => {
+            let store;
+            before(async () => {
+                store = await factory();
+            });
+            test('get returns undefined for unknown user', async () => {
+                const result = await store.get('unknown-user');
+                assert.equal(result, undefined);
+            });
+            test('set and get round-trip', async () => {
+                const session = { userId: 'user-1', organizationId: 'org-1' };
+                await store.set('user-1', session);
+                const result = await store.get('user-1');
+                assert.deepEqual(result, session);
+            });
+            test('set overwrites previous session', async () => {
+                await store.set('user-2', { userId: 'user-2', role: 'admin' });
+                await store.set('user-2', { userId: 'user-2', role: 'member' });
+                const result = await store.get('user-2');
+                assert.deepEqual(result, { userId: 'user-2', role: 'member' });
+            });
+            test('clear removes session', async () => {
+                await store.set('user-3', { userId: 'user-3' });
+                assert.ok(await store.get('user-3'));
+                await store.clear('user-3');
+                const result = await store.get('user-3');
+                assert.equal(result, undefined);
+            });
+            test('clear is no-op for unknown user', async () => {
+                await store.clear('nonexistent');
+            });
+        });
+    }
 }

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

@@ -25,6 +25,7 @@ import type { PikkuAIMiddlewareHooks } from '../wirings/ai-agent/ai-agent.types.
 import type { WorkflowRunService } from '../wirings/workflow/workflow.types.js';
 import type { CredentialService } from '../services/credential-service.js';
 import type { MetaService } from '../services/meta-service.js';
+import type { SessionStore } from '../services/session-store.js';
 export type PikkuWiringTypes = 'http' | 'scheduler' | 'trigger' | 'channel' | 'rpc' | 'queue' | 'mcp' | 'cli' | 'workflow' | 'agent' | 'gateway';
 export interface FunctionServicesMeta {
     optimized: boolean;
@@ -181,6 +182,8 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
     credentialService?: CredentialService;
     /** Meta service for reading .pikku metadata files (filesystem on Node, R2/KV on CF) */
     metaService?: MetaService;
+    /** Session store for persisting user sessions keyed by pikkuUserId */
+    sessionStore?: SessionStore;
 }
 /**
  * Represents different forms of wire within Pikku and the outside world.

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

@@ -1,17 +1,16 @@
-import type { CoreUserSession } from '../../types/core.types.js';
 export type Channel<ChannelType = unknown, OpeningData = unknown> = {
     channelId: string;
     channelName: string;
     channelObject?: ChannelType;
     openingData?: OpeningData;
 };
-export declare abstract class ChannelStore<ChannelType = unknown, OpeningData = unknown, UserSession extends CoreUserSession = CoreUserSession, TypedChannel = Channel<ChannelType, OpeningData>> {
+export declare abstract class ChannelStore<ChannelType = unknown, OpeningData = unknown, TypedChannel = Channel<ChannelType, OpeningData>> {
     abstract addChannel(channel: Channel<ChannelType, OpeningData>): Promise<void> | void;
     abstract removeChannels(channelId: string[]): Promise<void> | void;
-    abstract setUserSession(channelId: string, userSession: UserSession | null): Promise<void> | void;
-    abstract getChannelAndSession(channelId: string): Promise<TypedChannel & {
-        session: UserSession;
+    abstract setPikkuUserId(channelId: string, pikkuUserId: string | null): Promise<void> | void;
+    abstract getChannel(channelId: string): Promise<TypedChannel & {
+        pikkuUserId?: string;
     }> | (TypedChannel & {
-        session: UserSession;
+        pikkuUserId?: string;
     });
 }

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

@@ -15,7 +15,7 @@ export const runLocalChannel = async ({ channelId, request, response, route, ski
     let wireServices;
     let closedWireServices = false;
     let channelHandler;
-    const userSession = new PikkuSessionService();
+    const userSession = new PikkuSessionService(singletonServices.sessionStore);
     let http;
     if (request) {
         http = createHTTPWire(request, response);
@@ -79,7 +79,8 @@ export const runLocalChannel = async ({ channelId, request, response, route, ski
                         singletonServices.logger.error(`Error handling onConnect: ${e}`);
                         const errorResponse = getErrorResponse(e);
                         channel.send({
-                            error: errorResponse?.message ?? (isProduction() ? 'Internal server error' : e.message),
+                            error: errorResponse?.message ??
+                                (isProduction() ? 'Internal server error' : e.message),
                             ...(!isProduction() && { errorName: e.constructor?.name }),
                         });
                     }
@@ -102,7 +103,8 @@ export const runLocalChannel = async ({ channelId, request, response, route, ski
                         singletonServices.logger.error(`Error handling onDisconnect: ${e}`);
                         const errorResponse = getErrorResponse(e);
                         channel.send({
-                            error: errorResponse?.message ?? (isProduction() ? 'Internal server error' : e.message),
+                            error: errorResponse?.message ??
+                                (isProduction() ? 'Internal server error' : e.message),
                             ...(!isProduction() && { errorName: e.constructor?.name }),
                         });
                     }
@@ -119,7 +121,8 @@ export const runLocalChannel = async ({ channelId, request, response, route, ski
                     singletonServices.logger.error(e);
                     const errorResponse = getErrorResponse(e);
                     channel.send({
-                        error: errorResponse?.message ?? (isProduction() ? 'Internal server error' : e.message),
+                        error: errorResponse?.message ??
+                            (isProduction() ? 'Internal server error' : e.message),
                         ...(!isProduction() && { errorName: e.constructor?.name }),
                     });
                     setTimeout(() => channel.close(), 200);