@pogodisco/zephyr 1.2.8 → 1.3.0

package/dist/index.d.ts

@@ -7,4 +7,5 @@ export * from "./utils.js";
 export * from "./types.js";
 export * from "./utils.js";
 export * from "./node/index.js";
+export * from "./session.js";
 export { useMetrics, useLog } from "./middleware.js";

package/dist/index.js

@@ -7,4 +7,5 @@ export * from "./utils.js";
 export * from "./types.js";
 export * from "./utils.js";
 export * from "./node/index.js";
+export * from "./session.js";
 export { useMetrics, useLog } from "./middleware.js";

package/dist/registry.d.ts

@@ -1,8 +1,12 @@
-import { Action, ActionRegistry, MergeActionRegistries } from "./types.js";
+import { ActionRegistry, MergeActionRegistries } from "./types.js";
 export declare class ActionRegistryBuilder<R extends ActionRegistry = {}> {
     private registry;
     constructor(initial?: R);
-    action<K extends string, I, O>(key: K, action: Action<I, O>): ActionRegistryBuilder<MergeActionRegistries<R, Record<K, Action<I, O>>>>;
+    /**
+     * Accepts ANY function - sync or async, any parameter shape
+     * F captures the complete function signature for full type inference
+     */
+    action<K extends string, F extends (...args: any[]) => any>(key: K, action: F): ActionRegistryBuilder<MergeActionRegistries<R, Record<K, F>>>;
     extend<Other extends ActionRegistry>(other: ActionRegistryBuilder<Other> | Other): ActionRegistryBuilder<MergeActionRegistries<R, Other>>;
     build(): R;
 }

package/dist/registry.js

