@pikku/core 0.12.17 → 0.12.18

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## 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

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/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/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/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);

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

@@ -34,7 +34,7 @@ export const runChannelConnect = async ({ channelId, channelObject, request, res
     if (request instanceof Request) {
         http = createHTTPWire(new PikkuFetchHTTPRequest(request), response);
     }
-    const userSession = new PikkuSessionService(channelStore, channelId);
+    const userSession = new PikkuSessionService(singletonServices.sessionStore);
     const { channelConfig, openingData, meta } = await openChannel({
         channelId,
         request,
@@ -77,6 +77,11 @@ export const runChannelConnect = async ({ channelId, channelObject, request, res
                 channelMiddlewareMeta: meta.channelMiddleware,
             });
         }
+        // Store the pikkuUserId mapping after auth middleware has run
+        const pikkuUserId = userSession.getPikkuUserId();
+        if (pikkuUserId) {
+            await channelStore.setPikkuUserId(channelId, pikkuUserId);
+        }
         http?.response?.status(101);
     }
     catch (e) {
@@ -98,21 +103,27 @@ export const runChannelDisconnect = async ({ channelId, channelStore, channelHan
     // there's nothing to disconnect, so we can return early.
     let channelData;
     try {
-        channelData = await channelStore.getChannelAndSession(channelId);
+        channelData = await channelStore.getChannel(channelId);
     }
     catch {
         singletonServices.logger.info(`Channel ${channelId} not found during disconnect - already cleaned up`);
         return;
     }
-    const { openingData, channelName, session } = channelData;
+    const { openingData, channelName, pikkuUserId } = channelData;
     const { channel, channelConfig, meta } = getVariablesForChannel({
         channelId,
         channelHandlerFactory,
         openingData,
         channelName,
     });
-    const userSession = new PikkuSessionService(channelStore, channelId);
-    userSession.setInitial(session);
+    const userSession = new PikkuSessionService(singletonServices.sessionStore);
+    if (pikkuUserId) {
+        userSession.setPikkuUserId(pikkuUserId);
+        const session = await singletonServices.sessionStore?.get(pikkuUserId);
+        if (session) {
+            userSession.setInitial(session);
+        }
+    }
     const wire = {
         channel,
         ...createMiddlewareSessionWireProps(userSession),
@@ -149,15 +160,21 @@ export const runChannelMessage = async ({ channelId, channelStore, channelHandle
     const singletonServices = getSingletonServices();
     const createWireServices = getCreateWireServices();
     let wireServices;
-    const { openingData, channelName, session } = await channelStore.getChannelAndSession(channelId);
+    const { openingData, channelName, pikkuUserId } = await channelStore.getChannel(channelId);
     const { channel, channelHandler, channelConfig } = getVariablesForChannel({
         channelId,
         channelHandlerFactory,
         openingData,
         channelName,
     });
-    const userSession = new PikkuSessionService(channelStore, channelId);
-    userSession.setInitial(session);
+    const userSession = new PikkuSessionService(singletonServices.sessionStore);
+    if (pikkuUserId) {
+        userSession.setPikkuUserId(pikkuUserId);
+        const session = await singletonServices.sessionStore?.get(pikkuUserId);
+        if (session) {
+            userSession.setInitial(session);
+        }
+    }
     const wire = {
         channel,
         ...createMiddlewareSessionWireProps(userSession),

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

@@ -224,7 +224,7 @@ export async function runCLICommand({ program, commandPath, data, singletonServi
         },
         state: 'open',
     };
-    const userSession = new PikkuSessionService();
+    const userSession = new PikkuSessionService(singletonServices.sessionStore);
     const wire = {
         cli: {
             program,

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

@@ -201,9 +201,9 @@ export const createHTTPWire = (request, response) => {
  * @throws Throws errors like MissingSessionError or ForbiddenError on validation failures.
  */
 const executeRoute = async (services, matchedRoute, http, options) => {
-    const userSession = new PikkuSessionService();
     const { params, route, meta } = matchedRoute;
     const { singletonServices, createWireServices, skipUserSession, requestId } = services;
+    const userSession = new PikkuSessionService(singletonServices.sessionStore);
     // Attach URL parameters to the request object
     http?.request?.setParams(params);
     // Validate request headers if schema is defined

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

@@ -103,7 +103,7 @@ async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncId, { mcp: mcp
             throw new NotFoundError(`MCP '${type}' PikkuFunction Mapping not found for '${name}'`);
         }
         singletonServices.logger.debug(`Running MCP ${type}: ${name}`);
-        const mcpSessionService = new PikkuSessionService();
+        const mcpSessionService = new PikkuSessionService(singletonServices.sessionStore);
         const wire = {
             mcp: mcpWire,
             ...createMiddlewareSessionWireProps(mcpSessionService),

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

@@ -41,7 +41,7 @@ export async function runScheduledTask({ name, session, traceId, }) {
         singletonServices.logger;
     const task = pikkuState(null, 'scheduler', 'tasks').get(name);
     const meta = pikkuState(null, 'scheduler', 'meta')[name];
-    const userSession = new PikkuSessionService();
+    const userSession = new PikkuSessionService(singletonServices.sessionStore);
     if (session) {
         userSession.set(session);
     }

package/dist/wirings/workflow/pikku-workflow-service.js

@@ -425,7 +425,6 @@ export class PikkuWorkflowService {
             const wire = {
                 workflow: workflowWire,
                 pikkuUserId: run.wire?.pikkuUserId,
-                session: rpcService.wire?.session,
                 rpc: rpcService.wire?.rpc,
             };
             try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/core",
-  "version": "0.12.17",
+  "version": "0.12.18",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/index.js",

package/src/function/function-runner.ts

@@ -26,15 +26,44 @@ import type {
 } from './functions.types.js'
 import { parseVersionedId } from '../version.js'
 import type { SessionService } from '../services/user-session-service.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: PikkuWire,
+  singletonServices: CoreSingletonServices,
+  sessionService?: SessionService<CoreUserSession>
+): Promise<void> {
+  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.
@@ -256,6 +285,12 @@ export const runPikkuFunc = async <In = any, Out = any>(
 
   // 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: any) => sessionService.set(s)