@pikku/core 0.12.27 → 0.12.28

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.12.28
+
+### Patch Changes
+
+- 2cf67be: Add inline option to pikkuFunc/pikkuSessionlessFunc for workflow step dispatch
+
+  By default, workflow steps now run inline (no queue hop). Set inline: false on a function to force dispatch through the queue for that step.
+
 ## 0.12.27
 
 ### Patch Changes

package/dist/function/function-runner.d.ts

@@ -1,4 +1,4 @@
-import type { CoreServices, CoreUserSession, CorePikkuMiddleware, PikkuWiringTypes, PikkuWire, MiddlewareMetadata, PermissionMetadata, CoreSingletonServices, CreateWireServices } from '../types/core.types.js';
+import type { CoreUserSession, CorePikkuMiddleware, PikkuWiringTypes, PikkuWire, MiddlewareMetadata, PermissionMetadata, CoreSingletonServices, CreateWireServices } from '../types/core.types.js';
 import type { CorePikkuChannelMiddleware } from '../wirings/channel/channel.types.js';
 import type { CorePermissionGroup, CorePikkuFunctionConfig, CorePikkuPermission } from './functions.types.js';
 import type { SessionService } from '../services/user-session-service.js';
@@ -6,7 +6,6 @@ import { PikkuCredentialWireService } from '../services/credential-wire-service.
 export declare const addFunction: (funcName: string, funcConfig: CorePikkuFunctionConfig<any, any>, packageName?: string | null) => void;
 export declare const getFunctionNames: (packageName?: string | null) => string[];
 export declare const getAllFunctionNames: () => string[];
