@pikku/core 0.12.37 → 0.12.38

package/src/wirings/oauth2/oauth2-client.test.ts

@@ -1,4 +1,6 @@
-import { describe, test, afterEach, mock } from 'node:test'
+import { describe, test, afterEach } from 'node:test'
+
+const mockFn = <T extends (...args: any[]) => any>(fn: T): T => fn
 import * as assert from 'node:assert/strict'
 import { OAuth2Client } from './oauth2-client.js'
 import type { OAuth2Token, OAuth2AppCredential } from './oauth2.types.js'
@@ -94,7 +96,7 @@ describe('OAuth2Client', () => {
         APP_CREDS: defaultAppCredential,
       })
 
-      globalThis.fetch = mock.fn(async () =>
+      globalThis.fetch = mockFn(async () =>
         mockFetchResponse({
           access_token: 'new-access-token',
           refresh_token: 'new-refresh-token',
@@ -141,7 +143,7 @@ describe('OAuth2Client', () => {
         APP_CREDS: defaultAppCredential,
       })
 
-      globalThis.fetch = mock.fn(async () =>
+      globalThis.fetch = mockFn(async () =>
         mockFetchResponse({
           access_token: 'refreshed-token',
           expires_in: 3600,
@@ -183,7 +185,7 @@ describe('OAuth2Client', () => {
         APP_CREDS: defaultAppCredential,
       })
 
-      globalThis.fetch = mock.fn(async () =>
+      globalThis.fetch = mockFn(async () =>
         mockFetchResponse({
           access_token: 'refreshed-due-to-buffer',
           expires_in: 3600,
@@ -215,7 +217,7 @@ describe('OAuth2Client', () => {
 
       let capturedRequest: { url: string; options: RequestInit } | null = null
 
-      globalThis.fetch = mock.fn(
+      globalThis.fetch = mockFn(
         async (url: RequestInfo | URL, options?: RequestInit) => {
           capturedRequest = { url: url.toString(), options: options! }
           return mockFetchResponse({
@@ -259,7 +261,7 @@ describe('OAuth2Client', () => {
       })
 
       let fetchCallCount = 0
-      globalThis.fetch = mock.fn(async () => {
+      globalThis.fetch = mockFn(async () => {
         fetchCallCount++
         return mockFetchResponse({
           access_token: 'new-cached-token',
@@ -293,7 +295,7 @@ describe('OAuth2Client', () => {
         APP_CREDS: defaultAppCredential,
       })
 
-      globalThis.fetch = mock.fn(async () =>
+      globalThis.fetch = mockFn(async () =>
         mockFetchResponse({ error: 'invalid_grant' }, 400, false)
       )
 
@@ -339,7 +341,7 @@ describe('OAuth2Client', () => {
         APP_CREDS: defaultAppCredential,
       })
 
-      globalThis.fetch = mock.fn(async () =>
+      globalThis.fetch = mockFn(async () =>
         mockFetchResponse({
           access_token: 'new-persisted-token',
           refresh_token: 'new-refresh-token',
@@ -374,7 +376,7 @@ describe('OAuth2Client', () => {
       })
 
       let fetchCallCount = 0
-      globalThis.fetch = mock.fn(async () => {
+      globalThis.fetch = mockFn(async () => {
         fetchCallCount++
         // Simulate network delay
         await new Promise((resolve) => setTimeout(resolve, 50))
@@ -417,7 +419,7 @@ describe('OAuth2Client', () => {
       })
 
       // Response doesn't include refresh_token
-      globalThis.fetch = mock.fn(async () =>
+      globalThis.fetch = mockFn(async () =>
         mockFetchResponse({
           access_token: 'new-token',
           expires_in: 3600,
@@ -453,7 +455,7 @@ describe('OAuth2Client', () => {
 
       let capturedHeaders: Record<string, string> | null = null
 
-      globalThis.fetch = mock.fn(
+      globalThis.fetch = mockFn(
         async (_url: RequestInfo | URL, options?: RequestInit) => {
           capturedHeaders = options?.headers as Record<string, string>
           return mockFetchResponse({ data: 'test' })
@@ -482,7 +484,7 @@ describe('OAuth2Client', () => {
       })
 
       let requestCount = 0
-      globalThis.fetch = mock.fn(
+      globalThis.fetch = mockFn(
         async (url: RequestInfo | URL, options?: RequestInit) => {
           requestCount++
           const urlStr = url.toString()
@@ -529,7 +531,7 @@ describe('OAuth2Client', () => {
       })
 
       let apiRequestCount = 0
-      globalThis.fetch = mock.fn(async (url: RequestInfo | URL) => {
+      globalThis.fetch = mockFn(async (url: RequestInfo | URL) => {
         const urlStr = url.toString()
 
         if (urlStr === 'https://example.com/oauth/token') {
@@ -565,7 +567,7 @@ describe('OAuth2Client', () => {
         APP_CREDS: defaultAppCredential,
       })
 
-      globalThis.fetch = mock.fn(async () =>
+      globalThis.fetch = mockFn(async () =>
         mockFetchResponse({ error: 'forbidden' }, 403, false)
       )
 
@@ -589,7 +591,7 @@ describe('OAuth2Client', () => {
 
       let capturedHeaders: Record<string, string> | null = null
 
-      globalThis.fetch = mock.fn(
+      globalThis.fetch = mockFn(
         async (_url: RequestInfo | URL, options?: RequestInit) => {
           capturedHeaders = options?.headers as Record<string, string>
           return mockFetchResponse({ data: 'test' })
@@ -704,7 +706,7 @@ describe('OAuth2Client', () => {
 
       let capturedRequest: { url: string; options: RequestInit } | null = null
 
-      globalThis.fetch = mock.fn(
+      globalThis.fetch = mockFn(
         async (url: RequestInfo | URL, options?: RequestInit) => {
           capturedRequest = { url: url.toString(), options: options! }
           return mockFetchResponse({
@@ -738,7 +740,7 @@ describe('OAuth2Client', () => {
       })
 
       let fetchCallCount = 0
-      globalThis.fetch = mock.fn(async () => {
+      globalThis.fetch = mockFn(async () => {
         fetchCallCount++
         return mockFetchResponse({
           access_token: 'new-token',
@@ -767,7 +769,7 @@ describe('OAuth2Client', () => {
         APP_CREDS: defaultAppCredential,
       })
 
-      globalThis.fetch = mock.fn(async () =>
+      globalThis.fetch = mockFn(async () =>
         mockFetchResponse({ error: 'invalid_code' }, 400, false)
       )
 
@@ -785,7 +787,7 @@ describe('OAuth2Client', () => {
         APP_CREDS: defaultAppCredential,
       })
 
-      globalThis.fetch = mock.fn(async () =>
+      globalThis.fetch = mockFn(async () =>
         mockFetchResponse({
           access_token: 'token-only',
           // No refresh_token, expires_in, or scope
@@ -813,7 +815,7 @@ describe('OAuth2Client', () => {
       })
 
       // Response without access_token
-      globalThis.fetch = mock.fn(async () =>
+      globalThis.fetch = mockFn(async () =>
         mockFetchResponse({
           refresh_token: 'refresh-only',
           expires_in: 3600,
@@ -835,7 +837,7 @@ describe('OAuth2Client', () => {
       })
 
       // Response with non-string access_token
-      globalThis.fetch = mock.fn(async () =>
+      globalThis.fetch = mockFn(async () =>
         mockFetchResponse({
           access_token: 12345, // Number instead of string
           expires_in: 3600,
@@ -865,7 +867,7 @@ describe('OAuth2Client', () => {
       })
 
       // Error response with sensitive info
-      globalThis.fetch = mock.fn(async () =>
+      globalThis.fetch = mockFn(async () =>
         mockFetchResponse(
           {
             error: 'invalid_grant',
@@ -910,7 +912,7 @@ describe('OAuth2Client', () => {
       // Instead, we verify that the signal is being passed
       // by checking that an abort signal is present in the fetch call
       let signalPassed = false
-      globalThis.fetch = mock.fn(
+      globalThis.fetch = mockFn(
         async (_url: RequestInfo | URL, options?: RequestInit) => {
           signalPassed = options?.signal instanceof AbortSignal
           return mockFetchResponse({

package/src/wirings/workflow/dsl/workflow-dsl.types.ts

@@ -295,10 +295,28 @@ export type WorkflowStepMeta =
 export interface WorkflowStepWire {
   /** The workflow run ID */
   runId: string
-  /** The unique step ID */
+  /**
+   * The step row ID. Whether it stays the same or is minted fresh per attempt is
+   * STORE-SPECIFIC (in-memory mints a new one each attempt; the SQL store reuses
+   * the row) — do NOT use it as a dedupe key. Use `invocationId`.
+   */
   stepId: string
+  /**
+   * Stable identity of this step invocation — the idempotency / dedupe key.
+   * Identical across every retry of the same call (derived from runId + step
+   * name) regardless of storage backend, so a step can `ON CONFLICT (invocationId)`
+   * or pass it as an external idempotency key and have retries collapse onto the
+   * first attempt.
+   */
+  invocationId: string
   /** Current attempt number (1-indexed, increments on retry) */
   attemptCount: number
+  /**
+   * Invocation ID of the predecessor step this one was reached from (the walked
+   * transition/edge). Undefined for entry steps. Lets a step know its origin —
+   * e.g. in a cyclic graph `a → b → a → c`, the second `a` carries `b`'s id.
+   */
+  fromInvocationId?: string
 }
 
 /**

package/src/wirings/workflow/graph/graph-runner.test.ts

@@ -10,6 +10,7 @@ import {
 import type { WorkflowRuntimeMeta } from '../workflow.types.js'
 import { pikkuState } from '../../../pikku-state.js'
 import { RPCNotFoundError } from '../../rpc/rpc-runner.js'
+import { DEFAULT_STEP_RETRIES } from '../pikku-workflow-service.js'
 
 describe('graph-runner bugs', () => {
   test('continueGraph should NOT mark workflow completed while nodes are still running', async () => {
@@ -240,6 +241,84 @@ describe('graph-runner bugs', () => {
     assert.deepEqual(queuedNodes, ['c'])
   })
 
+  test('continueGraph revisits a cyclic node and records the walked path via fromStepName', async () => {
+    const ws = new InMemoryWorkflowService()
+    const queued: Array<{ stepName: string; fromStepName?: string }> = []
+
+    pikkuState(null, 'package', 'singletonServices', {
+      queueService: {
+        add: async (_queueName: string, data: any) => {
+          if (data?.stepName) {
+            queued.push({
+              stepName: data.stepName,
+              fromStepName: data.fromStepName,
+            })
+          }
+        },
+      },
+    } as any)
+
+    // start → a, where a loops back through b once, then exits to c:
+    //   start → a --retry--> b → a --done--> c
+    const meta: WorkflowRuntimeMeta = {
+      name: 'testCyclicGraph',
+      pikkuFuncId: 'testCyclicGraph',
+      source: 'graph',
+      entryNodeIds: ['start'],
+      graphHash: 'cyclic-hash',
+      nodes: {
+        start: { nodeId: 'start', rpcName: 'doStart', next: 'a' },
+        a: { nodeId: 'a', rpcName: 'doA', next: { retry: 'b', done: 'c' } },
+        b: { nodeId: 'b', rpcName: 'doB', next: 'a' },
+        c: { nodeId: 'c', rpcName: 'doC' },
+      },
+    }
+
+    const runId = await ws.createRun('testCyclicGraph', {}, false, 'cyclic-hash', {
+      type: 'test',
+    })
+
+    // Succeed a queued step (taking an optional branch), then advance the graph.
+    const advance = async (stepName: string, branch?: string) => {
+      const step = await ws.getStepState(runId, stepName)
+      await ws.setStepRunning(step.stepId)
+      if (branch) await ws.setBranchTaken(step.stepId, branch)
+      await ws.setStepResult(step.stepId, { ok: true })
+      await continueGraph(ws, runId, 'testCyclicGraph', meta)
+    }
+
+    await continueGraph(ws, runId, 'testCyclicGraph', meta) // fire entry
+    await advance('start')
+    await advance('a', 'retry') // a → b (b reaches a, but first visit ⇒ bare 'b')
+    await advance('b') // b → a revisit ⇒ a#1
+    await advance('a#1', 'done') // a#1 → c (forward edge, terminal)
+    await advance('c')
+
+    // Each step records the predecessor it was reached from; the cyclic
+    // revisit is a fresh ordinal instance (a#1) with its own provenance.
+    assert.deepEqual(queued, [
+      { stepName: 'start', fromStepName: undefined },
+      { stepName: 'a', fromStepName: 'start' },
+      { stepName: 'b', fromStepName: 'a' },
+      { stepName: 'a#1', fromStepName: 'b' },
+      { stepName: 'c', fromStepName: 'a#1' },
+    ])
+
+    const run = await ws.getRun(runId)
+    assert.equal(run?.status, 'completed')
+
+    // Reconstruct the walked path purely from the fromStepName chain.
+    const instances = await ws.getStepInstances(runId)
+    const from = new Map(instances.map((i) => [i.stepName, i.fromStepName]))
+    const path: string[] = []
+    let cursor: string | undefined = 'c'
+    while (cursor) {
+      path.unshift(cursor)
+      cursor = from.get(cursor) ?? undefined
+    }
+    assert.deepEqual(path, ['start', 'a', 'b', 'a#1', 'c'])
+  })
+
   test('inline graph should execute converging next node only once', async () => {
     const ws = new InMemoryWorkflowService()
     let cCalls = 0
@@ -618,9 +697,14 @@ describe('graph-runner bugs', () => {
     const cJob = enqueued.find((e) => e.data?.stepName === 'c')
     assert.ok(cJob, 'node c should have been enqueued')
     assert.equal(
-      cJob!.options,
-      undefined,
-      'no retries → no queue options (preserves prior queue defaults)'
+      cJob!.options?.attempts,
+      DEFAULT_STEP_RETRIES + 1,
+      'no retries → workflow default (5) + 1 attempt; queue never decides retries'
+    )
+    assert.equal(
+      cJob!.options?.backoff,
+      'exponential',
+      'default retries get exponential backoff so they ride out transient outages'
     )
   })
 })

package/src/wirings/workflow/graph/graph-runner.ts

@@ -2,6 +2,7 @@ import {
   type PikkuWorkflowService,
   WorkflowAsyncException,
   WorkflowSuspendedException,
+  DEFAULT_STEP_RETRIES,
 } from '../pikku-workflow-service.js'
 import type { GraphWireState, PikkuGraphWire } from './workflow-graph.types.js'
 import { pikkuState, getSingletonServices } from '../../../pikku-state.js'
@@ -28,6 +29,13 @@ function buildTemplateRegex(nodeId: string): RegExp | null {
   return new RegExp(`^${escaped}$`)
 }
 
+/** Strip a trailing revisit ordinal (`node#2` → `node`); leaves other names as-is. */
+function stripInstanceOrdinal(name: string): string {
+  const hash = name.lastIndexOf('#')
+  if (hash <= 0) return name
+  return /^\d+$/.test(name.slice(hash + 1)) ? name.slice(0, hash) : name
+}
+
 function remapStepNamesToNodeIds(
   stepNames: string[],
   nodes: Record<string, any>,
@@ -38,12 +46,14 @@ function remapStepNamesToNodeIds(
     const regex = buildTemplateRegex(nodeId)
     if (regex) templatePatterns.set(nodeId, regex)
   }
-  if (templatePatterns.size === 0) return stepNames
   return stepNames.map((name) => {
     if (nodes[name]) return name
+    // Revisit instance (`node#N`) maps to its logical node.
+    const base = stripInstanceOrdinal(name)
+    if (base !== name && nodes[base]) return base
     const matches: string[] = []
     for (const [nodeId, regex] of templatePatterns) {
-      if (regex.test(name)) matches.push(nodeId)
+      if (regex.test(base)) matches.push(nodeId)
     }
     if (matches.length > 1) {
       throw new Error(
@@ -57,6 +67,122 @@ function remapStepNamesToNodeIds(
   })
 }
 
+const ENTRY_FROM = '__entry__'
+
+/** Whether `target` can reach `source` over `next` edges — i.e. an edge
+ *  source→target closes a cycle (a back-edge), vs a plain forward edge. */
+function closesCycle(
+  source: string,
+  target: string,
+  nodes: Record<string, any>
+): boolean {
+  const seen = new Set<string>()
+  const stack = [target]
+  while (stack.length) {
+    const cur = stack.pop()!
+    if (cur === source) return true
+    if (seen.has(cur)) continue
+    seen.add(cur)
+    for (const next of normalizeNodeTargets(nodes[cur]?.next)) stack.push(next)
+  }
+  return false
+}
+
+/**
+ * Decide which next steps to fire this tick. Two kinds of edge:
+ *  - forward edge → node-once: fire the target only if it has no instance yet,
+ *    so converging edges (joins) collapse to a single run (unchanged behavior).
+ *  - back-edge (target can reach the source, closing a cycle) → revisit: fire a
+ *    fresh ordinal instance (`target#1`, …), edge-once on `from → target` so it
+ *    doesn't re-fire every tick. Cycles terminate when branch routing stops
+ *    looping back; a node always records the predecessor it was reached from.
+ */
+function planGraphTransitions(
+  nodes: Record<string, any>,
+  instances: Array<{ stepName: string; status: string; fromStepName?: string }>,
+  branchByStep: Record<string, string>,
+  entryNodeIds: string[],
+  graphName: string
+): {
+  toFire: Array<{ logical: string; instanceKey: string; fromStepName?: string }>
+  hasInFlight: boolean
+  blockedWaiting: boolean
+} {
+  const toLogical = (name: string) =>
+    remapStepNamesToNodeIds([name], nodes, graphName)[0]!
+
+  const countByLogical: Record<string, number> = {}
+  const consumed = new Set<string>()
+  for (const inst of instances) {
+    const logical = toLogical(inst.stepName)
+    countByLogical[logical] = (countByLogical[logical] ?? 0) + 1
+    consumed.add(`${inst.fromStepName ?? ENTRY_FROM}->${logical}`)
+  }
+
+  const completed = instances.filter((i) => i.status === 'succeeded')
+  const completedLogical = new Set(completed.map((i) => toLogical(i.stepName)))
+
+  // Available edges: entry edges + each completed instance's resolved `next`.
+  const edges: Array<{
+    from?: string
+    fromKey: string
+    fromLogical?: string
+    target: string
+  }> = []
+  for (const entryId of entryNodeIds) {
+    edges.push({ fromKey: ENTRY_FROM, target: entryId })
+  }
+  for (const inst of completed) {
+    const fromLogical = toLogical(inst.stepName)
+    const node = nodes[fromLogical]
+    if (!node?.next) continue
+    for (const target of resolveNextFromConfig(
+      node.next,
+      branchByStep[inst.stepName]
+    )) {
+      edges.push({ from: inst.stepName, fromKey: inst.stepName, fromLogical, target })
+    }
+  }
+
+  const toFire: Array<{
+    logical: string
+    instanceKey: string
+    fromStepName?: string
+  }> = []
+  let blockedWaiting = false
+  for (const edge of edges) {
+    const target = edge.target
+    const edgeKey = `${edge.fromKey}->${target}`
+    if (consumed.has(edgeKey)) continue
+    const visits = countByLogical[target] ?? 0
+    const isBackEdge =
+      edge.fromLogical !== undefined &&
+      closesCycle(edge.fromLogical, target, nodes)
+    // Forward edge into an already-started node = a join; node-once.
+    if (!isBackEdge && visits > 0) {
+      consumed.add(edgeKey)
+      continue
+    }
+    if (!areDependenciesSatisfied(nodes[target] ?? {}, completedLogical)) {
+      blockedWaiting = true
+      continue
+    }
+    toFire.push({
+      logical: target,
+      instanceKey: visits === 0 ? target : `${target}#${visits}`,
+      fromStepName: edge.from,
+    })
+    countByLogical[target] = visits + 1
+    consumed.add(edgeKey)
+  }
+
+  return {
+    toFire,
+    hasInFlight: instances.some((i) => i.status !== 'succeeded'),
+    blockedWaiting,
+  }
+}
+
 function remapBranchKeys(
   branchKeys: Record<string, string>,
   nodes: Record<string, any>,
@@ -325,10 +451,13 @@ async function queueGraphNode(
   nodeId: string,
   rpcName: string,
   input: any,
-  nodeConfig?: { retries?: number; retryDelay?: string | number }
+  nodeConfig?: { retries?: number; retryDelay?: string | number },
+  fromStepName?: string
 ): Promise<void> {
+  // Default to the workflow-wide retry policy when the node sets none, so the
+  // persisted step retries match the queue `attempts` (see resolveStepJobOptions).
   const stepOptions = {
-    retries: nodeConfig?.retries ?? 0,
+    retries: nodeConfig?.retries ?? DEFAULT_STEP_RETRIES,
     retryDelay: nodeConfig?.retryDelay,
   }
   await workflowService.insertStepState(
@@ -336,14 +465,16 @@ async function queueGraphNode(
     nodeId,
     rpcName,
     input,
-    stepOptions
+    stepOptions,
+    fromStepName
   )
   await workflowService.queueStepWorker(
     runId,
     nodeId,
     rpcName,
     input,
-    stepOptions
+    stepOptions,
+    fromStepName
   )
 }
 
@@ -364,16 +495,13 @@ export async function continueGraph(
   const {
     completedNodeIds: rawCompleted,
     failedNodeIds: rawFailed,
-    branchKeys: rawBranch,
+    branchKeys: branchByStep,
   } = await workflowService.getCompletedGraphState(runId)
-  const completedNodeIds = remapStepNamesToNodeIds(
-    rawCompleted,
-    nodes,
-    graphName
-  )
-  const completedNodeIdSet = new Set(completedNodeIds)
+  // Validate step/branch names map to unambiguous nodes (planning keys
+  // physically; these calls only surface ambiguous template configs).
+  remapStepNamesToNodeIds(rawCompleted, nodes, graphName)
+  remapBranchKeys(branchByStep, nodes, graphName)
   const failedNodeIds = remapStepNamesToNodeIds(rawFailed, nodes, graphName)
-  const branchKeys = remapBranchKeys(rawBranch, nodes, graphName)
 
   if (failedNodeIds.length > 0) {
     const failedNode = failedNodeIds[0]!
@@ -390,44 +518,18 @@ export async function continueGraph(
     return
   }
 
-  const candidateNodes = new Set<string>()
-
-  for (const nodeId of completedNodeIds) {
-    const node = nodes[nodeId]
-    if (!node?.next) continue
-
-    const nextNodes = resolveNextFromConfig(node.next, branchKeys[nodeId])
-    for (const nextNode of nextNodes) {
-      candidateNodes.add(nextNode)
-    }
-  }
-
-  for (const entryId of meta.entryNodeIds ?? []) {
-    candidateNodes.add(entryId)
-  }
-
-  if (candidateNodes.size === 0 && completedNodeIds.length > 0) {
-    await workflowService.updateRunStatus(runId, 'completed')
-    return
-  }
-
-  const unstartedNodes = await workflowService.getNodesWithoutSteps(runId, [
-    ...candidateNodes,
-  ])
-
-  const nodesToQueue = unstartedNodes.filter((nodeId) => {
-    const node = nodes[nodeId]
-    return node && areDependenciesSatisfied(node, completedNodeIdSet)
-  })
+  const instances = await workflowService.getStepInstances(runId)
+  const plan = planGraphTransitions(
+    nodes,
+    instances,
+    branchByStep,
+    meta.entryNodeIds ?? [],
+    graphName
+  )
 
-  if (nodesToQueue.length === 0) {
-    const allRpcNodes = Object.entries(nodes)
-      .filter(([_, n]) => n.rpcName)
-      .map(([id]) => id)
-    const allRpcCompleted = allRpcNodes.every((id) =>
-      completedNodeIdSet.has(id)
-    )
-    if (allRpcCompleted) {
+  if (plan.toFire.length === 0) {
+    // Nothing left to fire and nothing running/blocked → the run is done.
+    if (!plan.hasInFlight && !plan.blockedWaiting) {
       await workflowService.updateRunStatus(runId, 'completed')
     }
     return
@@ -436,8 +538,8 @@ export async function continueGraph(
   const run = await workflowService.getRun(runId)
   const triggerInput = run?.input
 
-  for (const nodeId of nodesToQueue) {
-    const node = nodes[nodeId]
+  for (const fire of plan.toFire) {
+    const node = nodes[fire.logical]
     if (!node?.rpcName) continue
 
     const referencedNodeIds = extractReferencedNodeIds(node.input).filter(
@@ -447,7 +549,6 @@ export async function continueGraph(
       runId,
       referencedNodeIds
     )
-
     const nodeResults = { trigger: triggerInput, ...fetchedResults }
     const resolvedInput = resolveSerializedInput(node.input, nodeResults)
 
@@ -455,10 +556,11 @@ export async function continueGraph(
       workflowService,
       runId,
       graphName,
-      nodeId,
+      fire.instanceKey,
       node.rpcName,
       resolvedInput,
-      node
+      node,
+      fire.fromStepName
     )
   }
 }

package/src/wirings/workflow/index.ts

@@ -5,9 +5,12 @@ export {
   PikkuWorkflowService,
   WorkflowCancelledException,
   WorkflowSuspendedException,
+  WorkflowDispatchException,
   WorkflowNotFoundError,
   WorkflowRunNotFoundError,
+  DEFAULT_STEP_RETRIES,
 } from './pikku-workflow-service.js'
+export { deriveInvocationId, uuidv5 } from './workflow-invocation-id.js'
 
 // Internal registration functions (used by generated code)
 export { addWorkflow } from './dsl/workflow-runner.js'