@positronic/core 0.0.1

package/src/dsl/workflow.test.ts

@@ -0,0 +1,1435 @@
+import { WORKFLOW_EVENTS, STATUS } from './constants';
+import { applyPatches} from './json-patch';
+import { State } from './types';
+import { workflow, type WorkflowEvent, type WorkflowErrorEvent} from './workflow';
+import { z } from 'zod';
+import { nextStep } from '../../../../test-utils';
+import { FileStore } from '../file-stores/types';
+
+class TestFileStore implements FileStore {
+  private files: Map<string, string> = new Map();
+
+  setFile(path: string, content: string) {
+    this.files.set(path, content);
+  }
+
+  async readFile(path: string): Promise<string> {
+    const content = this.files.get(path);
+    if (content === undefined) {
+      throw new Error(`File not found: ${path}`);
+    }
+    return content;
+  }
+}
+
+const testFileStore = new TestFileStore();
+
+type AssertEquals<T, U> =
+  0 extends (1 & T) ? false : // fails if T is any
+  0 extends (1 & U) ? false : // fails if U is any
+  [T] extends [U] ? [U] extends [T] ? true : false : false;
+
+// Mock PromptClient for testing
+const mockClient = {
+  execute: jest.fn()
+};
+
+describe('workflow creation', () => {
+  it('should create a workflow with steps and run through them', async () => {
+    const testWorkflow = workflow('test workflow')
+      .step(
+        "First step",
+        () => {
+          return { count: 1 };
+        }
+      )
+      .step(
+        "Second step",
+        ({ state }) => ({ ...state, doubled: state.count * 2 })
+      );
+
+    const workflowRun = testWorkflow.run({ client: mockClient, fileStore: testFileStore });
+
+    // Check start event
+    const startResult = await workflowRun.next();
+    expect(startResult.value).toEqual(expect.objectContaining({
+      type: WORKFLOW_EVENTS.START,
+      status: STATUS.RUNNING,
+      workflowTitle: 'test workflow',
+      workflowDescription: undefined
+    }));
+
+    // Skip initial step status event
+    await nextStep(workflowRun);
+
+    // Check first step start
+    const firstStepStartResult = await nextStep(workflowRun);
+    expect(firstStepStartResult).toEqual(expect.objectContaining({
+      type: WORKFLOW_EVENTS.STEP_START,
+      status: STATUS.RUNNING,
+      stepTitle: 'First step',
+      stepId: expect.any(String)
+    }));
+
+    // Check first step completion
+    const firstStepResult = await nextStep(workflowRun);
+    expect(firstStepResult).toEqual(expect.objectContaining({
+      type: WORKFLOW_EVENTS.STEP_COMPLETE,
+      status: STATUS.RUNNING,
+      stepTitle: 'First step',
+      stepId: expect.any(String),
+      patch: [{
+        op: 'add',
+        path: '/count',
+        value: 1
+      }]
+    }));
+
+    // Step Status Event
+    await nextStep(workflowRun);
+
+    // Check second step start
+    const secondStepStartResult = await nextStep(workflowRun);
+    expect(secondStepStartResult).toEqual(expect.objectContaining({
+      type: WORKFLOW_EVENTS.STEP_START,
+      status: STATUS.RUNNING,
+      stepTitle: 'Second step',
+      stepId: expect.any(String)
+    }));
+
+    // Check second step completion
+    const secondStepResult = await nextStep(workflowRun);
+    expect(secondStepResult).toEqual(expect.objectContaining({
+      type: WORKFLOW_EVENTS.STEP_COMPLETE,
+      stepTitle: 'Second step',
+      stepId: expect.any(String),
+      patch: [{
+        op: 'add',
+        path: '/doubled',
+        value: 2
+      }]
+    }));
+
+    // Step Status Event
+    const stepStatusResult = await nextStep(workflowRun);
+    expect(stepStatusResult).toEqual(expect.objectContaining({
+      type: WORKFLOW_EVENTS.STEP_STATUS,
+      steps: [
+        expect.objectContaining({
+          title: 'First step',
+          status: STATUS.COMPLETE,
+          id: expect.any(String)
+        }),
+        expect.objectContaining({
+          title: 'Second step',
+          status: STATUS.COMPLETE,
+          id: expect.any(String)
+        })
+      ]
+    }));
+
+    // Check workflow completion
+    const completeResult = await nextStep(workflowRun);
+    expect(completeResult).toEqual(expect.objectContaining({
+      type: WORKFLOW_EVENTS.COMPLETE,
+      status: STATUS.COMPLETE,
+      workflowTitle: 'test workflow',
+      workflowDescription: undefined,
+    }));
+  });
+
+  it('should create a workflow with a name and description when passed an object', async () => {
+    const testWorkflow = workflow({
+      title: 'my named workflow',
+      description: 'some description'
+    });
+
+    const workflowRun = testWorkflow.run({ client: mockClient, fileStore: testFileStore });
+    const startResult = await workflowRun.next();
+    expect(startResult.value).toEqual(expect.objectContaining({
+      type: WORKFLOW_EVENTS.START,
+      status: STATUS.RUNNING,
+      workflowTitle: 'my named workflow',
+      workflowDescription: 'some description',
+      options: {}
+    }));
+  });
+
+  it('should create a workflow with just a name when passed a string', async () => {
+    const testWorkflow = workflow('simple workflow');
+    const workflowRun = testWorkflow.run({ client: mockClient, fileStore: testFileStore });
+    const startResult = await workflowRun.next();
+    expect(startResult.value).toEqual(expect.objectContaining({
+      type: WORKFLOW_EVENTS.START,
+      status: STATUS.RUNNING,
+      workflowTitle: 'simple workflow',
+      workflowDescription: undefined,
+      options: {}
+    }));
+  });
+
+  it('should allow overriding client per step', async () => {
+    const overrideClient = {
+      execute: jest.fn().mockResolvedValue({ override: true })
+    };
+
+    // Make sure that for the default prompt the default client returns a known value.
+    mockClient.execute.mockResolvedValueOnce({ override: false });
+
+    const testWorkflow = workflow('Client Override Test')
+      .prompt(
+        "Use default client",
+        {
+          template: () => "prompt1",
+          responseModel: {
+            schema: z.object({ override: z.boolean() }),
+            name: 'overrideResponse'
+          }
+        }
+      )
+      .prompt(
+        "Use override client",
+        {
+          template: () => "prompt2",
+          responseModel: {
+            schema: z.object({ override: z.boolean() }),
+            name: 'overrideResponse'
+          },
+          client: overrideClient
+        }
+      );
+
+    // Run the workflow and capture all events
+    const events = [];
+    let finalState = {};
+    for await (const event of testWorkflow.run({ client: mockClient, fileStore: testFileStore })) {
+      events.push(event);
+      if (event.type === WORKFLOW_EVENTS.STEP_COMPLETE) {
+        finalState = applyPatches(finalState, [event.patch]);
+      }
+    }
+
+    // Final state should include both responses
+    expect(finalState).toEqual({
+      overrideResponse: { override: true }
+    });
+
+    // Verify that each client was used correctly based on the supplied prompt configuration.
+    expect(mockClient.execute).toHaveBeenCalledWith("prompt1", expect.any(Object));
+    expect(overrideClient.execute).toHaveBeenCalledWith("prompt2", expect.any(Object));
+  });
+});
+
+describe('error handling', () => {
+  it('should handle errors in actions and maintain correct status', async () => {
+    const errorWorkflow = workflow('Error Workflow')
+      // Step 1: Normal step
+      .step("First step", () => ({
+        value: 1
+      }))
+      // Step 2: Error step
+      .step("Error step", () => {
+        if (true) {
+          throw new Error('Test error');
+        }
+        return {
+          value: 1
+        };
+      })
+      // Step 3: Should never execute
+      .step("Never reached", ({ state }) => ({
+        value: state.value + 1
+      }));
+
+    let errorEvent, finalStepStatusEvent;
+    try {
+      for await (const event of errorWorkflow.run({ client: mockClient, fileStore: testFileStore })) {
+        if (event.type === WORKFLOW_EVENTS.ERROR) {
+          errorEvent = event;
+        }
+        if (event.type === WORKFLOW_EVENTS.STEP_STATUS) {
+          finalStepStatusEvent = event;
+        }
+      }
+    } catch (error) {
+      // Error is expected to be thrown
+    }
+
+    // Verify final state
+    expect(errorEvent?.status).toBe(STATUS.ERROR);
+    expect(errorEvent?.error?.message).toBe('Test error');
+
+    // Verify steps status
+    if (!finalStepStatusEvent?.steps) {
+      throw new Error('Steps not found');
+    }
+    expect(finalStepStatusEvent.steps[0].status).toBe(STATUS.COMPLETE);
+    expect(finalStepStatusEvent.steps[1].status).toBe(STATUS.ERROR);
+    expect(finalStepStatusEvent.steps[2].status).toBe(STATUS.PENDING);
+
+    // Verify error event structure
+    expect(errorEvent).toEqual(expect.objectContaining({
+      type: WORKFLOW_EVENTS.ERROR,
+      status: STATUS.ERROR,
+      workflowTitle: 'Error Workflow',
+      error: expect.objectContaining({
+        name: expect.any(String),
+        message: expect.any(String)
+      }),
+    }));
+  });
+
+  it('should handle errors in nested workflows and propagate them up', async () => {
+    // Create an inner workflow that will throw an error
+    const innerWorkflow = workflow<{}, { inner?: boolean, value?: number }>('Failing Inner Workflow')
+      .step(
+        "Throw error",
+        (): { value: number } => {
+          throw new Error('Inner workflow error');
+        }
+      );
+
+    // Create outer workflow that uses the failing inner workflow
+    const outerWorkflow = workflow('Outer Workflow')
+      .step(
+        "First step",
+        () => ({ step: "first" })
+      )
+      .workflow(
+        "Run inner workflow",
+        innerWorkflow,
+        ({ state, workflowState }) => ({
+          ...state,
+          step: "second",
+          innerResult: workflowState.value
+        }),
+        () => ({ value: 5 })
+      );
+
+    const events: WorkflowEvent<any>[] = [];
+    let error: Error | undefined;
+    let mainWorkflowId: string | undefined;
+
+    try {
+      for await (const event of outerWorkflow.run({ client: mockClient, fileStore: testFileStore })) {
+        events.push(event);
+        if (event.type === WORKFLOW_EVENTS.START && !mainWorkflowId) {
+          mainWorkflowId = event.workflowRunId;
+        }
+      }
+    } catch (e) {
+      error = e as Error;
+    }
+
+    // Verify error was thrown
+    expect(error?.message).toBe('Inner workflow error');
+
+    // Verify event sequence including error
+    expect(events).toEqual([
+      expect.objectContaining({
+        type: WORKFLOW_EVENTS.START,
+        workflowTitle: 'Outer Workflow',
+        status: STATUS.RUNNING,
+        workflowRunId: mainWorkflowId
+      }),
+      expect.objectContaining({
+        type: WORKFLOW_EVENTS.STEP_STATUS,
+        steps: expect.any(Array)
+      }),
+      expect.objectContaining({
+        type: WORKFLOW_EVENTS.STEP_START,
+        status: STATUS.RUNNING,
+        stepTitle: 'First step'
+      }),
+      expect.objectContaining({
+        type: WORKFLOW_EVENTS.STEP_COMPLETE,
+        status: STATUS.RUNNING,
+        stepTitle: 'First step'
+      }),
+      expect.objectContaining({
+        type: WORKFLOW_EVENTS.STEP_STATUS,
+        steps: expect.any(Array)
+      }),
+      expect.objectContaining({
+        type: WORKFLOW_EVENTS.STEP_START,
+        status: STATUS.RUNNING,
+        stepTitle: 'Run inner workflow'
+      }),
+      expect.objectContaining({
+        type: WORKFLOW_EVENTS.START,
+        workflowTitle: 'Failing Inner Workflow',
+        status: STATUS.RUNNING,
+      }),
+      expect.objectContaining({
+        type: WORKFLOW_EVENTS.STEP_STATUS,
+        steps: expect.any(Array)
+      }),
+      expect.objectContaining({
+        type: WORKFLOW_EVENTS.STEP_START,
+        status: STATUS.RUNNING,
+        stepTitle: 'Throw error'
+      }),
+      expect.objectContaining({
+        type: WORKFLOW_EVENTS.ERROR,
+        workflowTitle: 'Failing Inner Workflow',
+        status: STATUS.ERROR,
+        error: expect.objectContaining({
+          name: expect.any(String),
+          message: expect.any(String)
+        }),
+      }),
+      expect.objectContaining({
+        type: WORKFLOW_EVENTS.STEP_STATUS,
+        steps: expect.arrayContaining([
+          expect.objectContaining({
+            title: 'Throw error',
+            status: STATUS.ERROR
+          })
+        ])
+      }),
+      expect.objectContaining({
+        type: WORKFLOW_EVENTS.ERROR,
+        workflowTitle: 'Outer Workflow',
+        status: STATUS.ERROR,
+        error: expect.objectContaining({
+          name: expect.any(String),
+          message: expect.any(String)
+        })
+      }),
+      expect.objectContaining({
+        type: WORKFLOW_EVENTS.STEP_STATUS,
+        steps: expect.arrayContaining([
+          expect.objectContaining({
+            title: 'Run inner workflow',
+            status: STATUS.ERROR
+          })
+        ])
+      })
+    ]);
+
+    // Find inner and outer error events by workflowRunId
+    const innerErrorEvent = events.find(e =>
+      e.type === WORKFLOW_EVENTS.ERROR &&
+      e.workflowRunId !== mainWorkflowId
+    ) as WorkflowErrorEvent<any>;
+
+    const outerErrorEvent = events.find(e =>
+      e.type === WORKFLOW_EVENTS.ERROR &&
+      e.workflowRunId === mainWorkflowId
+    ) as WorkflowErrorEvent<any>;
+
+    expect(innerErrorEvent.error).toEqual(expect.objectContaining({
+      message: 'Inner workflow error'
+    }));
+    expect(outerErrorEvent.error).toEqual(expect.objectContaining({
+      message: 'Inner workflow error'
+    }));
+  });
+});
+
+describe('step creation', () => {
+  it('should create a step that updates state', async () => {
+    const testWorkflow = workflow('Simple Workflow')
+      .step("Simple step", ({ state }) => ({
+        ...state,
+        count: 1,
+        message: 'Count is now 1'
+      }));
+
+    const events = [];
+    let finalState = {};
+    for await (const event of testWorkflow.run({ client: mockClient, fileStore: testFileStore })) {
+      events.push(event);
+      if (event.type === WORKFLOW_EVENTS.STEP_COMPLETE) {
+        finalState = applyPatches(finalState, event.patch);
+      }
+    }
+
+    // Skip checking events[0] (workflow:start)
+    // Skip checking events[1] (step:status)
+
+    // Verify the step start event
+    expect(events[2]).toEqual(expect.objectContaining({
+      type: WORKFLOW_EVENTS.STEP_START,
+      status: STATUS.RUNNING,
+      stepTitle: 'Simple step',
+      stepId: expect.any(String),
+      options: {}
+    }));
+
+    // Verify the step complete event
+    expect(events[3]).toEqual(expect.objectContaining({
+      type: WORKFLOW_EVENTS.STEP_COMPLETE,
+      status: STATUS.RUNNING,
+      stepTitle: 'Simple step',
+      stepId: expect.any(String),
+      patch: [{
+        op: 'add',
+        path: '/count',
+        value: 1
+      }, {
+        op: 'add',
+        path: '/message',
+        value: 'Count is now 1'
+      }],
+      options: {}
+    }));
+
+    expect(events[4]).toEqual(expect.objectContaining({
+      type: WORKFLOW_EVENTS.STEP_STATUS,
+      steps: [
+        expect.objectContaining({ title: 'Simple step', status: STATUS.COMPLETE, id: expect.any(String) })
+      ],
+      options: {}
+    }));
+
+    // Verify the workflow complete event
+    expect(events[5]).toEqual(expect.objectContaining({
+      type: WORKFLOW_EVENTS.COMPLETE,
+      status: STATUS.COMPLETE,
+      workflowTitle: 'Simple Workflow',
+      options: {}
+    }));
+
+    // Verify the final state
+    expect(finalState).toEqual({
+      count: 1,
+      message: 'Count is now 1'
+    });
+  });
+
+  it('should maintain immutable results between steps', async () => {
+    const testWorkflow = workflow('Immutable Steps Workflow')
+      .step("First step", () => ({
+        value: 1
+      }))
+      .step("Second step", ({ state }) => {
+        // Attempt to modify previous step's state
+        state.value = 99;
+        return {
+          value: 2
+        };
+      });
+
+    let finalState = {};
+    const patches = [];
+    for await (const event of testWorkflow.run({ client: mockClient, fileStore: testFileStore })) {
+      if (event.type === WORKFLOW_EVENTS.STEP_COMPLETE) {
+        patches.push(...event.patch);
+      }
+    }
+
+    // Apply all patches to the initial state
+    finalState = applyPatches(finalState, patches);
+
+    // Verify the final state
+    expect(finalState).toEqual({ value: 2 });
+  });
+});
+
+describe('workflow resumption', () => {
+  const mockClient = {
+    execute: jest.fn()
+  };
+
+  it('should resume workflow from the correct step when given initialCompletedSteps', async () => {
+    const executedSteps: string[] = [];
+    const threeStepWorkflow = workflow('Three Step Workflow')
+      .step("Step 1", ({ state }) => {
+        executedSteps.push("Step 1");
+        return { ...state, value: 2 };
+      })
+      .step("Step 2", ({ state }) => {
+        executedSteps.push("Step 2");
+        return { ...state, value: state.value + 10 };
+      })
+      .step("Step 3", ({ state }) => {
+        executedSteps.push("Step 3");
+        return { ...state, value: state.value * 3 };
+      });
+
+    // First run to get the first step completed with initial state
+    let initialCompletedSteps;
+    const initialState = { initialValue: true };
+    let firstStepState: State = initialState;
+
+    // Run workflow until we get the first step completed
+    for await (const event of threeStepWorkflow.run({
+      client: mockClient,
+      initialState,
+      fileStore: testFileStore
+    })) {
+      if (event.type === WORKFLOW_EVENTS.STEP_COMPLETE) {
+        firstStepState = applyPatches(firstStepState, [event.patch]);
+      }
+      if (event.type === WORKFLOW_EVENTS.STEP_STATUS && event.steps[0].status === STATUS.COMPLETE) {
+        initialCompletedSteps = event.steps;
+        break;  // Stop after first step
+      }
+    }
+
+    // Clear executed steps array
+    executedSteps.length = 0;
+
+    // Resume workflow with first step completed
+    let resumedState: State | undefined;
+    if (!initialCompletedSteps) throw new Error('Expected initialCompletedSteps');
+
+    for await (const event of threeStepWorkflow.run({
+      client: mockClient,
+      initialState,
+      initialCompletedSteps,
+      workflowRunId: 'test-run-id',
+      fileStore: testFileStore
+    })) {
+      if (event.type === WORKFLOW_EVENTS.RESTART) {
+        resumedState = event.initialState;
+      } else if (event.type === WORKFLOW_EVENTS.STEP_COMPLETE) {
+        resumedState = applyPatches(resumedState!, [event.patch]);
+      }
+    }
+
+    // Verify only steps 2 and 3 were executed
+    expect(executedSteps).toEqual(["Step 2", "Step 3"]);
+    expect(executedSteps).not.toContain("Step 1");
+
+    // Verify the final state after all steps complete
+    expect(resumedState).toEqual({
+      value: 36,
+      initialValue: true
+    });
+  });
+});
+
+describe('nested workflows', () => {
+  it('should execute nested workflows and yield all inner workflow events', async () => {
+    // Create an inner workflow that will be nested
+    const innerWorkflow = workflow<{}, { value: number }>('Inner Workflow')
+      .step(
+        "Double value",
+        ({ state }) => ({
+          inner: true,
+          value: state.value * 2
+        })
+      );
+
+    // Create outer workflow that uses the inner workflow
+    const outerWorkflow = workflow('Outer Workflow')
+      .step(
+        "Set prefix",
+        () => ({ prefix: "test-" })
+      )
+      .workflow(
+        "Run inner workflow",
+        innerWorkflow,
+        ({ state, workflowState }) => ({
+          ...state,
+          innerResult: workflowState.value
+        }),
+        () => ({ value: 5 })
+      );
+
+    const events: WorkflowEvent<any>[] = [];
+    for await (const event of outerWorkflow.run({ client: mockClient, fileStore: testFileStore })) {
+      events.push(event);
+    }
+
+    // Verify all events are yielded in correct order
+    expect(events.map(e => ({
+      type: e.type,
+      workflowTitle: 'workflowTitle' in e ? e.workflowTitle : undefined,
+      status: 'status' in e ? e.status : undefined,
+      stepTitle: 'stepTitle' in e ? e.stepTitle : undefined
+    }))).toEqual([
+      // Outer workflow start
+      {
+        type: WORKFLOW_EVENTS.START,
+        workflowTitle: 'Outer Workflow',
+        status: STATUS.RUNNING,
+        stepTitle: undefined
+      },
+      // Initial step status for outer workflow
+      {
+        type: WORKFLOW_EVENTS.STEP_STATUS,
+        workflowTitle: undefined,
+        status: undefined,
+        stepTitle: undefined
+      },
+      // First step of outer workflow
+      {
+        type: WORKFLOW_EVENTS.STEP_START,
+        workflowTitle: undefined,
+        status: STATUS.RUNNING,
+        stepTitle: 'Set prefix'
+      },
+      {
+        type: WORKFLOW_EVENTS.STEP_COMPLETE,
+        workflowTitle: undefined,
+        status: STATUS.RUNNING,
+        stepTitle: 'Set prefix'
+      },
+      {
+        type: WORKFLOW_EVENTS.STEP_STATUS,
+        workflowTitle: undefined,
+        status: undefined,
+        stepTitle: undefined
+      },
+      {
+        type: WORKFLOW_EVENTS.STEP_START,
+        workflowTitle: undefined,
+        status: STATUS.RUNNING,
+        stepTitle: 'Run inner workflow'
+      },
+      // Inner workflow start
+      {
+        type: WORKFLOW_EVENTS.START,
+        workflowTitle: 'Inner Workflow',
+        status: STATUS.RUNNING,
+        stepTitle: undefined
+      },
+      // Initial step status for inner workflow
+      {
+        type: WORKFLOW_EVENTS.STEP_STATUS,
+        workflowTitle: undefined,
+        status: undefined,
+        stepTitle: undefined
+      },
+      // Inner workflow step
+      {
+        type: WORKFLOW_EVENTS.STEP_START,
+        workflowTitle: undefined,
+        status: STATUS.RUNNING,
+        stepTitle: 'Double value'
+      },
+      {
+        type: WORKFLOW_EVENTS.STEP_COMPLETE,
+        workflowTitle: undefined,
+        status: STATUS.RUNNING,
+        stepTitle: 'Double value'
+      },
+      {
+        type: WORKFLOW_EVENTS.STEP_STATUS,
+        workflowTitle: undefined,
+        status: undefined,
+        stepTitle: undefined
+      },
+      {
+        type: WORKFLOW_EVENTS.COMPLETE,
+        workflowTitle: 'Inner Workflow',
+        status: STATUS.COMPLETE,
+        stepTitle: undefined
+      },
+      // Outer workflow nested step completion
+      {
+        type: WORKFLOW_EVENTS.STEP_COMPLETE,
+        workflowTitle: undefined,
+        status: STATUS.RUNNING,
+        stepTitle: 'Run inner workflow'
+      },
+      {
+        type: WORKFLOW_EVENTS.STEP_STATUS,
+        workflowTitle: undefined,
+        status: undefined,
+        stepTitle: undefined
+      },
+      // Outer workflow completion
+      {
+        type: WORKFLOW_EVENTS.COMPLETE,
+        workflowTitle: 'Outer Workflow',
+        status: STATUS.COMPLETE,
+        stepTitle: undefined
+      }
+    ]);
+
+    // Verify states are passed correctly
+    let innerState: State = { value: 5 };  // Match the initial state from the workflow
+    let outerState = {};
+
+    for (const event of events) {
+      if (event.type === WORKFLOW_EVENTS.STEP_COMPLETE) {
+        if (event.stepTitle === 'Double value') {
+          innerState = applyPatches(innerState, [event.patch]);
+        } else {
+          outerState = applyPatches(outerState, [event.patch]);
+        }
+      }
+    }
+
+    // Verify final states
+    expect(innerState).toEqual({
+      inner: true,
+      value: 10
+    });
+
+    expect(outerState).toEqual({
+      prefix: "test-",
+      innerResult: 10
+    });
+  });
+
+  it('should handle errors in nested workflows and propagate them up', async () => {
+    // Create an inner workflow that will throw an error
+    const innerWorkflow = workflow<{}, { inner: boolean, value: number }>('Failing Inner Workflow')
+      .step(
+        "Throw error",
+        (): { value: number } => {
+          throw new Error('Inner workflow error');
+        }
+      );
+
+    // Create outer workflow that uses the failing inner workflow
+    const outerWorkflow = workflow('Outer Workflow')
+      .step(
+        "First step",
+        () => ({ step: "first" })
+      )
+      .workflow(
+        "Run inner workflow",
+        innerWorkflow,
+        ({ state, workflowState }) => ({
+          ...state,
+          step: "second",
+          innerResult: workflowState.value
+        }),
+        () => ({ value: 5 })
+      );
+
+    const events: WorkflowEvent<any>[] = [];
+    let error: Error | undefined;
+    let mainWorkflowId: string | undefined;
+
+    try {
+      for await (const event of outerWorkflow.run({ client: mockClient, fileStore: testFileStore })) {
+        events.push(event);
+        if (event.type === WORKFLOW_EVENTS.START && !mainWorkflowId) {
+          mainWorkflowId = event.workflowRunId;
+        }
+      }
+    } catch (e) {
+      error = e as Error;
+    }
+
+    // Verify error was thrown
+    expect(error?.message).toBe('Inner workflow error');
+
+    // Verify event sequence including error
+    expect(events).toEqual([
+      expect.objectContaining({
+        type: WORKFLOW_EVENTS.START,
+        workflowTitle: 'Outer Workflow',
+        status: STATUS.RUNNING,
+        workflowRunId: mainWorkflowId
+      }),
+      expect.objectContaining({
+        type: WORKFLOW_EVENTS.STEP_STATUS,
+        steps: expect.any(Array)
+      }),
+      expect.objectContaining({
+        type: WORKFLOW_EVENTS.STEP_START,
+        status: STATUS.RUNNING,
+        stepTitle: 'First step'
+      }),
+      expect.objectContaining({
+        type: WORKFLOW_EVENTS.STEP_COMPLETE,
+        status: STATUS.RUNNING,
+        stepTitle: 'First step'
+      }),
+      expect.objectContaining({
+        type: WORKFLOW_EVENTS.STEP_STATUS,
+        steps: expect.any(Array)
+      }),
+      expect.objectContaining({
+        type: WORKFLOW_EVENTS.STEP_START,
+        status: STATUS.RUNNING,
+        stepTitle: 'Run inner workflow'
+      }),
+      expect.objectContaining({
+        type: WORKFLOW_EVENTS.START,
+        workflowTitle: 'Failing Inner Workflow',
+        status: STATUS.RUNNING,
+      }),
+      expect.objectContaining({
+        type: WORKFLOW_EVENTS.STEP_STATUS,
+        steps: expect.any(Array)
+      }),
+      expect.objectContaining({
+        type: WORKFLOW_EVENTS.STEP_START,
+        status: STATUS.RUNNING,
+        stepTitle: 'Throw error'
+      }),
+      expect.objectContaining({
+        type: WORKFLOW_EVENTS.ERROR,
+        workflowTitle: 'Failing Inner Workflow',
+        status: STATUS.ERROR,
+        error: expect.objectContaining({
+          name: expect.any(String),
+          message: expect.any(String)
+        }),
+      }),
+      expect.objectContaining({
+        type: WORKFLOW_EVENTS.STEP_STATUS,
+        steps: expect.arrayContaining([
+          expect.objectContaining({
+            title: 'Throw error',
+            status: STATUS.ERROR
+          })
+        ])
+      }),
+      expect.objectContaining({
+        type: WORKFLOW_EVENTS.ERROR,
+        workflowTitle: 'Outer Workflow',
+        status: STATUS.ERROR,
+        error: expect.objectContaining({
+          name: expect.any(String),
+          message: expect.any(String)
+        })
+      }),
+      expect.objectContaining({
+        type: WORKFLOW_EVENTS.STEP_STATUS,
+        steps: expect.arrayContaining([
+          expect.objectContaining({
+            title: 'Run inner workflow',
+            status: STATUS.ERROR
+          })
+        ])
+      })
+    ]);
+
+    // Find inner and outer error events by workflowRunId
+    const innerErrorEvent = events.find(e =>
+      e.type === WORKFLOW_EVENTS.ERROR &&
+      e.workflowRunId !== mainWorkflowId
+    ) as WorkflowErrorEvent<any>;
+
+    const outerErrorEvent = events.find(e =>
+      e.type === WORKFLOW_EVENTS.ERROR &&
+      e.workflowRunId === mainWorkflowId
+    ) as WorkflowErrorEvent<any>;
+
+    expect(innerErrorEvent.error).toEqual(expect.objectContaining({
+      message: 'Inner workflow error'
+    }));
+    expect(outerErrorEvent.error).toEqual(expect.objectContaining({
+      message: 'Inner workflow error'
+    }));
+  });
+
+  it('should include patches in step status events for inner workflow steps', async () => {
+    interface InnerState extends State {
+      value: number;
+    }
+
+    interface OuterState extends State {
+      value: number;
+      result?: number;
+    }
+
+    // Create an inner workflow that modifies state
+    const innerWorkflow = workflow<{}, InnerState>('Inner Workflow')
+      .step("Double value", ({ state }) => ({
+        ...state,
+        value: state.value * 2
+      }));
+
+    // Create outer workflow that uses the inner workflow
+    const outerWorkflow = workflow<{}, OuterState>('Outer Workflow')
+      .step("Set initial", () => ({
+        value: 5
+      }))
+      .workflow(
+        "Run inner workflow",
+        innerWorkflow,
+        ({ state, workflowState }) => ({
+          ...state,
+          result: workflowState.value
+        }),
+        (state) => ({ value: state.value })
+      );
+
+    // Run workflow and collect step status events
+    let finalStepStatus;
+    for await (const event of outerWorkflow.run({ client: mockClient, fileStore: testFileStore })) {
+      if (event.type === WORKFLOW_EVENTS.STEP_STATUS) {
+        finalStepStatus = event;
+      }
+    }
+
+    // Verify step status contains patches for all steps including the inner workflow step
+    expect(finalStepStatus?.steps).toEqual([
+      expect.objectContaining({
+        title: 'Set initial',
+        status: STATUS.COMPLETE,
+        patch: [{
+          op: 'add',
+          path: '/value',
+          value: 5
+        }]
+      }),
+      expect.objectContaining({
+        title: 'Run inner workflow',
+        status: STATUS.COMPLETE,
+        patch: [{
+          op: 'add',
+          path: '/result',
+          value: 10
+        }]
+      })
+    ]);
+  });
+});
+
+describe('workflow options', () => {
+  it('should pass options through to workflow events', async () => {
+    const testWorkflow = workflow<{ testOption: string }>('Options Workflow')
+      .step(
+        "Simple step",
+        ({ state, options }) => ({
+          value: 1,
+          passedOption: options.testOption
+        })
+      );
+
+    const workflowOptions = {
+      testOption: 'test-value'
+    };
+
+    let finalEvent, finalStepStatus;
+    for await (const event of testWorkflow.run({
+      client: mockClient,
+      options: workflowOptions,
+      fileStore: testFileStore
+    })) {
+      if (event.type === WORKFLOW_EVENTS.STEP_STATUS) {
+        finalStepStatus = event;
+      } else {
+        finalEvent = event;
+      }
+    }
+
+    expect(finalEvent).toEqual(expect.objectContaining({
+      type: WORKFLOW_EVENTS.COMPLETE,
+      status: STATUS.COMPLETE,
+      workflowTitle: 'Options Workflow',
+      workflowDescription: undefined,
+      options: workflowOptions,
+    }))
+    expect(finalStepStatus).toEqual(expect.objectContaining({
+      type: WORKFLOW_EVENTS.STEP_STATUS,
+      steps: [
+        expect.objectContaining({
+          title: 'Simple step',
+          patch: expect.any(Object),
+          status: STATUS.COMPLETE,
+        })
+      ],
+      options: workflowOptions,
+    }));
+  });
+
+  it('should provide empty object as default options', async () => {
+    const testWorkflow = workflow('Default Options Workflow')
+      .step(
+        "Simple step",
+        ({ options }) => ({
+          hasOptions: Object.keys(options).length === 0
+        })
+      );
+
+    const workflowRun = testWorkflow.run({ client: mockClient, fileStore: testFileStore });
+
+    // Skip start event
+    await workflowRun.next();
+
+    // Skip initial step status event
+    await workflowRun.next();
+
+    // Check step start
+    const stepStartResult = await workflowRun.next();
+    expect(stepStartResult.value).toEqual(expect.objectContaining({
+      options: {},
+      type: WORKFLOW_EVENTS.STEP_START
+    }));
+
+    // Check step completion
+    const stepResult = await workflowRun.next();
+    expect(stepResult.value).toEqual(expect.objectContaining({
+      type: WORKFLOW_EVENTS.STEP_COMPLETE,
+      stepTitle: 'Simple step',
+      options: {},
+    }));
+  });
+});
+
+describe('type inference', () => {
+  it('should correctly infer complex workflow state types', async () => {
+    // Create an inner workflow that uses the shared options type
+    const innerWorkflow = workflow<{ features: string[] }>('Inner Type Test')
+      .step(
+        "Process features",
+        ({ options }) => ({
+          processedValue: options.features.includes('fast') ? 100 : 42,
+          featureCount: options.features.length
+        })
+      );
+
+    // Create a complex workflow using multiple features
+    const complexWorkflow = workflow<{ features: string[] }>('Complex Type Test')
+      .step(
+        "First step",
+        ({ options }) => ({
+          initialFeatures: options.features,
+          value: 42
+        })
+      )
+      .workflow(
+        "Nested workflow",
+        innerWorkflow,
+        ({ state, workflowState }) => ({
+          ...state,
+          processedValue: workflowState.processedValue,
+          totalFeatures: workflowState.featureCount
+        }),
+        () => ({
+          processedValue: 0,
+          featureCount: 0
+        })
+      )
+      .step(
+        "Final step",
+        ({ state }) => ({
+          ...state,
+          completed: true
+        })
+      );
+
+    // Type test setup
+    type ExpectedState = {
+      initialFeatures: string[];
+      value: number;
+      processedValue: number;
+      totalFeatures: number;
+      completed: true;
+    };
+
+    type ActualState = Parameters<
+      Parameters<(typeof complexWorkflow)['step']>[1]
+    >[0]['state'];
+
+    type TypeTest = AssertEquals<ActualState, ExpectedState>;
+    const _typeAssert: TypeTest = true;
+
+    // Collect all events
+    const events = [];
+    let finalStepStatus, finalState = {};
+    let mainWorkflowId: string | undefined;
+
+    for await (const event of complexWorkflow.run({
+      client: mockClient,
+      options: { features: ['fast', 'secure'] },
+      fileStore: testFileStore
+    })) {
+      events.push(event);
+
+      // Capture the main workflow's ID from its start event
+      if (event.type === WORKFLOW_EVENTS.START && !mainWorkflowId) {
+        mainWorkflowId = event.workflowRunId;
+      }
+
+      if (event.type === WORKFLOW_EVENTS.STEP_STATUS) {
+        finalStepStatus = event;
+      } else if (
+        event.type === WORKFLOW_EVENTS.STEP_COMPLETE &&
+        event.workflowRunId === mainWorkflowId // Only process events from main workflow
+      ) {
+        finalState = applyPatches(finalState, [event.patch]);
+      }
+    }
+
+    // Verify workflow start event
+    expect(events[0]).toEqual(expect.objectContaining({
+      type: WORKFLOW_EVENTS.START,
+      status: STATUS.RUNNING,
+      workflowTitle: 'Complex Type Test',
+      workflowDescription: undefined,
+      options: { features: ['fast', 'secure'] },
+      workflowRunId: mainWorkflowId
+    }));
+
+    // Verify inner workflow events are included
+    const innerStartEvent = events.find(e =>
+      e.type === WORKFLOW_EVENTS.START &&
+      'workflowRunId' in e &&
+      e.workflowRunId !== mainWorkflowId
+    );
+    expect(innerStartEvent).toEqual(expect.objectContaining({
+      type: WORKFLOW_EVENTS.START,
+      status: STATUS.RUNNING,
+      workflowTitle: 'Inner Type Test',
+      options: { features: ['fast', 'secure'] }
+    }));
+
+    // Verify the final step status
+    if (!finalStepStatus) throw new Error('Expected final step status event');
+    const lastStep = finalStepStatus.steps[finalStepStatus.steps.length - 1];
+    expect(lastStep.status).toBe(STATUS.COMPLETE);
+    expect(lastStep.title).toBe('Final step');
+
+    expect(finalState).toEqual({
+      initialFeatures: ['fast', 'secure'],
+      value: 42,
+      processedValue: 100,
+      totalFeatures: 2,
+      completed: true
+    });
+  });
+
+  it('should correctly infer workflow reducer state types', async () => {
+    // Create an inner workflow with a specific state shape
+    const innerWorkflow = workflow('Inner State Test')
+      .step(
+        "Inner step",
+        () => ({
+          innerValue: 42,
+          metadata: { processed: true }
+        })
+      );
+
+    // Create outer workflow to test reducer type inference
+    const outerWorkflow = workflow('Outer State Test')
+      .step(
+        "First step",
+        () => ({
+          outerValue: 100,
+          status: 'ready'
+        })
+      )
+      .workflow(
+        "Nested workflow",
+        innerWorkflow,
+        ({ state, workflowState }) => {
+          // Type assertion for outer state
+          type ExpectedOuterState = {
+            outerValue: number;
+            status: string;
+          };
+          type ActualOuterState = typeof state;
+          type OuterStateTest = AssertEquals<
+            ActualOuterState,
+            ExpectedOuterState
+          >;
+          const _outerAssert: OuterStateTest = true;
+
+          // Type assertion for inner workflow state
+          type ExpectedInnerState = {
+            innerValue: number;
+            metadata: { processed: true };
+          };
+          type ActualInnerState = typeof workflowState;
+          type InnerStateTest = AssertEquals<
+            ActualInnerState,
+            ExpectedInnerState
+          >;
+          const _innerAssert: InnerStateTest = true;
+
+          return {
+            ...state,
+            innerResult: workflowState.innerValue,
+            processed: workflowState.metadata.processed
+          };
+        },
+        () => ({} as { innerValue: number; metadata: { processed: boolean } })
+      );
+
+    // Run the workflow to verify runtime behavior
+    let finalState = {};
+    let mainWorkflowId: string | undefined;
+
+    for await (const event of outerWorkflow.run({ client: mockClient, fileStore: testFileStore })) {
+      if (event.type === WORKFLOW_EVENTS.START && !mainWorkflowId) {
+        mainWorkflowId = event.workflowRunId;
+      }
+      if (event.type === WORKFLOW_EVENTS.STEP_COMPLETE && event.workflowRunId === mainWorkflowId) {
+        finalState = applyPatches(finalState, [event.patch]);
+      }
+    }
+
+    expect(finalState).toEqual({
+      outerValue: 100,
+      status: 'ready',
+      innerResult: 42,
+      processed: true
+    });
+  });
+
+  it('should correctly infer step action state types', async () => {
+    const testWorkflow = workflow('Action State Test')
+      .step(
+        "First step",
+        () => ({
+          count: 1,
+          metadata: { created: new Date().toISOString() }
+        })
+      )
+      .step(
+        "Second step",
+        ({ state }) => {
+          // Type assertion for action state
+          type ExpectedState = {
+            count: number;
+            metadata: { created: string };
+          };
+          type ActualState = typeof state;
+          type StateTest = AssertEquals<
+            ActualState,
+            ExpectedState
+          >;
+          const _stateAssert: StateTest = true;
+
+          return {
+            ...state,
+            count: state.count + 1,
+            metadata: {
+              ...state.metadata,
+              updated: new Date().toISOString()
+            }
+          };
+        }
+      );
+
+    // Run the workflow to verify runtime behavior
+    let finalState = {};
+    let mainWorkflowId: string | undefined;
+
+    for await (const event of testWorkflow.run({ client: mockClient, fileStore: testFileStore })) {
+      if (event.type === WORKFLOW_EVENTS.START && !mainWorkflowId) {
+        mainWorkflowId = event.workflowRunId;
+      }
+      if (event.type === WORKFLOW_EVENTS.STEP_COMPLETE && event.workflowRunId === mainWorkflowId) {
+        finalState = applyPatches(finalState, [event.patch]);
+      }
+    }
+
+    expect(finalState).toMatchObject({
+      count: 2,
+      metadata: {
+        created: expect.any(String),
+        updated: expect.any(String)
+      }
+    });
+  });
+
+  it('should correctly infer prompt response types in subsequent steps', async () => {
+    const testWorkflow = workflow('Prompt Type Test')
+      .prompt(
+        "Get user info",
+        {
+          template: () => "What is the user's info?",
+          responseModel: {
+            schema: z.object({ name: z.string(), age: z.number() }),
+            name: "userInfo" as const  // Must be const or type inference breaks
+          }
+        }
+      )
+      .step(
+        "Use response",
+        ({ state }) => {
+          // Type assertion to verify state includes userInfo
+          type ExpectedState = {
+            userInfo: {
+              name: string;
+              age: number;
+            }
+          };
+          type ActualState = typeof state;
+          type StateTest = AssertEquals<ActualState, ExpectedState>;
+          const _stateAssert: StateTest = true;
+
+          return {
+            ...state,
+            greeting: `Hello ${state.userInfo.name}, you are ${state.userInfo.age} years old`
+          };
+        }
+      );
+
+    // Mock the client response
+    mockClient.execute.mockResolvedValueOnce({
+      name: "Test User",
+      age: 30
+    });
+
+    // Run workflow and collect final state
+    let finalState = {};
+    for await (const event of testWorkflow.run({ client: mockClient, fileStore: testFileStore })) {
+      if (event.type === WORKFLOW_EVENTS.STEP_COMPLETE) {
+        finalState = applyPatches(finalState, [event.patch]);
+      }
+    }
+
+    // Verify the workflow executed correctly
+    expect(finalState).toEqual({
+      userInfo: {
+        name: "Test User",
+        age: 30
+      },
+      greeting: "Hello Test User, you are 30 years old"
+    });
+  });
+
+  it('should correctly handle prompt reduce function', async () => {
+    const testWorkflow = workflow('Prompt Reduce Test')
+      .prompt(
+        "Get numbers",
+        {
+          template: () => "Give me some numbers",
+          responseModel: {
+            schema: z.object({ numbers: z.array(z.number()) }),
+            name: "numbersResponse" as const
+          }
+        },
+        ({ state, response, options }) => ({
+          ...state,
+          numbersResponse: response,  // Include the response explicitly
+          sum: response.numbers.reduce((a, b) => a + b, 0),
+          count: response.numbers.length
+        })
+      );
+
+    // Mock the client response
+    mockClient.execute.mockResolvedValueOnce({
+      numbers: [1, 2, 3, 4, 5]
+    });
+
+    // Run workflow and collect final state
+    let finalState = {};
+    for await (const event of testWorkflow.run({ client: mockClient, fileStore: testFileStore })) {
+      if (event.type === WORKFLOW_EVENTS.STEP_COMPLETE) {
+        finalState = applyPatches(finalState, [event.patch]);
+      }
+    }
+
+    // Verify the workflow executed correctly with reduced state
+    expect(finalState).toEqual({
+      numbersResponse: {
+        numbers: [1, 2, 3, 4, 5]
+      },
+      sum: 15,
+      count: 5
+    });
+
+    // Verify type inference works correctly
+    type ExpectedState = {
+      numbersResponse: {
+        numbers: number[];
+      };
+      sum: number;
+      count: number;
+    };
+
+    type ActualState = Parameters<
+      Parameters<(typeof testWorkflow)['step']>[1]
+    >[0]['state'];
+
+    type TypeTest = AssertEquals<ActualState, ExpectedState>;
+    const _typeAssert: TypeTest = true;
+  });
+});