@pikku/core 0.12.19 → 0.12.21

package/src/wirings/rpc/wire-addon.test.ts

@@ -0,0 +1,57 @@
+import { beforeEach, describe, test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { resetPikkuState, pikkuState } from '../../pikku-state.js'
+import { wireAddon } from './wire-addon.js'
+
+beforeEach(() => {
+  resetPikkuState()
+})
+
+describe('wireAddon', () => {
+  test('registers addon package metadata for namespace resolution', () => {
+    wireAddon({
+      name: 'stripe',
+      package: '@addon/stripe',
+      rpcEndpoint: 'https://rpc.example.com',
+      auth: true,
+      mcp: true,
+      tags: ['payments', 'billing'],
+      secretOverrides: { apiKey: 'secretName' },
+      variableOverrides: { region: 'eu-west-1' },
+      credentialOverrides: { oauth: 'credentialName' },
+    })
+
+    assert.deepEqual(pikkuState(null, 'addons', 'packages').get('stripe'), {
+      package: '@addon/stripe',
+      rpcEndpoint: 'https://rpc.example.com',
+      auth: true,
+      tags: ['payments', 'billing'],
+    })
+  })
+
+  test('overwrites existing addon config for the same namespace', () => {
+    wireAddon({
+      name: 'stripe',
+      package: '@addon/stripe-v1',
+      rpcEndpoint: 'https://rpc-v1.example.com',
+      auth: false,
+      tags: ['old'],
+    })
+
+    wireAddon({
+      name: 'stripe',
+      package: '@addon/stripe-v2',
+      rpcEndpoint: 'https://rpc-v2.example.com',
+      auth: true,
+      tags: ['new'],
+    })
+
+    assert.deepEqual(pikkuState(null, 'addons', 'packages').get('stripe'), {
+      package: '@addon/stripe-v2',
+      rpcEndpoint: 'https://rpc-v2.example.com',
+      auth: true,
+      tags: ['new'],
+    })
+  })
+})

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

@@ -45,6 +45,10 @@ export interface GraphNodeDef<
   next?: NextConfig<NodeIds>
   /** Error handling - node(s) to execute on error */
   onError?: NodeIds | NodeIds[]
+  /** Maximum retry attempts allowed (excludes the initial attempt) */
+  retries?: number
+  /** Delay between retries — milliseconds, duration string, or 'exponential' */
+  retryDelay?: string | number
 }
 
 /**
@@ -146,6 +150,8 @@ export function createGraph<RPCMap extends Record<string, RPCHandler>>() {
         input: def?.input as any,
         next: def?.next,
         onError: def?.onError,
+        retries: def?.retries,
+        retryDelay: def?.retryDelay,
       }
     }
 
@@ -172,6 +178,8 @@ type GraphNodeConfigMap<
       ) => TypedRef<ComputeNodeOutputs<FuncMap, RPCMap>[N][P]>
     ) => InputWithRefs<ComputeNodeInputs<FuncMap, RPCMap>[K]>
     onError?: Extract<keyof FuncMap, string> | Extract<keyof FuncMap, string>[]
+    retries?: number
+    retryDelay?: string | number
   }
 }
 
@@ -204,6 +212,8 @@ export function graph<NodeIds extends string = string>(
         ref: (nodeId: NodeIds, path: string) => RefValue
       ) => Record<string, unknown>
       onError?: NodeIds | NodeIds[]
+      retries?: number
+      retryDelay?: string | number
     }
   >
 ): Record<NodeIds, GraphNodeConfig<NodeIds>> {
@@ -215,6 +225,8 @@ export function graph<NodeIds extends string = string>(
       input: def.input as any,
       next: def.next,
       onError: def.onError,
+      retries: def.retries,
+      retryDelay: def.retryDelay,
     }
   }
 

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

@@ -526,4 +526,102 @@ describe('graph-runner bugs', () => {
 
     delete metaState['testInlineMetaGraph']
   })
+
+  test('queueGraphNode forwards node retries to queue attempts and backoff', async () => {
+    const ws = new InMemoryWorkflowService()
+    const enqueued: Array<{ queueName: string; data: any; options: any }> = []
+
+    pikkuState(null, 'package', 'singletonServices', {
+      queueService: {
+        add: async (queueName: string, data: any, options: any) => {
+          enqueued.push({ queueName, data, options })
+        },
+      },
+    } as any)
+
+    const meta: WorkflowRuntimeMeta = {
+      name: 'testRetries',
+      pikkuFuncId: 'testRetries',
+      source: 'graph',
+      entryNodeIds: ['a'],
+      graphHash: 'retries-hash',
+      nodes: {
+        a: {
+          nodeId: 'a',
+          rpcName: 'doA',
+          retries: 3,
+          retryDelay: 250,
+        },
+        b: {
+          nodeId: 'b',
+          rpcName: 'doB',
+          retries: 2,
+          retryDelay: 'exponential',
+        },
+        c: {
+          nodeId: 'c',
+          rpcName: 'doC',
+        },
+      },
+    }
+
+    const { runId } = await runWorkflowGraph(
+      ws,
+      'testRetries',
+      {},
+      { rpcWithWire: async () => ({}) },
+      false,
+      undefined,
+      undefined,
+      meta
+    )
+
+    const aJob = enqueued.find((e) => e.data?.stepName === 'a')
+    assert.ok(aJob, 'node a should have been enqueued')
+    assert.equal(aJob!.options?.attempts, 4, 'retries=3 → attempts=4')
+    assert.deepEqual(aJob!.options?.backoff, { type: 'fixed', delay: 250 })
+
+    const stepStateA = await ws.getStepState(runId, 'a')
+    assert.equal(
+      stepStateA.retries,
+      3,
+      'insertStepState should record node retries'
+    )
+    assert.equal(stepStateA.retryDelay, 250)
+
+    enqueued.length = 0
+    await runWorkflowGraph(
+      ws,
+      'testRetries',
+      {},
+      { rpcWithWire: async () => ({}) },
+      false,
+      'b',
+      undefined,
+      meta
+    )
+    const bJob = enqueued.find((e) => e.data?.stepName === 'b')
+    assert.ok(bJob, 'node b should have been enqueued')
+    assert.equal(bJob!.options?.attempts, 3, 'retries=2 → attempts=3')
+    assert.equal(bJob!.options?.backoff, 'exponential')
+
+    enqueued.length = 0
+    await runWorkflowGraph(
+      ws,
+      'testRetries',
+      {},
+      { rpcWithWire: async () => ({}) },
+      false,
+      'c',
+      undefined,
+      meta
+    )
+    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)'
+    )
+  })
 })

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

@@ -324,12 +324,27 @@ async function queueGraphNode(
   _graphName: string,
   nodeId: string,
   rpcName: string,
-  input: any
+  input: any,
+  nodeConfig?: { retries?: number; retryDelay?: string | number }
 ): Promise<void> {
-  await workflowService.insertStepState(runId, nodeId, rpcName, input, {
-    retries: 0,
-  })
-  await workflowService.queueStepWorker(runId, nodeId, rpcName, input)
+  const stepOptions = {
+    retries: nodeConfig?.retries ?? 0,
+    retryDelay: nodeConfig?.retryDelay,
+  }
+  await workflowService.insertStepState(
+    runId,
+    nodeId,
+    rpcName,
+    input,
+    stepOptions
+  )
+  await workflowService.queueStepWorker(
+    runId,
+    nodeId,
+    rpcName,
+    input,
+    stepOptions
+  )
 }
 
 export async function continueGraph(
@@ -442,7 +457,8 @@ export async function continueGraph(
       graphName,
       nodeId,
       node.rpcName,
-      resolvedInput
+      resolvedInput,
+      node
     )
   }
 }
@@ -553,7 +569,8 @@ export async function executeGraphStep(
               graphName,
               errorNodeId,
               errorNode.rpcName,
-              { error: { message: (error as Error).message } }
+              { error: { message: (error as Error).message } },
+              errorNode
             )
           }
         }
@@ -600,7 +617,7 @@ async function executeGraphNodeInline(
     nodeId,
     rpcName,
     input,
-    { retries: 3 }
+    { retries: node.retries ?? 0, retryDelay: node.retryDelay }
   )
 
   await workflowService.setStepRunning(stepState.stepId)
@@ -677,7 +694,7 @@ async function executeGraphNodeInline(
         message: `RPC '${rpcName}' not found. Deploy the missing function and resume.`,
         code: 'RPC_NOT_FOUND',
       })
-      return
+      throw new WorkflowSuspendedException(runId, 'RPC_NOT_FOUND')
     }
     await workflowService.setStepError(stepState.stepId, error as Error)
 
@@ -932,7 +949,8 @@ export async function runWorkflowGraph(
         graphName,
         nodeId,
         node.rpcName,
-        resolvedInput
+        resolvedInput,
+        node
       )
     }
     if (inline) {

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

@@ -65,6 +65,10 @@ export interface GraphNodeConfig<NodeIds extends string = string> {
   next?: NextConfig<NodeIds>
   /** Error routing - node(s) to execute on error */
   onError?: NodeIds | NodeIds[]
