@pikku/core 0.12.18 → 0.12.20

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

@@ -1,10 +1,12 @@
 import { pikkuState } from '../../../pikku-state.js';
 import { generateCommandHelp, parseCLIArguments } from '../command-parser.js';
 /**
- * Default JSON renderer for CLI output
+ * Default JSON renderer for CLI output. Emits single-line NDJSON so
+ * the output stays machine-parseable when the CLI is run with
+ * `--output json`; pretty-printing here would break NDJSON consumers.
  */
 const defaultJSONRenderer = (_services, data) => {
-    console.log(JSON.stringify(data, null, 2));
+    console.log(JSON.stringify(data));
 };
 /**
  * Execute a CLI program via WebSocket channel

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

@@ -17,10 +17,12 @@ export class CLIError extends Error {
     }
 }
 /**
- * Default JSON renderer for CLI output
+ * Default JSON renderer for CLI output. Emits single-line NDJSON so
+ * the output stays machine-parseable when the CLI is run with
+ * `--output json`; pretty-printing here would break NDJSON consumers.
  */
 const defaultJSONRenderer = (_services, data) => {
-    console.log(JSON.stringify(data, null, 2));
+    console.log(JSON.stringify(data));
 };
 /**
  * Registers a CLI command tree and all its functions

package/dist/wirings/rpc/rpc-runner.d.ts

@@ -18,10 +18,11 @@ export declare class ContextAwareRPCService {
     private services;
     private wire;
     private options;
+    private packageName;
     constructor(services: CoreServices, wire: PikkuWire, options: {
         requiresAuth?: boolean;
         sessionService?: SessionService<CoreUserSession>;
-    });
+    }, packageName?: string | null);
     rpcExposed(funcName: string, data: any): Promise<any>;
     rpc<In = any, Out = any>(funcName: string, data: In): Promise<Out>;
     /**
@@ -96,7 +97,7 @@ export declare class PikkuRPCService<Services extends CoreServices, TypedRPC = P
     getContextRPCService(services: Services, wire: PikkuWire, requiresAuthOrOptions?: boolean | {
         requiresAuth?: boolean;
         sessionService?: SessionService<CoreUserSession>;
-    } | undefined, depth?: number): TypedRPC;
+    } | undefined, depth?: number, packageName?: string | null): TypedRPC;
 }
 export declare const rpcService: PikkuRPCService<import("../../types/core.types.js").CoreSingletonServices<{
     logLevel?: import("../../services/logger.js").LogLevel;

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

@@ -39,7 +39,22 @@ export const resolveNamespace = (namespacedFunction) => {
         addonConfig: pkgConfig,
     };
 };
-const getPikkuFunctionName = (rpcName) => {
+/**
+ * Resolve a bare (non-namespaced) RPC name to its pikkuFuncId, preferring
+ * the caller's addon package when provided. Returns the function name plus
+ * the package scope that resolved it (null = root), so callers can thread
+ * the scope into runPikkuFunc without a second lookup.
+ */
+const resolvePikkuFunction = (rpcName, packageName = null) => {
+    // Addon-scoped calls: try the caller's package function meta first.
+    // (RPC meta only lives in root; addon functions are registered under their package.)
+    if (packageName) {
+        const pkgFunctions = pikkuState(packageName, 'function', 'meta');
+        const pkgMeta = pkgFunctions?.[rpcName];
+        if (pkgMeta) {
+            return { pikkuFuncId: pkgMeta.pikkuFuncId || rpcName, packageName };
+        }
+    }
     const rpc = pikkuState(null, 'rpc', 'meta');
     let rpcMeta = rpc[rpcName];
     if (!rpcMeta) {
@@ -51,17 +66,19 @@ const getPikkuFunctionName = (rpcName) => {
     if (!rpcMeta) {
         throw new RPCNotFoundError(rpcName);
     }
-    return rpcMeta;
+    return { pikkuFuncId: rpcMeta, packageName: null };
 };
 // Context-aware RPC client for use within services
 export class ContextAwareRPCService {
     services;
     wire;
     options;
-    constructor(services, wire, options) {
+    packageName;
+    constructor(services, wire, options, packageName = null) {
         this.services = services;
         this.wire = wire;
         this.options = options;
+        this.packageName = packageName;
     }
     async rpcExposed(funcName, data) {
         let functionMeta;
@@ -105,13 +122,18 @@ export class ContextAwareRPCService {
                 // Not an addon — fall through to local lookup
             }
         }
-        // Try local function, then fall back to deployment service (remote)
+        // Bare name: resolve via caller's package scope first (if any), then root.
+        // Note: intra-addon bare calls do NOT re-apply the addon's external
+        // addonConfig.auth/tags — those gates are only applied on the external
+        // 'namespace:func' boundary via invokeAddonFunction.
         try {
-            return await runPikkuFunc('rpc', funcName, getPikkuFunctionName(funcName), {
+            const resolved = resolvePikkuFunction(funcName, this.packageName);
+            return await runPikkuFunc('rpc', funcName, resolved.pikkuFuncId, {
                 auth: this.options.requiresAuth,
                 singletonServices: this.services,
                 data: () => data,
                 wire: updatedWire,
+                packageName: resolved.packageName,
             });
         }
         catch (e) {
@@ -181,11 +203,13 @@ export class ContextAwareRPCService {
             return this.invokeAddonFunction(rpcName, data, mergedWire);
         }
         try {
-            return await runPikkuFunc('rpc', rpcName, getPikkuFunctionName(rpcName), {
+            const resolved = resolvePikkuFunction(rpcName, this.packageName);
+            return await runPikkuFunc('rpc', rpcName, resolved.pikkuFuncId, {
                 auth: this.options.requiresAuth,
                 singletonServices: this.services,
                 data: () => data,
                 wire: mergedWire,
+                packageName: resolved.packageName,
             });
         }
         catch (e) {
@@ -269,12 +293,12 @@ export class ContextAwareRPCService {
 // RPC Service class for the global interface
 export class PikkuRPCService {
     // Convenience function for initializing
-    getContextRPCService(services, wire, requiresAuthOrOptions, depth = 0) {
+    getContextRPCService(services, wire, requiresAuthOrOptions, depth = 0, packageName = null) {
         const options = typeof requiresAuthOrOptions === 'object' &&
             requiresAuthOrOptions !== null
             ? requiresAuthOrOptions
             : { requiresAuth: requiresAuthOrOptions };
-        const serviceRPC = new ContextAwareRPCService(services, wire, options);
+        const serviceRPC = new ContextAwareRPCService(services, wire, options, packageName);
         return {
             depth,
             global: false,

package/dist/wirings/workflow/graph/graph-runner.js

@@ -580,7 +580,10 @@ export async function runWorkflowGraph(workflowService, graphName, triggerInput,
     if (!meta.graphHash) {
         throw new Error(`Workflow graph '${graphName}': missing graphHash in meta`);
     }
-    const runId = await workflowService.createRun(graphName, triggerInput, inline ?? false, meta.graphHash, wire ?? { type: 'unknown' });
+    const runId = await workflowService.createRun(graphName, triggerInput, inline ?? false, meta.graphHash, wire ?? { type: 'unknown' }, {
+        deterministic: meta.deterministic,
+        plannedSteps: meta.plannedSteps,
+    });
     if (inline) {
         workflowService.registerInlineRun(runId);
     }

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

@@ -8,5 +8,5 @@ export { pikkuWorkflowGraph, type PikkuWorkflowGraphConfig, type PikkuWorkflowGr
 export { validateWorkflowWiring, computeEntryNodeIds, } from './graph/graph-validation.js';
 export { pikkuWorkflowWorkerFunc, pikkuWorkflowOrchestratorFunc, pikkuWorkflowSleeperFunc, } from './workflow-queue-workers.js';
 export type { WorkflowStepInput as WorkflowStepQueueInput, PikkuWorkflowOrchestratorInput, PikkuWorkflowSleeperInput, } from './workflow-queue-workers.js';
-export type { WorkflowService, WorkflowServiceConfig, WorkflowRunWire, WorkflowStatus, WorkflowVersionStatus, StepStatus, WorkflowRun, WorkflowRunStatus, StepState, WorkflowRunService, CoreWorkflow, PikkuWorkflow, ContextVariable, WorkflowContext, WorkflowsMeta, WorkflowRuntimeMeta, WorkflowsRuntimeMeta, WorkflowStepInput, WorkflowOrchestratorInput, WorkflowSleeperInput, } from './workflow.types.js';
+export type { WorkflowService, WorkflowServiceConfig, WorkflowPlannedStep, WorkflowRunWire, WorkflowStatus, WorkflowVersionStatus, StepStatus, WorkflowRun, WorkflowRunStatus, StepState, WorkflowRunService, CoreWorkflow, PikkuWorkflow, ContextVariable, WorkflowContext, WorkflowsMeta, WorkflowRuntimeMeta, WorkflowsRuntimeMeta, WorkflowStepInput, WorkflowOrchestratorInput, WorkflowSleeperInput, } from './workflow.types.js';
 export type { WorkflowStepOptions, WorkflowWireDoRPC, WorkflowWireDoInline, WorkflowWireSleep, WorkflowWireSuspend, InputSource, OutputBinding, RpcStepMeta, SimpleCondition, Condition, BranchCase, BranchStepMeta, ParallelGroupStepMeta, FanoutStepMeta, ReturnStepMeta, InlineStepMeta, SleepStepMeta, CancelStepMeta, SetStepMeta, SwitchCaseMeta, SwitchStepMeta, FilterStepMeta, ArrayPredicateStepMeta, WorkflowStepMeta, WorkflowStepWire, PikkuWorkflowWire, } from './workflow.types.js';

package/dist/wirings/workflow/pikku-workflow-service.d.ts

@@ -1,5 +1,5 @@
 import type { SerializedError } from '../../types/core.types.js';
-import type { PikkuWorkflowWire, StepState, WorkflowRun, WorkflowRunStatus, WorkflowRunWire, WorkflowStatus, WorkflowVersionStatus, WorkflowStepOptions } from './workflow.types.js';
+import type { PikkuWorkflowWire, StepState, WorkflowPlannedStep, WorkflowRun, WorkflowRunStatus, WorkflowRunWire, WorkflowStatus, WorkflowVersionStatus, WorkflowStepOptions } from './workflow.types.js';
 import type { WorkflowService } from '../../services/workflow-service.js';
 import { PikkuError } from '../../errors/error-handler.js';
 /**
@@ -62,7 +62,10 @@ export declare abstract class PikkuWorkflowService implements WorkflowService {
      */
     unregisterInlineRun(runId: string): void;
     registerWorkflowVersions(): Promise<void>;
-    abstract createRun(workflowName: string, input: any, inline: boolean, graphHash: string, wire: WorkflowRunWire): Promise<string>;
+    abstract createRun(workflowName: string, input: any, inline: boolean, graphHash: string, wire: WorkflowRunWire, options?: {
+        deterministic?: boolean;
+        plannedSteps?: WorkflowPlannedStep[];
+    }): Promise<string>;
     /**
      * Get a workflow run by ID
      * @param id - Run ID

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

@@ -231,6 +231,8 @@ export class PikkuWorkflowService {
             status: run.status,
             startedAt: run.createdAt,
             completedAt: terminalStatuses.has(run.status) ? run.updatedAt : undefined,
+            deterministic: run.deterministic,
+            plannedSteps: run.plannedSteps,
             steps,
             output: run.status === 'completed' ? run.output : undefined,
             error: run.error
@@ -326,7 +328,10 @@ export class PikkuWorkflowService {
         const shouldInline = options?.inline ||
             workflowMeta.inline ||
             !getSingletonServices()?.queueService;
-        const runId = await this.createRun(name, input, shouldInline, workflowMeta.graphHash, wire);
+        const runId = await this.createRun(name, input, shouldInline, workflowMeta.graphHash, wire, {
+            deterministic: workflowMeta.deterministic,
+            plannedSteps: workflowMeta.plannedSteps,
+        });
         if (shouldInline) {
             this.inlineRuns.add(runId);
             try {

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

@@ -18,6 +18,10 @@ export interface WorkflowServiceConfig {
     stepWorkerQueueName: string;
     sleeperRPCName: string;
 }
+export interface WorkflowPlannedStep {
+    /** Human-readable step label for UI timeline */
+    stepName: string;
+}
 /**
  * Workflow run status
  */
@@ -50,6 +54,10 @@ export interface WorkflowRun {
     inline?: boolean;
     /** Graph hash of the workflow definition at run creation time */
     graphHash?: string;
+    /** True when the workflow has a static, pre-computable step timeline */
+    deterministic?: boolean;
+    /** Static planned steps snapshot captured at run start */
+    plannedSteps?: WorkflowPlannedStep[];
     /** Wire origin info (how this run was started) */
     wire: WorkflowRunWire;
     /** Creation timestamp */
@@ -95,6 +103,8 @@ export interface WorkflowRunStatus {
     status: WorkflowStatus;
     startedAt: Date;
     completedAt?: Date;
+    deterministic?: boolean;
+    plannedSteps?: WorkflowPlannedStep[];
     steps: Array<{
         name: string;
         status: StepStatus;
@@ -211,6 +221,10 @@ export interface WorkflowRuntimeMeta {
     entryNodeIds?: string[];
     /** Hash of graph topology (nodes, edges, input mappings) */
     graphHash?: string;
+    /** True when the workflow has a static, pre-computable step timeline */
+    deterministic?: boolean;
+    /** Static planned steps metadata for deterministic workflows */
+    plannedSteps?: WorkflowPlannedStep[];
 }
 /**
  * Unified workflow runtime metadata map

package/package.json

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

package/src/function/function-runner.ts

@@ -72,6 +72,54 @@ async function resolveSession(
  * @param parentServices - The parent/caller's singleton services (used as base)
  * @returns The package's singleton services
  */
+/**
+ * Find the consumer-defined namespace (from wireAddon) for a given addon package.
+ * Returns null if the package isn't registered as an addon.
+ */
+const findAddonNamespaceForPackage = (packageName: string): string | null => {
+  const addons = pikkuState(null, 'addons', 'packages')
+  if (!addons) return null
+  for (const [namespace, cfg] of addons.entries()) {
+    if (cfg?.package === packageName) return namespace
+  }
+  return null
+}
+
+/**
+ * Wrap a workflow service so that bare workflow names passed from inside an
+ * addon function are auto-prefixed with the addon's consumer-facing namespace.
+ * Without this, `runToCompletion('myWorkflow')` from inside an addon misses
+ * the workflow registered under the addon's package scope and throws
+ * WorkflowNotFoundError — forcing addons to hardcode their consumer-defined
+ * namespace, which couples the addon to its caller.
+ *
+ * Explicit `'ns:name'` and bare names that already exist in root meta are
+ * unaffected; only bare names that would otherwise miss resolution get
+ * prefixed.
+ */
+const wrapWorkflowServiceForPackage = <T extends object>(
+  service: T,
+  packageName: string
+): T => {
+  return new Proxy(service, {
+    get(target, prop, receiver) {
+      if (prop === 'startWorkflow' || prop === 'runToCompletion') {
+        const original = Reflect.get(target, prop, receiver) as Function
+        return function (this: any, name: string, ...rest: any[]) {
+          if (typeof name === 'string' && !name.includes(':')) {
+            const namespace = findAddonNamespaceForPackage(packageName)
+            if (namespace) {
+              name = `${namespace}:${name}`
+            }
+          }
+          return original.call(this, name, ...rest)
+        }
+      }
+      return Reflect.get(target, prop, receiver)
+    },
+  })
+}
+
 const getOrCreatePackageSingletonServices = async (
   packageName: string,
   parentServices: CoreSingletonServices
@@ -101,6 +149,18 @@ const getOrCreatePackageSingletonServices = async (
     parentServices
   )
 
+  // Wrap workflowService so that bare names used inside the addon's functions
+  // resolve to workflows registered under the addon's package scope.
+  if (
+    packageServices.workflowService &&
+    typeof packageServices.workflowService === 'object'
+  ) {
+    packageServices.workflowService = wrapWorkflowServiceForPackage(
+      packageServices.workflowService as object,
+      packageName
+    ) as typeof packageServices.workflowService
+  }
+
   // Cache the services
   pikkuState(packageName, 'package', 'singletonServices', packageServices)
 
@@ -378,11 +438,16 @@ export const runPikkuFunc = async <In = any, Out = any>(
         wireServices && Object.keys(wireServices).length > 0
           ? { ...resolvedSingletonServices, ...wireServices }
           : resolvedSingletonServices
+      const callerPackageName = packageName
       Object.defineProperty(resolvedWire, 'rpc', {
         get() {
-          const rpc = rpcService.getContextRPCService(services, resolvedWire, {
-            sessionService,
-          })
+          const rpc = rpcService.getContextRPCService(
+            services,
+            resolvedWire,
+            { sessionService },
+            0,
+            callerPackageName
+          )
           Object.defineProperty(resolvedWire, 'rpc', {
             value: rpc,
             writable: true,

package/src/function/functions.types.ts

@@ -74,15 +74,8 @@ export type CorePikkuFunctionSessionless<
 export type CorePikkuPermission<
   In = any,
   Services extends CoreSingletonServices = CoreServices,
-  Wire extends PikkuWire<
-    In,
-    never,
-    false,
-    CoreUserSession,
-    any,
-    never,
-    never
-  > = PikkuWire<In, never, false, CoreUserSession, never, never, never>,
+  Wire extends PikkuWire<In, never, false, CoreUserSession, any, never, never> =
+    PikkuWire<In, never, false, CoreUserSession, never, never, never>,
 > = (services: Services, data: In, wire: Wire) => Promise<boolean>
 
 /**
@@ -269,11 +262,8 @@ export type CorePikkuFunctionConfig<
   PikkuFunction extends
     | CorePikkuFunction<any, any, any, any, any>
     | CorePikkuFunctionSessionless<any, any, any, any, any>,
-  PikkuPermission extends CorePikkuPermission<
-    any,
-    any,
-    any
-  > = CorePikkuPermission<any>,
+  PikkuPermission extends CorePikkuPermission<any, any, any> =
+    CorePikkuPermission<any>,
   PikkuMiddleware extends CorePikkuMiddleware<any, any> = CorePikkuMiddleware<
     any,
     any
@@ -292,6 +282,7 @@ export type CorePikkuFunctionConfig<
   remote?: boolean
   mcp?: boolean
   readonly?: boolean
+  deploy?: 'serverless' | 'server' | 'auto'
   approvalRequired?: boolean
   approvalDescription?: any
   func: PikkuFunction

package/src/index.ts

@@ -98,7 +98,16 @@ export type { QueueService } from './wirings/queue/queue.types.js'
 export type { JWTService } from './services/jwt-service.js'
 export type { SecretService } from './services/secret-service.js'
 export type { VariablesService } from './services/variables-service.js'
-export type { ContentService } from './services/content-service.js'
+export type {
+  ContentService,
+  SignContentKeyArgs,
+  SignURLArgs,
+  GetUploadURLArgs,
+  UploadURLResult,
+  BucketKeyArgs,
+  WriteFileArgs,
+  CopyFileArgs,
+} from './services/content-service.js'
 export type { DeploymentService } from './services/deployment-service.js'
 export type { WorkflowService } from './services/workflow-service.js'
 export type { GatewayService } from './services/gateway-service.js'

package/src/services/content-service.ts

@@ -1,81 +1,109 @@
-export interface ContentService {
+/**
+ * Arguments for signing a content key into a time-limited URL.
+ */
+export interface SignContentKeyArgs<TBucket extends string = string> {
+  bucket: TBucket
+  contentKey: string
+  dateLessThan: Date
+  dateGreaterThan?: Date
+}
+
+/**
+ * Arguments for signing an arbitrary URL.
+ */
+export interface SignURLArgs {
+  url: string
+  dateLessThan: Date
+  dateGreaterThan?: Date
+}
+
+/**
+ * Arguments for minting a presigned upload URL.
+ */
+export interface GetUploadURLArgs<TBucket extends string = string> {
+  bucket: TBucket
+  fileKey: string
+  contentType: string
+  size?: number
+}
+
+/**
+ * Result of minting a presigned upload URL.
+ */
+export interface UploadURLResult {
+  uploadUrl: string
+  assetKey: string
+  uploadHeaders?: Record<string, string>
+  uploadMethod?: 'PUT' | 'POST'
+}
+
+/**
+ * Arguments for an operation that targets a single object by key.
+ */
+export interface BucketKeyArgs<TBucket extends string = string> {
+  bucket: TBucket
+  key: string
+}
+
+/**
+ * Arguments for writing a stream to storage.
+ */
+export interface WriteFileArgs<
+  TBucket extends string = string,
+> extends BucketKeyArgs<TBucket> {
+  stream: ReadableStream | NodeJS.ReadableStream
+}
+
+/**
+ * Arguments for copying a local file into storage.
+ */
+export interface CopyFileArgs<
+  TBucket extends string = string,
+> extends BucketKeyArgs<TBucket> {
+  fromAbsolutePath: string
+}
+
+export interface ContentService<TBucket extends string = string> {
   /**
    * Signs a content key to generate a secure, time-limited access URL.
-   * @param contentKey - The key representing the content object.
-   * @param dateLessThan - The expiration time for the signed URL.
-   * @param dateGreaterThan - (Optional) Start time before which access is denied.
    */
-  signContentKey(
-    contentKey: string,
-    dateLessThan: Date,
-    dateGreaterThan?: Date
-  ): Promise<string>
+  signContentKey(args: SignContentKeyArgs<TBucket>): Promise<string>
 
   /**
    * Signs an arbitrary URL to generate a secure, time-limited access URL.
-   * @param url - The full URL that needs signing.
-   * @param dateLessThan - The expiration time for the signed URL.
-   * @param dateGreaterThan - (Optional) Start time before which access is denied.
    */
-  signURL(
-    url: string,
-    dateLessThan: Date,
-    dateGreaterThan?: Date
-  ): Promise<string>
+  signURL(args: SignURLArgs): Promise<string>
 
   /**
    * Generates a signed URL for uploading a file directly to storage.
-   * @param fileKey - The desired key/location of the uploaded file.
-   * @param contentType - The MIME type of the file.
-   * @returns A signed upload URL and the finalized asset key.
+   * Bucket policy (size limits, MIME allowlist) is enforced by the implementation.
    */
-  getUploadURL(
-    fileKey: string,
-    contentType: string
-  ): Promise<{
-    uploadUrl: string
-    assetKey: string
-    uploadHeaders?: Record<string, string>
-    uploadMethod?: 'PUT' | 'POST'
-  }>
+  getUploadURL(args: GetUploadURLArgs<TBucket>): Promise<UploadURLResult>
 
   /**
    * Deletes a file from the storage backend.
-   * @param fileName - The name or key of the file to delete.
-   * @returns A boolean indicating success.
    */
-  deleteFile(fileName: string): Promise<boolean>
+  deleteFile(args: BucketKeyArgs<TBucket>): Promise<boolean>
 
   /**
-   * Uploads a file stream to storage under a specified asset key.
-   * @param assetKey - The key where the file will be saved.
-   * @param stream - A readable stream of the file contents.
-   * @returns A boolean indicating success.
+   * Uploads a file stream to storage under the specified bucket + key.
    */
-  writeFile(
-    assetKey: string,
-    stream: ReadableStream | NodeJS.ReadableStream
-  ): Promise<boolean>
+  writeFile(args: WriteFileArgs<TBucket>): Promise<boolean>
 
   /**
-   * Copies a file from a local absolute path into storage under a new asset key.
-   * @param assetKey - The destination key.
-   * @param fromAbsolutePath - The local absolute file path.
-   * @returns A boolean indicating success.
+   * Copies a file from a local absolute path into storage.
    */
-  copyFile(assetKey: string, fromAbsolutePath: string): Promise<boolean>
+  copyFile(args: CopyFileArgs<TBucket>): Promise<boolean>
 
   /**
    * Reads a file from storage as a readable stream.
-   * @param assetKey - The key of the file to read.
-   * @returns A readable file stream.
    */
-  readFile(assetKey: string): Promise<ReadableStream | NodeJS.ReadableStream>
+  readFile(
+    args: BucketKeyArgs<TBucket>
+  ): Promise<ReadableStream | NodeJS.ReadableStream>
 
   /**
    * Reads an entire file from storage into a Buffer.
-   * @param assetKey - The key of the file to read.
-   * @returns The file contents as a Buffer.
    */
-  readFileAsBuffer(assetKey: string): Promise<Buffer>
+  readFileAsBuffer(args: BucketKeyArgs<TBucket>): Promise<Buffer>
 }

package/src/services/in-memory-workflow-service.test.ts

@@ -46,6 +46,27 @@ describe('InMemoryWorkflowService', () => {
       const state = await service.getRunState(runId)
       assert.deepStrictEqual(state, {})
     })
+
+    test('should persist deterministic planned steps metadata', async () => {
+      const runId = await service.createRun(
+        'wf',
+        {},
+        true,
+        'h',
+        {} as any,
+        {
+          deterministic: true,
+          plannedSteps: [{ stepName: 'Step 1' }, { stepName: 'Step 2' }],
+        }
+      )
+
+      const run = await service.getRun(runId)
+      assert.strictEqual(run?.deterministic, true)
+      assert.deepStrictEqual(run?.plannedSteps, [
+        { stepName: 'Step 1' },
+        { stepName: 'Step 2' },
+      ])
+    })
   })
 
   describe('getRun', () => {

package/src/services/in-memory-workflow-service.ts

@@ -2,6 +2,7 @@ import { randomUUID } from 'crypto'
 import { PikkuWorkflowService } from '../wirings/workflow/pikku-workflow-service.js'
 import type { SerializedError } from '../types/core.types.js'
 import type {
+  WorkflowPlannedStep,
   WorkflowRun,
   WorkflowRunService,
   WorkflowRunWire,
@@ -55,7 +56,11 @@ export class InMemoryWorkflowService
     input: any,
     inline: boolean,
     graphHash: string,
-    wire: WorkflowRunWire
+    wire: WorkflowRunWire,
+    options?: {
+      deterministic?: boolean
+      plannedSteps?: WorkflowPlannedStep[]
+    }
   ): Promise<string> {
     const runId = randomUUID()
     const now = new Date()
@@ -67,6 +72,8 @@ export class InMemoryWorkflowService
       input,
       inline,
       graphHash,
+      deterministic: options?.deterministic,
+      plannedSteps: options?.plannedSteps,
       wire,
       createdAt: now,
       updatedAt: now,

package/src/services/index.ts

@@ -25,7 +25,16 @@ export { InMemoryQueueService } from './in-memory-queue-service.js'
 export { InMemoryTriggerService } from './in-memory-trigger-service.js'
 export { InMemoryAIRunStateService } from './in-memory-ai-run-state-service.js'
 export { LocalGatewayService } from './local-gateway-service.js'
-export type { ContentService } from './content-service.js'
+export type {
+  ContentService,
+  SignContentKeyArgs,
+  SignURLArgs,
+  GetUploadURLArgs,
+  UploadURLResult,
+  BucketKeyArgs,
+  WriteFileArgs,
+  CopyFileArgs,
+} from './content-service.js'
 export type { JWTService } from './jwt-service.js'
 export type { Logger } from './logger.js'
 export type { SecretService } from './secret-service.js'