@pikku/core 0.12.27 → 0.12.29

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## 0.12.29
+
+### Patch Changes
+
+- 294e365: Fix body stream caching in PikkuFetchHTTPRequest so that arrayBuffer() can be called after body() has already consumed the stream via text(). This is required for Auth.js CSRF validation to work correctly when integrated with Pikku's internal fetch.
+
+## 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/http/pikku-fetch-http-request.js

@@ -11,6 +11,9 @@ export class PikkuFetchHTTPRequest {
     #cookies;
     #params = {};
     #url;
+    #rawBodyText;
+    #rawBodyBuffer;
+    #bodyRead = false;
     constructor(request) {
         this.request = request;
         this.#url = new URL(request.url);
@@ -25,15 +28,45 @@ export class PikkuFetchHTTPRequest {
      * Retrieves the request body.
      * @returns A promise that resolves to the request body.
      */
-    json() {
-        return this.request.json();
+    async json() {
+        const text = await this.#readRawText();
+        return JSON.parse(text);
     }
     /**
      * Retrieves the raw request body as a Buffer.
      * @returns A promise that resolves to the raw request body.
      */
-    arrayBuffer() {
-        return this.request.arrayBuffer();
+    async arrayBuffer() {
+        if (this.#rawBodyBuffer !== undefined) {
+            return this.#rawBodyBuffer;
+        }
+        if (this.#bodyRead) {
+            if (this.#rawBodyText !== undefined) {
+                const buf = new TextEncoder().encode(this.#rawBodyText)
+                    .buffer;
+                this.#rawBodyBuffer = buf;
+                return buf;
+            }
+            return new ArrayBuffer(0);
+        }
+        const buf = await this.request.arrayBuffer();
+        this.#rawBodyBuffer = buf;
+        this.#bodyRead = true;
+        return buf;
+    }
+    async #readRawText() {
+        if (this.#rawBodyText !== undefined) {
+            return this.#rawBodyText;
+        }
+        if (this.#rawBodyBuffer !== undefined) {
+            const text = new TextDecoder().decode(this.#rawBodyBuffer);
+            this.#rawBodyText = text;
+            return text;
+        }
+        const text = await this.request.text();
+        this.#rawBodyText = text;
+        this.#bodyRead = true;
+        return text;
     }
     headers() {
         return Object.fromEntries(this.request.headers.entries());
@@ -111,7 +144,8 @@ export class PikkuFetchHTTPRequest {
         const contentType = this.header('content-type') || '';
         try {
             if (contentType.includes('application/json')) {
-                const parsed = await this.json();
+                const text = await this.#readRawText();
+                const parsed = text ? JSON.parse(text) : null;
                 body =
                     typeof parsed === 'object' &&
                         parsed !== null &&
@@ -120,15 +154,15 @@ export class PikkuFetchHTTPRequest {
                         : { data: parsed };
             }
             else if (contentType.includes('text/')) {
-                const text = await this.request.text();
+                const text = await this.#readRawText();
                 body = { data: text };
             }
             else if (contentType.includes('application/octet-stream')) {
-                const buffer = await this.request.arrayBuffer();
+                const buffer = await this.arrayBuffer();
                 body = { data: buffer };
             }
             else if (contentType === 'application/x-www-form-urlencoded') {
-                const text = await this.request.text();
+                const text = await this.#readRawText();
                 const params = new URLSearchParams(text);
                 let count = 0;
                 for (const _ of params) {

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.29",
   "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')