+  /** Maximum retry attempts allowed (excludes the initial attempt) */
+  retries?: number
+  /** Delay between retries — milliseconds, duration string, or 'exponential' */
+  retryDelay?: string | number
 }
 
 /**

package/src/wirings/workflow/index.ts

@@ -51,6 +51,7 @@ export type {
   WorkflowRunStatus,
   StepState,
   WorkflowRunService,
+  WorkflowRunMirror,
   CoreWorkflow,
   PikkuWorkflow,
   ContextVariable,

package/src/wirings/workflow/pikku-workflow-service.test.ts

@@ -2,13 +2,30 @@ import { describe, test } from 'node:test'
 import assert from 'node:assert/strict'
 
 import { InMemoryWorkflowService } from '../../services/in-memory-workflow-service.js'
-import { pikkuState } from '../../pikku-state.js'
+import { pikkuState, resetPikkuState } from '../../pikku-state.js'
 import { addWorkflow } from './dsl/workflow-runner.js'
 import {
   WorkflowSuspendedException,
   type PikkuWorkflowWire,
 } from './pikku-workflow-service.js'
 
+describe('pikku-workflow-service worker registration', () => {
+  test('registers sleeper function metadata', () => {
+    resetPikkuState()
+
+    new InMemoryWorkflowService()
+
+    const functionMeta = pikkuState(null, 'function', 'meta')
+    assert.deepEqual(functionMeta.pikkuWorkflowSleeper, {
+      pikkuFuncId: 'pikkuWorkflowSleeper',
+      sessionless: true,
+      functionType: 'helper',
+      inputSchemaName: null,
+      outputSchemaName: null,
+    })
+  })
+})
+
 describe('pikku-workflow-service inline meta flag', () => {
   test('workflow with inline: true in meta should create inline run and not queue', async () => {
     const ws = new InMemoryWorkflowService()
@@ -53,7 +70,7 @@ describe('pikku-workflow-service inline meta flag', () => {
       },
     })
 
-    const { runId } = await ws.startWorkflow(workflowName, {}, {})
+    const { runId } = await ws.startWorkflow(workflowName, {}, {}, {})
 
     // The run should be created as inline
     const run = await ws.getRun(runId)