-export declare const runPikkuFuncDirectly: <In, Out>(funcName: string, allServices: CoreServices, wire: PikkuWire, data: In, userSession?: SessionService<CoreUserSession>, packageName?: string | null) => Promise<Out>;
 export declare const runPikkuFunc: <In = any, Out = any>(wireType: PikkuWiringTypes, wireId: string, funcName: string, { singletonServices, createWireServices, data, auth: wiringAuth, inheritedMiddleware, wireMiddleware, inheritedChannelMiddleware, wireChannelMiddleware, inheritedPermissions, wirePermissions, coerceDataFromSchema, tags, wire, sessionService, credentialWireService, packageName, }: {
     singletonServices: CoreSingletonServices;
     createWireServices?: CreateWireServices;

package/dist/function/function-runner.js

@@ -4,7 +4,7 @@ import { runPermissions } from '../permissions.js';
 import { pikkuState } from '../pikku-state.js';
 import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js';
 import { parseVersionedId } from '../version.js';
-import { PikkuSessionService, createFunctionSessionWireProps, } from '../services/user-session-service.js';
+import { PikkuSessionService } 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';
@@ -132,17 +132,6 @@ export const getAllFunctionNames = () => {
     }
     return functions;
 };
-export const runPikkuFuncDirectly = async (funcName, allServices, wire, data, userSession, packageName = null) => {
-    const funcConfig = pikkuState(packageName, 'function', 'functions').get(funcName);
-    if (!funcConfig) {
-        throw new Error(`Function not found: ${funcName}`);
-    }
-    const wireWithSession = {
-        ...wire,
-        ...(userSession && createFunctionSessionWireProps(userSession)),
-    };
-    return (await funcConfig.func(allServices, data, wireWithSession));
-};
 export const runPikkuFunc = async (wireType, wireId, funcName, { singletonServices, createWireServices, data, auth: wiringAuth, inheritedMiddleware, wireMiddleware, inheritedChannelMiddleware, wireChannelMiddleware, inheritedPermissions, wirePermissions, coerceDataFromSchema, tags = [], wire, sessionService, credentialWireService, packageName = null, }) => {
     wire.wireType ??= wireType;
     wire.wireId ??= wireId;
@@ -230,7 +219,7 @@ export const runPikkuFunc = async (wireType, wireId, funcName, { singletonServic
                 }
             }
         }
-        else if (funcMeta.sessionless === false) {
+        else {
             if (wiringAuth === false || funcConfig.auth === false) {
                 resolvedSingletonServices.logger.warn(`Function '${funcName}' requires a session but auth was explicitly disabled — use pikkuSessionlessFunc instead.`);
             }
@@ -238,15 +227,6 @@ export const runPikkuFunc = async (wireType, wireId, funcName, { singletonServic
                 throw new ForbiddenError('Authentication required');
             }
         }
-        else {
-            // TODO: Remove after a couple of releases — backward compat for
-            // generated metadata that doesn't include the `sessionless` field yet.
-            if (wiringAuth === true || funcConfig.auth === true) {
-                if (!session) {
-                    throw new ForbiddenError('Authentication required');
-                }
-            }
-        }
         if (session?.readonly && !funcMeta.readonly) {
             throw new ReadonlySessionError();
         }

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

@@ -149,6 +149,8 @@ export type CorePikkuFunctionConfig<PikkuFunction extends CorePikkuFunction<any,
     readonly?: boolean;
     deploy?: 'serverless' | 'server' | 'auto';
     approvalRequired?: boolean;
+    /** When false, workflow steps calling this function are dispatched via the queue instead of running inline. Defaults to true (inline). */
+    inline?: boolean;
     audit?: boolean | {
         durability?: 'best-effort' | 'transactional';
     };

package/dist/services/meta-service.js

@@ -285,15 +285,26 @@ export class LocalMetaService {
         if (!emailsMeta.src) {
             throw new Error('No generated email metadata found. Run `pikku emails generate`.');
         }
+        // emailsMeta.src is an absolute path resolved by the CLI at generation time.
+        // Read directly rather than through readProjectFile (which prepends the project
+        // root and produces a wrong compound path when baseDir is absolute).
         const baseDir = emailsMeta.src;
+        const readEmailFile = async (rel) => {
+            try {
+                return await readFile(join(baseDir, rel), 'utf-8');
+            }
+            catch {
+                return null;
+            }
+        };
         const [themeRaw, localeRaw, layoutRaw, footerRaw, templateHtml, templateSubject, templateText,] = await Promise.all([
-            this.readProjectFile(`${baseDir}/theme.json`),
-            this.readProjectFile(`${baseDir}/locales/${locale}.json`),
-            this.readProjectFile(`${baseDir}/partials/layout.html`),
-            this.readProjectFile(`${baseDir}/partials/footer.html`),
-            this.readProjectFile(`${baseDir}/templates/${templateName}.html`),
-            this.readProjectFile(`${baseDir}/templates/${templateName}.subject.txt`),
-            this.readProjectFile(`${baseDir}/templates/${templateName}.text.txt`),
+            readEmailFile('theme.json'),
+            readEmailFile(`locales/${locale}.json`),
+            readEmailFile('partials/layout.html'),
+            readEmailFile('partials/footer.html'),
+            readEmailFile(`templates/${templateName}.html`),
+            readEmailFile(`templates/${templateName}.subject.txt`),
+            readEmailFile(`templates/${templateName}.text.txt`),
         ]);
         return {
             theme: themeRaw ? JSON.parse(themeRaw) : {},

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

@@ -82,6 +82,8 @@ export type FunctionRuntimeMeta = {
     readonly?: boolean;
     deploy?: 'serverless' | 'server' | 'auto';
     sessionless?: boolean;
+    /** When false, workflow steps calling this function are dispatched via the queue. Defaults to true (inline). */
+    inline?: boolean;
     version?: number;
     approvalRequired?: boolean;
     approvalDescription?: string;

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

@@ -1,5 +1,5 @@
 import { combineMiddleware, runMiddleware } from '../../middleware-runner.js';
-import { runPikkuFuncDirectly } from '../../function/function-runner.js';
+import { runPikkuFunc } from '../../function/function-runner.js';
 import { combineChannelMiddleware, wrapChannelWithMiddleware, } from './channel-middleware-runner.js';
 /**
  * Runs a channel lifecycle function (onConnect or onDisconnect) with proper middleware handling.
@@ -37,7 +37,14 @@ export const runChannelLifecycleWithMiddleware = async ({ channelConfig, meta, l
         wire = wrapChannelWithMiddleware(wire, services, allChannelMiddleware);
     }
     const runLifecycle = async () => {
-        return await runPikkuFuncDirectly(meta.pikkuFuncId, services, wire, data);
+        return await runPikkuFunc('channel', channelConfig.name, meta.pikkuFuncId, {
+            singletonServices: services,
+            data: () => data,
+            wire,
+            tags: meta.tags ?? [],
+            inheritedPermissions: meta.permissions,
+            packageName: meta.packageName ?? null,
+        });
     };
     if (allMiddleware.length > 0) {
         return await runMiddleware(services, wire, allMiddleware, runLifecycle);

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

@@ -1,3 +1,4 @@
+import type { Logger } from '../../../services/logger.js';
 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> {
@@ -7,14 +8,16 @@ export declare class PikkuLocalChannelHandler<OpeningData = unknown, Out = unkno
     private closeCallbacks;
     private sendCallback?;
     private sendBinaryCallback?;
-    registerOnOpen(callback: () => void): void;
-    open(): void;
+    private logger?;
+    constructor(channelId: string, channelName: string, openingData: OpeningData, logger?: Logger);
+    registerOnOpen(callback: () => Promise<void> | void): void;
+    open(): Promise<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;
+    registerOnClose(callback: () => Promise<void> | void): void;
+    close(): Promise<void>;
     registerOnSend(send: (message: Out) => void): void;
     send(message: Out, isBinary?: boolean): void;
     registerOnSendBinary(send: (data: BinaryData) => void): void;

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

@@ -6,13 +6,18 @@ export class PikkuLocalChannelHandler extends PikkuAbstractChannelHandler {
     closeCallbacks = [];
     sendCallback;
     sendBinaryCallback;
+    logger;
+    constructor(channelId, channelName, openingData, logger) {
+        super(channelId, channelName, openingData);
+        this.logger = logger;
+    }
     registerOnOpen(callback) {
         this.openCallBack = callback;
     }
-    open() {
+    async open() {
         this.getChannel().state = 'open';
         if (this.openCallBack) {
-            this.openCallBack();
+            await this.openCallBack();
         }
     }
     registerOnMessage(callback) {
@@ -30,13 +35,16 @@ export class PikkuLocalChannelHandler extends PikkuAbstractChannelHandler {
     registerOnClose(callback) {
         this.closeCallbacks.push(callback);
     }
-    close() {
+    async close() {
         if (this.getChannel().state === 'closed') {
             return;
         }
         super.close();
-        for (const cb of this.closeCallbacks) {
-            cb();
+        const results = await Promise.allSettled(this.closeCallbacks.map((cb) => cb()));
+        for (const result of results) {
+            if (result.status === 'rejected') {
+                this.logger?.error('Error in channel close callback:', result.reason);
+            }
         }
     }
     registerOnSend(send) {

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

@@ -59,7 +59,7 @@ export const runLocalChannel = async ({ channelId, request, response, route, ski
     }
     const main = async () => {
         try {
-            channelHandler = new PikkuLocalChannelHandler(channelId, channelConfig.name, openingData);
+            channelHandler = new PikkuLocalChannelHandler(channelId, channelConfig.name, openingData, singletonServices.logger);
             const channel = channelHandler.getChannel();
             const wire = {
                 channel,

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

@@ -484,7 +484,16 @@ export class PikkuWorkflowService {
      *   through to the inline execution path.
      */
     async dispatchStep(runId, stepName, rpcName, data, stepOptions) {
-        if (this.isInline(runId) || !getSingletonServices()?.queueService) {
+        if (!getSingletonServices()?.queueService) {
+            return false;
+        }
+        // Functions default to inline execution. Only dispatch via queue when the
+        // function explicitly sets inline: false.
+        const functionsMeta = pikkuState(null, 'function', 'meta');
+        const rpcFuncId = pikkuState(null, 'rpc', 'meta')[rpcName];
+        const rpcMeta = typeof rpcFuncId === 'string' ? functionsMeta[rpcFuncId] : undefined;
+        const forceQueue = rpcMeta?.inline === false;
+        if (!forceQueue && this.isInline(runId)) {
             return false;
         }
         const retries = stepOptions?.retries ?? 0;

package/package.json

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

package/src/dev/hot-reload.test.ts

@@ -308,6 +308,7 @@ describe('pikkuDevReloader', { concurrency: false }, () => {
       pikkuFuncId: 'hotTask',
       inputSchemaName: null,
       outputSchemaName: null,
+      sessionless: true,
     }
 
     addFunction('hotTask', {
@@ -375,6 +376,7 @@ describe('pikkuDevReloader', { concurrency: false }, () => {
       pikkuFuncId: 'queue_hot-queue',
       inputSchemaName: null,
       outputSchemaName: null,
+      sessionless: true,
     }
 
     addFunction('queue_hot-queue', {

package/src/function/function-runner.test.ts

@@ -5,7 +5,6 @@ import {
   getAllFunctionNames,
   getFunctionNames,
   runPikkuFunc,
-  runPikkuFuncDirectly,
 } from './function-runner.js'
 import { addTagMiddleware, addTagPermission } from '../index.js'
 import { resetPikkuState, pikkuState } from '../pikku-state.js'
@@ -33,6 +32,7 @@ const addTestFunction = (funcName: string, funcConfig: any) => {
     pikkuFuncId: funcName,
     inputSchemaName: null,
     outputSchemaName: null,
+    sessionless: true,
     middleware,
     permissions,
   }
@@ -676,7 +676,7 @@ describe('runPikkuFunc - Integration Tests', () => {
     )
   })
 
-  test('should use backward-compatible auth checks when sessionless metadata is absent', async () => {
+  test('should require auth when sessionless metadata is absent (undefined defaults to session-required)', async () => {
     addTestFunction('legacyAuth', {
       func: async () => 'ok',
       auth: true,
@@ -1227,32 +1227,6 @@ describe('runPikkuFunc - Integration Tests', () => {
 })
 
 describe('function-runner helpers', () => {
-  test('runPikkuFuncDirectly should pass through the provided wire and session helpers', async () => {
-    let receivedWire: any
-    const sessionService = new PikkuSessionService({
-      get: async () => undefined,
-    } as any)
-
-    addTestFunction('directFunc', {
-      func: async (_services: any, _data: any, wire: any) => {
-        receivedWire = wire
-        return 'ok'
-      },
-    })
-
-    const result = await runPikkuFuncDirectly(
-      'directFunc',
-      mockServices,
-      { traceId: 'trace-1' },
-      { hello: 'world' },
-      sessionService
-    )
-
-    assert.equal(result, 'ok')
-    assert.equal(receivedWire.traceId, 'trace-1')
-    assert.equal(typeof receivedWire.getSession, 'function')
-  })
-
   test('getFunctionNames and getAllFunctionNames should include addon namespaces', () => {
     addTestFunction('rootFunc', { func: async () => 'ok' })
     pikkuState(null, 'addons', 'packages').set('stripe', {

package/src/function/function-runner.ts

@@ -7,7 +7,6 @@ import { runPermissions } from '../permissions.js'
 import { pikkuState } from '../pikku-state.js'
 import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js'
 import type {
-  CoreServices,
   CoreUserSession,
   CorePikkuMiddleware,
   PikkuWiringTypes,
@@ -26,10 +25,7 @@ import type {
 } from './functions.types.js'
 import { parseVersionedId } from '../version.js'
 import type { SessionService } from '../services/user-session-service.js'
-import {
-  PikkuSessionService,
-  createFunctionSessionWireProps,
-} from '../services/user-session-service.js'
+import { PikkuSessionService } from '../services/user-session-service.js'
 import { ForbiddenError, ReadonlySessionError } from '../errors/errors.js'
 import {
   PikkuCredentialWireService,
@@ -200,27 +196,6 @@ export const getAllFunctionNames = (): string[] => {
   return functions
 }
 
-export const runPikkuFuncDirectly = async <In, Out>(
-  funcName: string,
-  allServices: CoreServices,
-  wire: PikkuWire,
-  data: In,
-  userSession?: SessionService<CoreUserSession>,
-  packageName: string | null = null
-) => {
-  const funcConfig = pikkuState(packageName, 'function', 'functions').get(
-    funcName
-  )
-  if (!funcConfig) {
-    throw new Error(`Function not found: ${funcName}`)
-  }
-  const wireWithSession = {
-    ...wire,
-    ...(userSession && createFunctionSessionWireProps(userSession)),
-  }
-  return (await funcConfig.func(allServices, data, wireWithSession)) as Out
-}
-
 export const runPikkuFunc = async <In = any, Out = any>(
   wireType: PikkuWiringTypes,
   wireId: string,
@@ -381,7 +356,7 @@ export const runPikkuFunc = async <In = any, Out = any>(
           throw new ForbiddenError('Authentication required')
         }
       }
-    } else if (funcMeta.sessionless === false) {
+    } else {
       if (wiringAuth === false || funcConfig.auth === false) {
         resolvedSingletonServices.logger.warn(
           `Function '${funcName}' requires a session but auth was explicitly disabled — use pikkuSessionlessFunc instead.`
@@ -390,14 +365,6 @@ export const runPikkuFunc = async <In = any, Out = any>(
       if (!session) {
         throw new ForbiddenError('Authentication required')
       }
-    } else {
-      // TODO: Remove after a couple of releases — backward compat for
-      // generated metadata that doesn't include the `sessionless` field yet.
-      if (wiringAuth === true || funcConfig.auth === true) {
-        if (!session) {
-          throw new ForbiddenError('Authentication required')
-        }
-      }
     }
 
     if ((session as any)?.readonly && !funcMeta.readonly) {

package/src/function/functions.types.ts

@@ -295,6 +295,8 @@ export type CorePikkuFunctionConfig<
   readonly?: boolean
   deploy?: 'serverless' | 'server' | 'auto'
   approvalRequired?: boolean
+  /** When false, workflow steps calling this function are dispatched via the queue instead of running inline. Defaults to true (inline). */
+  inline?: boolean
   audit?:
     | boolean
     | {

package/src/services/meta-service.ts

@@ -533,7 +533,17 @@ export class LocalMetaService implements MetaService {
       )
     }
 
+    // emailsMeta.src is an absolute path resolved by the CLI at generation time.
+    // Read directly rather than through readProjectFile (which prepends the project
+    // root and produces a wrong compound path when baseDir is absolute).
     const baseDir = emailsMeta.src
+    const readEmailFile = async (rel: string): Promise<string | null> => {
+      try {
+        return await readFile(join(baseDir, rel), 'utf-8')
+      } catch {
+        return null
+      }
+    }
     const [
       themeRaw,
       localeRaw,
@@ -543,13 +553,13 @@ export class LocalMetaService implements MetaService {
       templateSubject,
       templateText,
     ] = await Promise.all([
-      this.readProjectFile(`${baseDir}/theme.json`),
-      this.readProjectFile(`${baseDir}/locales/${locale}.json`),
-      this.readProjectFile(`${baseDir}/partials/layout.html`),
-      this.readProjectFile(`${baseDir}/partials/footer.html`),
-      this.readProjectFile(`${baseDir}/templates/${templateName}.html`),
-      this.readProjectFile(`${baseDir}/templates/${templateName}.subject.txt`),
-      this.readProjectFile(`${baseDir}/templates/${templateName}.text.txt`),
+      readEmailFile('theme.json'),
+      readEmailFile(`locales/${locale}.json`),
+      readEmailFile('partials/layout.html'),
+      readEmailFile('partials/footer.html'),
+      readEmailFile(`templates/${templateName}.html`),
+      readEmailFile(`templates/${templateName}.subject.txt`),
+      readEmailFile(`templates/${templateName}.text.txt`),
     ])
 
     return {

package/src/types/core.types.ts

@@ -118,6 +118,8 @@ export type FunctionRuntimeMeta = {
   readonly?: boolean
   deploy?: 'serverless' | 'server' | 'auto'
   sessionless?: boolean
+  /** When false, workflow steps calling this function are dispatched via the queue. Defaults to true (inline). */
+  inline?: boolean
   version?: number
   approvalRequired?: boolean
   approvalDescription?: string

package/src/wirings/ai-agent/ai-agent-prepare.test.ts

@@ -178,6 +178,7 @@ describe('ai-agent-prepare', () => {
       description: 'Deploy the service',
       approvalRequired: true,
       inputSchemaName: 'DeployInput',
+      sessionless: true,
     }
     pikkuState(null, 'misc', 'schemas').set('DeployInput', {
       type: 'object',
@@ -254,6 +255,7 @@ describe('ai-agent-prepare', () => {
       description: 'Secret tool',
       permissions: ['admin'],
       inputSchemaName: 'SecretInput',
+      sessionless: true,
     }
     pikkuState(null, 'misc', 'schemas').set('SecretInput', {
       type: 'object',

package/src/wirings/ai-agent/ai-agent-runner.test.ts

@@ -560,6 +560,7 @@ describe('runAIAgent', () => {
       description: 'Deploy',
       approvalRequired: true,
       inputSchemaName: 'DeployInput',
+      sessionless: true,
     }
     pikkuState(null, 'misc', 'schemas').set('DeployInput', {
       type: 'object',
@@ -716,6 +717,7 @@ describe('resumeAIAgentSync', () => {
     pikkuState(null, 'function', 'meta').deploy = {
       description: 'Deploy',
       inputSchemaName: 'DeployInput',
+      sessionless: true,
     }
     pikkuState(null, 'misc', 'schemas').set('DeployInput', {
       type: 'object',
@@ -901,6 +903,7 @@ describe('resumeAIAgentSync', () => {
     pikkuState(null, 'function', 'meta').deploy = {
       description: 'Deploy',
       inputSchemaName: 'DeployInput',
+      sessionless: true,
     }
     pikkuState(null, 'misc', 'schemas').set('DeployInput', {
       type: 'object',
@@ -986,7 +989,12 @@ describe('getCredential API key override', () => {
     }
 
     const mockServices = {
-      logger: { info: () => {}, warn: () => {}, error: () => {}, debug: () => {} },
+      logger: {
+        info: () => {},
+        warn: () => {},
+        error: () => {},
+        debug: () => {},
+      },
       aiAgentRunner: {
         run: async (): Promise<AIAgentStepResult> => {
           originalRunCalls.push('original')
@@ -1019,13 +1027,24 @@ describe('getCredential API key override', () => {
     const originalRunCalls: string[] = []
 
     const mockServices = {
-      logger: { info: () => {}, warn: () => {}, error: () => {}, debug: () => {} },
+      logger: {
+        info: () => {},
+        warn: () => {},
+        error: () => {},
+        debug: () => {},
+      },
       aiAgentRunner: {
         run: async (): Promise<AIAgentStepResult> => {
           originalRunCalls.push('original')
           return makeStepResult({ text: 'from-original', finishReason: 'stop' })
         },
-        withApiKey: (_key: string) => ({ run: async () => makeStepResult({ text: 'should-not-be-called', finishReason: 'stop' }) }),
+        withApiKey: (_key: string) => ({
+          run: async () =>
+            makeStepResult({
+              text: 'should-not-be-called',
+              finishReason: 'stop',
+            }),
+        }),
       },
       aiRunState: {
         createRun: async () => 'run-no-cred',
@@ -1051,7 +1070,12 @@ describe('getCredential API key override', () => {
     const originalRunCalls: string[] = []
 
     const mockServices = {
-      logger: { info: () => {}, warn: () => {}, error: () => {}, debug: () => {} },
+      logger: {
+        info: () => {},
+        warn: () => {},
+        error: () => {},
+        debug: () => {},
+      },
       aiAgentRunner: {
         run: async (): Promise<AIAgentStepResult> => {
           originalRunCalls.push('original')

package/src/wirings/ai-agent/ai-agent-stream.test.ts

@@ -327,6 +327,7 @@ describe('streamAIAgent', () => {
       description: 'Add a todo',
       approvalRequired: true,
       inputSchemaName: 'AddTodoInput',
+      sessionless: true,
     }
     pikkuState(null, 'misc', 'schemas').set('AddTodoInput', {
       type: 'object',
@@ -428,6 +429,7 @@ describe('streamAIAgent', () => {
       description: 'Add a todo',
       approvalRequired: true,
       inputSchemaName: 'AddTodoInput',
+      sessionless: true,
     }
     pikkuState('@test/addon-todos', 'misc', 'schemas').set('AddTodoInput', {
       type: 'object',
@@ -1287,6 +1289,7 @@ describe('resumeAIAgent', () => {
     pikkuState(null, 'function', 'meta').deploy = {
       description: 'Deploy',
       inputSchemaName: 'DeployInput',
+      sessionless: true,
     }
     pikkuState(null, 'misc', 'schemas').set('DeployInput', {
       type: 'object',

package/src/wirings/channel/channel-common.ts

@@ -6,7 +6,7 @@ import type {
 } from '../../types/core.types.js'
 import type { CoreChannel, ChannelMessageMeta } from './channel.types.js'
 import { combineMiddleware, runMiddleware } from '../../middleware-runner.js'
-import { runPikkuFuncDirectly } from '../../function/function-runner.js'
+import { runPikkuFunc } from '../../function/function-runner.js'
 import {
   combineChannelMiddleware,
   wrapChannelWithMiddleware,
@@ -79,7 +79,14 @@ export const runChannelLifecycleWithMiddleware = async ({
   }
 
   const runLifecycle = async () => {
-    return await runPikkuFuncDirectly(meta.pikkuFuncId, services, wire, data)
+    return await runPikkuFunc('channel', channelConfig.name, meta.pikkuFuncId, {
+      singletonServices: services,
+      data: () => data as any,
+      wire,
+      tags: meta.tags ?? [],
+      inheritedPermissions: meta.permissions,
+      packageName: meta.packageName ?? null,
+    })
   }
 
   if (allMiddleware.length > 0) {