@@ -1,3 +1,43 @@
+// import { Action, ActionRegistry, MergeActionRegistries } from "./types.js";
+//
+// export class ActionRegistryBuilder<R extends ActionRegistry = {}> {
+//   private registry: Partial<R> = {};
+//
+//   constructor(initial?: R) {
+//     if (initial) {
+//       this.registry = { ...initial };
+//     }
+//   }
+//
+//   action<K extends string, I, O>(
+//     key: K,
+//     action: Action<I, O>,
+//   ): ActionRegistryBuilder<MergeActionRegistries<R, Record<K, Action<I, O>>>> {
+//     (this.registry as any)[key] = action;
+//     return this as any;
+//   }
+//
+//   // Extend with another registry (with override)
+//   extend<Other extends ActionRegistry>(
+//     other: ActionRegistryBuilder<Other> | Other,
+//   ): ActionRegistryBuilder<MergeActionRegistries<R, Other>> {
+//     const otherRegistry =
+//       other instanceof ActionRegistryBuilder ? other.build() : other;
+//
+//     Object.assign(this.registry, otherRegistry);
+//     return this as any;
+//   }
+//
+//   build(): R {
+//     return this.registry as R;
+//   }
+// }
+//
+// export function createActionRegistry<R extends ActionRegistry = {}>(
+//   initial?: R,
+// ): ActionRegistryBuilder<R> {
+//   return new ActionRegistryBuilder(initial);
+// }
 export class ActionRegistryBuilder {
     constructor(initial) {
         this.registry = {};
@@ -5,6 +45,10 @@ export class ActionRegistryBuilder {
             this.registry = { ...initial };
         }
     }
+    /**
+     * Accepts ANY function - sync or async, any parameter shape
+     * F captures the complete function signature for full type inference
+     */
     action(key, action) {
         this.registry[key] = action;
         return this;

package/dist/session.d.ts

@@ -0,0 +1,25 @@
+import { ActionRegistry, WorkflowMiddleware } from "./types.js";
+import { WorkflowDef } from "./workflow-composer.js";
+type ModuleFlows<Reg extends ActionRegistry> = Record<string, WorkflowDef<Reg, any, any>>;
+export declare class WorkflowSession<Reg extends ActionRegistry, State extends Record<string, any>> {
+    private registry;
+    private subscribers;
+    private running;
+    private queue;
+    state: State;
+    middleware: WorkflowMiddleware[];
+    private moduleFlows;
+    /**
+     * @param baseModule Module to extend (inherits workflows)
+     * @param registry Action registry
+     * @param initialContext Initial context (session state) — will be mutated in workflows
+     */
+    constructor(baseModule: ModuleFlows<Reg>, registry: Reg, initialContext: State, middleware: WorkflowMiddleware[]);
+    getState(): State;
+    subscribe(fn: (state: Partial<State>) => void): () => boolean;
+    private notify;
+    /** Queue a workflow execution by key and input; state/context is automatically updated */
+    dispatch(key: keyof ModuleFlows<Reg>, input?: any): void;
+    private processQueue;
+}
+export {};

package/dist/session.js

@@ -0,0 +1,58 @@
+import { executeWorkflow } from "./workflow-executor.js";
+import { createModule } from "./workflow-module.js";
+export class WorkflowSession {
+    /**
+     * @param baseModule Module to extend (inherits workflows)
+     * @param registry Action registry
+     * @param initialContext Initial context (session state) — will be mutated in workflows
+     */
+    constructor(baseModule, registry, initialContext, middleware) {
+        this.registry = registry;
+        this.subscribers = new Set();
+        this.running = false;
+        this.queue = [];
+        this.middleware = [];
+        // Use the same object for session state and module context
+        this.state = initialContext;
+        this.middleware = middleware;
+        // Per-session module: inherits workflows, shares the same state/context object
+        this.moduleFlows = createModule({
+            registry: this.registry,
+            context: this.state,
+            use: [baseModule],
+            define: () => ({}), // no new flows needed
+        });
+    }
+    getState() {
+        return this.state;
+    }
+    subscribe(fn) {
+        this.subscribers.add(fn);
+        fn(this.state); // immediately notify
+        return () => this.subscribers.delete(fn);
+    }
+    notify() {
+        for (const fn of this.subscribers)
+            fn(this.state);
+    }
+    /** Queue a workflow execution by key and input; state/context is automatically updated */
+    dispatch(key, input = {}) {
+        this.queue.push({ key, input });
+        if (!this.running)
+            this.processQueue();
+    }
+    async processQueue() {
+        this.running = true;
+        while (this.queue.length) {
+            const { key, input } = this.queue.shift();
+            const workflow = this.moduleFlows[key];
+            if (!workflow)
+                throw new Error(`Workflow ${String(key)} not found`);
+            // state/context already lives on the module; no need to pass a separate context
+            await executeWorkflow(workflow, this.registry, input, this.middleware);
+            // Notify subscribers after workflow mutates state
+            this.notify();
+        }
+        this.running = false;
+    }
+}

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 import { createWorkflow } from "./workflow-composer.js";
-export type Action<I = any, O = any> = (args: I) => Promise<O>;
+export type Action<F extends (...args: any[]) => any = (...args: any[]) => any> = F;
 export interface ActionRegistry {
     [key: string]: Action;
 }
@@ -13,6 +13,8 @@ export type ExecutionFrame = {
     output?: any;
     error?: any;
 };
+export type ActionParams<Reg extends ActionRegistry, K extends keyof Reg> = Parameters<Reg[K]>;
+export type ActionReturn<Reg extends ActionRegistry, K extends keyof Reg> = Awaited<ReturnType<Reg[K]>>;
 export type WorkflowMiddleware<Reg extends ActionRegistry = any> = {
     (ctx: {
         stepId: string;

package/dist/types.js

@@ -1 +1,47 @@
+// import { createWorkflow } from "./workflow-composer.js";
+//
+// export type Action<I = any, O = any> = (args: I) => Promise<O>;
+//
+// export interface ActionRegistry {
+//   [key: string]: Action;
+// }
+//
+// export type MergeActionRegistries<
+//   A extends ActionRegistry,
+//   B extends ActionRegistry,
+// > = Omit<A, keyof B> & B;
+//
+// export type ExecutionFrame = {
+//   stepId: string;
+//   attempts: number;
+//   start: number;
+//   end?: number;
+//   input?: any;
+//   output?: any;
+//   error?: any;
+// };
+//
+// export type WorkflowMiddleware<Reg extends ActionRegistry = any> = {
+//   (
+//     ctx: {
+//       stepId: string;
+//       input: any;
+//       results: Record<string, any>;
+//       registry: Reg;
+//       extras: Record<string, any>;
+//       frame: ExecutionFrame;
+//     },
+//     next: () => Promise<any>,
+//   ): Promise<any>;
+// };
+//
+// export type WF<
+//   Reg extends ActionRegistry,
+//   Context extends Record<string, any>,
+// > = ReturnType<typeof createWorkflow<Reg, Context>>;
+// // TODO: this needs enforcing
+// type Observer = (
+//   frame: Readonly<ExecutionFrame>,
+//   extras: Record<string, any>,
+// ) => void | Promise<void>;
 export {};

package/dist/utils.d.ts

@@ -1,8 +1,14 @@
-import { TaskMap, TaskNodeWithContracts, TasksFromFns } from "./node/types.js";
-export declare function createAction<FN extends (args: any) => any, // Allow sync or async
-Out = Awaited<ReturnType<FN>>>(fn: FN): TaskNodeWithContracts<TasksFromFns<{
-    run: FN;
-}>, Parameters<FN>[0], Out>;
-export declare function genericAction<FN extends (args: any) => any>(fn: FN): <T = Awaited<ReturnType<FN>>>() => (initArgs: Parameters<FN>[0]) => Promise<T>;
-export declare function fixedAction<FN extends (args: any) => any, T = Awaited<ReturnType<FN>>>(fn: FN): () => (args: Parameters<FN>[0]) => Promise<T>;
-export declare function useAction<T extends TaskMap, I extends Record<string, any> | undefined, O>(node: TaskNodeWithContracts<T, I, O>): (initArgs: I) => Promise<O>;
+type AnyFn = (...args: any[]) => Promise<any>;
+type Input<F extends AnyFn> = Parameters<F>[0];
+type Output<F extends AnyFn> = Awaited<ReturnType<F>>;
+/**
+ * For generic actions where you want to specify the return type
+ * Just a type helper, does nothing at runtime
+ */
+export declare function genericAction<F extends AnyFn>(fn: F): <T = Output<F>>() => (args: Input<F>) => Promise<T>;
+/**
+ * For fixed actions - just returns the function
+ * The type parameter T is for convenience when you want to override the return type
+ */
+export declare function fixedAction<F extends AnyFn>(fn: F): <T = Output<F>>() => ((args: Input<F>) => Promise<T>);
+export {};

package/dist/utils.js

@@ -1,25 +1,55 @@
-import { defineNode, execNode } from "./node/main.js";
-export function createAction(fn) {
-    // Just return the raw node definition, not wrapped with useNode
-    return defineNode({
-        run: {
-            fn, // Function can throw or return data
-            argMap: (r) => r._init,
-        },
-        _output: (r) => r.run,
-    });
-}
+// import { defineNode, execNode } from "./node/main.js";
+// import { TaskMap, TaskNodeWithContracts, TasksFromFns } from "./node/types.js";
+//
+// export function createAction<
+//   FN extends (args: any) => any, // Allow sync or async
+//   Out = Awaited<ReturnType<FN>>, // Unwrap Promise if present
+// >(fn: FN) {
+//   // Just return the raw node definition, not wrapped with useNode
+//   return defineNode<TasksFromFns<{ run: FN }>, Parameters<FN>[0], Out>({
+//     run: {
+//       fn, // Function can throw or return data
+//       argMap: (r) => r._init,
+//     },
+//     _output: (r) => r.run as Out,
+//   });
+// }
+//
+// export function genericAction<FN extends (args: any) => any>(fn: FN) {
+//   return <T = Awaited<ReturnType<FN>>>() => useAction(createAction<FN, T>(fn));
+// }
+//
+// export function fixedAction<
+//   FN extends (args: any) => any,
+//   T = Awaited<ReturnType<FN>>,
+// >(fn: FN): () => (args: Parameters<FN>[0]) => Promise<T> {
+//   return () => useAction(createAction<FN, T>(fn));
+// }
+//
+// export function useAction<
+//   T extends TaskMap,
+//   I extends Record<string, any> | undefined,
+//   O,
+// >(node: TaskNodeWithContracts<T, I, O>) {
+//   // Returns a function that graph can call, but WITHOUT withResponse
+//   // Just a simple adapter that calls callNode and returns raw _output
+//   return async (initArgs: I): Promise<O> => {
+//     const result = await execNode(node, initArgs);
+//     return result._output; // Just raw data, throws on error
+//   };
+// }
+//
+/**
+ * For generic actions where you want to specify the return type
+ * Just a type helper, does nothing at runtime
+ */
 export function genericAction(fn) {
-    return () => useAction(createAction(fn));
+    return () => fn;
 }
+/**
+ * For fixed actions - just returns the function
+ * The type parameter T is for convenience when you want to override the return type
+ */
 export function fixedAction(fn) {
-    return () => useAction(createAction(fn));
-}
-export function useAction(node) {
-    // Returns a function that graph can call, but WITHOUT withResponse
-    // Just a simple adapter that calls callNode and returns raw _output
-    return async (initArgs) => {
-        const result = await execNode(node, initArgs);
-        return result._output; // Just raw data, throws on error
-    };
+    return () => fn;
 }

package/dist/workflow-composer.d.ts

@@ -1,11 +1,11 @@
-import { ActionRegistry } from "./types.js";
+import { ActionRegistry, ActionParams, ActionReturn } from "./types.js";
 type SubflowResult<SubResults, SubOutput> = SubOutput extends undefined ? SubResults : SubOutput;
-type StepResult<Reg extends ActionRegistry, ActionName extends keyof Reg> = Awaited<ReturnType<Reg[ActionName]>>;
+type StepResult<Reg extends ActionRegistry, ActionName extends keyof Reg> = ActionReturn<Reg, ActionName>;
 export type StepDef<Reg extends ActionRegistry, ID extends string = string, ActionName extends keyof Reg = any> = {
     id: ID;
     action: ActionName;
     dependsOn: string[];
-    resolve: (ctx: any) => Parameters<Reg[ActionName]>[0];
+    resolve: (ctx: any) => ActionParams<Reg, ActionName>;
     when?: (ctx: any) => boolean;
 };
 export type WorkflowDef<Reg extends ActionRegistry, Input, Results, Steps extends StepDef<Reg, any, any>[] = StepDef<Reg, any, any>[], Output = undefined> = {
@@ -16,6 +16,7 @@ export type WorkflowDef<Reg extends ActionRegistry, Input, Results, Steps extend
     input: Input;
     results: Results;
     outputResolver?: (ctx: any) => Output;
+    __context?: any;
 };
 type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
 export declare class WorkflowBuilder<Reg extends ActionRegistry, Input = unknown, Context extends Record<string, any> = {}, Steps extends StepDef<Reg, any, any>[] = [], Results = {}, Output = undefined> {
@@ -26,7 +27,7 @@ export declare class WorkflowBuilder<Reg extends ActionRegistry, Input = unknown
     private frontier;
     private outputResolver?;
     constructor(name: string, registry: Reg, context: Context);
-    step<ID extends string, ActionName extends keyof Reg & string>(id: ID, action: ActionName, resolve?: Parameters<Reg[ActionName]>[0] extends undefined ? (ctx?: {
+    step<ID extends string, ActionName extends keyof Reg & string>(id: ID, action: ActionName, resolve?: ActionParams<Reg, ActionName> extends [] ? (ctx?: {
         input: Input;
         results: Results;
         context: Context;
@@ -34,13 +35,13 @@ export declare class WorkflowBuilder<Reg extends ActionRegistry, Input = unknown
         input: Input;
         results: Results;
         context: Context;
-    }) => Parameters<Reg[ActionName]>[0], dependsOn?: string[]): WorkflowBuilder<Reg, Input, Context, [
+    }) => ActionParams<Reg, ActionName>, dependsOn?: string[]): WorkflowBuilder<Reg, Input, Context, [
         ...Steps,
         StepDef<Reg, ID, ActionName>
     ], Results & {
         [K in ID]: StepResult<Reg, ActionName>;
     }>;
-    seq<ID extends string, ActionName extends keyof Reg & string>(id: ID, action: ActionName, resolve?: Parameters<Reg[ActionName]>[0] extends undefined ? (ctx?: {
+    seq<ID extends string, ActionName extends keyof Reg & string>(id: ID, action: ActionName, resolve?: ActionParams<Reg, ActionName> extends [] ? (ctx?: {
         input: Input;
         results: Results;
         context: Context;
@@ -48,20 +49,20 @@ export declare class WorkflowBuilder<Reg extends ActionRegistry, Input = unknown
         input: Input;
         results: Results;
         context: Context;
-    }) => Parameters<Reg[ActionName]>[0]): WorkflowBuilder<Reg, Input, Context, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K in ID]: Awaited<ReturnType<Reg[ActionName]>>; }, undefined>;
+    }) => ActionParams<Reg, ActionName>): WorkflowBuilder<Reg, Input, Context, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K in ID]: Awaited<ReturnType<Reg[ActionName]>>; }, undefined>;
     parallel<Branches extends WorkflowBuilder<Reg, Input, Context, any, any>[]>(...branches: {
         [K in keyof Branches]: (builder: WorkflowBuilder<Reg, Input, Context, [], Results>) => Branches[K];
     }): WorkflowBuilder<Reg, Input, Context, [
         ...Steps,
         ...(Branches[number] extends WorkflowBuilder<Reg, any, any, infer S, any> ? S : never)
     ], Results & (Branches[number] extends WorkflowBuilder<Reg, any, any, any, infer R> ? UnionToIntersection<R> : {})>;
-    join<ID extends string, ActionName extends keyof Reg & string>(id: ID, action: ActionName, resolve?: Parameters<Reg[ActionName]>[0] extends undefined ? (ctx?: {
+    join<ID extends string, ActionName extends keyof Reg & string>(id: ID, action: ActionName, resolve?: ActionParams<Reg, ActionName> extends [] ? (ctx?: {
         input: Input;
         results: Results;
     }) => undefined : (ctx: {
         input: Input;
         results: Results;
-    }) => Parameters<Reg[ActionName]>[0]): WorkflowBuilder<Reg, Input, Context, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K in ID]: Awaited<ReturnType<Reg[ActionName]>>; }, undefined>;
+    }) => ActionParams<Reg, ActionName>): WorkflowBuilder<Reg, Input, Context, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K in ID]: Awaited<ReturnType<Reg[ActionName]>>; }, undefined>;
     subflow<Prefix extends string, SubInput, SubResults, SubSteps extends StepDef<Reg, any, any>[], SubOutput>(prefix: Prefix, workflow: WorkflowDef<Reg, SubInput, SubResults, SubSteps, SubOutput>, resolveInput?: (ctx: {
         input: Input;
         results: Results;

package/dist/workflow-composer.js

@@ -555,12 +555,14 @@ export class WorkflowBuilder {
     /* ------------------------------------------------ */
     /* Base Step                                         */
     /* ------------------------------------------------ */
-    step(id, action, resolve, dependsOn) {
+    step(id, action, 
+    // 👇 resolve returns whatever the action expects (tuple, object, single value, etc.)
+    resolve, dependsOn) {
         const deps = dependsOn ?? [...this.frontier];
         this.steps.push({
             id,
             action,
-            resolve: resolve ?? (() => undefined),
+            resolve: (resolve ?? (() => undefined)),
             dependsOn: deps,
         });
         this.frontier = [id];
@@ -608,7 +610,6 @@ export class WorkflowBuilder {
                 dependsOn: step.dependsOn.map((d) => idMap.get(d)),
                 resolve: (ctx) => {
                     const subInput = resolveInput ? resolveInput(ctx) : undefined;
-                    // const subInput = resolveInput(ctx);
                     return step.resolve({
                         input: subInput,
                         results: ctx.results,
@@ -638,6 +639,7 @@ export class WorkflowBuilder {
             input: {},
             results: {},
             outputResolver: this.outputResolver,
+            __context: this.context,
         };
     }
     validateDependencies() {

package/dist/workflow-executor.js

@@ -97,12 +97,114 @@
 //
 //   return { results: results as R, extras };
 // }
+// import { composeMiddleware } from "./middleware.js";
+// import { ActionRegistry, ExecutionFrame, WorkflowMiddleware } from "./types.js";
+// import { StepDef, WorkflowDef } from "./workflow-composer.js";
+//
+// export async function executeWorkflow<Reg extends ActionRegistry, I, R, O = R>(
+//   workflow: WorkflowDef<Reg, I, R, any, O>,
+//   registry: Reg,
+//   input: I,
+//   middleware: WorkflowMiddleware<Reg>[] = [],
+// ): Promise<{ results: R; output: O; extras: Record<string, any> }> {
+//   const results: Record<string, any> = {};
+//   const extras: Record<string, any> = {};
+//   extras.frames = {} as Record<string, ExecutionFrame>;
+//
+//   // --- strongly type steps ---
+//
+//   const stepById = new Map<string, StepDef<Reg, any, any>>(
+//     workflow.steps.map((s: StepDef<Reg, any, any>) => [s.id, s]),
+//   );
+//   const remainingDeps = new Map<string, number>();
+//   const dependents = new Map<string, string[]>();
+//   const ready: string[] = [];
+//
+//   // Build dependency graph
+//   for (const step of workflow.steps) {
+//     remainingDeps.set(step.id, step.dependsOn.length);
+//     if (step.dependsOn.length === 0) ready.push(step.id);
+//
+//     for (const dep of step.dependsOn) {
+//       if (!dependents.has(dep)) dependents.set(dep, []);
+//       dependents.get(dep)!.push(step.id);
+//     }
+//   }
+//
+//   let completed = 0;
+//
+//   while (ready.length > 0) {
+//     const batch = ready.splice(0);
+//
+//     await Promise.all(
+//       batch.map(async (stepId) => {
+//         const step = stepById.get(stepId)!;
+//
+//         const frame: ExecutionFrame = {
+//           stepId,
+//           attempts: 0,
+//           start: Date.now(),
+//         };
+//         extras.frames[stepId] = frame;
+//
+//         const ctx = { stepId, input, results, registry, extras, frame };
+//
+//         const core = async () => {
+//           frame.attempts++;
+//           frame.input = step.resolve?.({ input, results }) ?? undefined;
+//
+//           try {
+//             const action = registry[step.action];
+//             const result =
+//               frame.input === undefined
+//                 ? await (action as () => Promise<any>)()
+//                 : await action(frame.input);
+//             // const result = await action(frame.input);
+//             frame.output = result;
+//             frame.end = Date.now();
+//
+//             results[step.id] = result;
+//             return result;
+//           } catch (err) {
+//             frame.error = err;
+//             frame.end = Date.now();
+//             throw err;
+//           }
+//         };
+//
+//         const composed = composeMiddleware(middleware, ctx, core);
+//         await composed();
+//
+//         for (const childId of dependents.get(stepId) ?? []) {
+//           const remaining = remainingDeps.get(childId)! - 1;
+//           remainingDeps.set(childId, remaining);
+//           if (remaining === 0) ready.push(childId);
+//         }
+//
+//         completed++;
+//       }),
+//     );
+//   }
+//
+//   if (completed !== workflow.steps.length) {
+//     throw new Error("Workflow execution failed (cycle or missing dependency)");
+//   }
+//
+//   // Resolve output
+//   const output: O = workflow.outputResolver
+//     ? workflow.outputResolver({ input, results: results as R })
+//     : (results as unknown as O);
+//
+//   return { results: results as R, output, extras };
+// }
+//
+//
+///// with any fn shape
 import { composeMiddleware } from "./middleware.js";
 export async function executeWorkflow(workflow, registry, input, middleware = []) {
     const results = {};
     const extras = {};
     extras.frames = {};
-    // --- strongly type steps ---
     const stepById = new Map(workflow.steps.map((s) => [s.id, s]));
     const remainingDeps = new Map();
     const dependents = new Map();
@@ -129,16 +231,36 @@ export async function executeWorkflow(workflow, registry, input, middleware = []
                 start: Date.now(),
             };
             extras.frames[stepId] = frame;
-            const ctx = { stepId, input, results, registry, extras, frame };
+            const context = workflow.__context;
+            const ctx = {
+                stepId,
+                input,
+                results,
+                context,
+                registry,
+                extras,
+                frame,
+            };
             const core = async () => {
                 frame.attempts++;
-                frame.input = step.resolve?.({ input, results }) ?? undefined;
+                // 👇 Get the resolved arguments (should be a tuple or undefined)
+                const resolvedArgs = step.resolve?.({ input, results, context });
+                frame.input = resolvedArgs;
                 try {
                     const action = registry[step.action];
-                    const result = frame.input === undefined
-                        ? await action()
-                        : await action(frame.input);
-                    // const result = await action(frame.input);
+                    let result;
+                    if (resolvedArgs === undefined) {
+                        // No arguments - call with nothing
+                        result = await action();
+                    }
+                    else if (Array.isArray(resolvedArgs)) {
+                        // Tuple arguments - spread as positional params
+                        result = await action(...resolvedArgs);
+                    }
+                    else {
+                        // Single object argument (backward compatibility)
+                        result = await action(resolvedArgs);
+                    }
                     frame.output = result;
                     frame.end = Date.now();
                     results[step.id] = result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pogodisco/zephyr",
-  "version": "1.2.8",
+  "version": "1.3.0",
   "publishConfig": {
     "access": "public"
   },