@pikku/core 0.12.70 → 0.12.71

package/src/wirings/workflow/workflow-run-context.test.ts

@@ -0,0 +1,177 @@
+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'
+
+const silentLogger = { error() {}, info() {}, warn() {}, debug() {} }
+
+function service() {
+  pikkuState(null, 'package', 'singletonServices', {
+    queueService: { add: async () => {} },
+    logger: silentLogger,
+  } as any)
+  return new InMemoryWorkflowService() as any
+}
+
+const newRun = (ws: any, inline = false) =>
+  ws.createRun('flow', {}, inline, 'hash', { type: 'test' })
+
+const trackDetaches = (ws: any): string[] => {
+  const detached: string[] = []
+  ws.setRunExtension(() => ({
+    attachRunContext: async () => {},
+    detachRunContext: (runId: string) => detached.push(runId),
+    decorateRunWire: () => {},
+    decorateWorkflowWire: () => {},
+    onBeforeRunFunc: async () => {},
+    onAfterRunFunc: async () => {},
+  }))
+  return detached
+}
+
+/**
+ * A long-lived process orchestrates many runs. Anything it keeps per run has to
+ * be released when that run stops executing here, or the engine grows for the
+ * life of the deployment.
+ */
+describe('per-run state is released when the run stops executing here', () => {
+  test('a finished replay leaves nothing behind', async () => {
+    const ws = service()
+    const runId = await newRun(ws)
+
+    await ws.beginReplay(runId)
+    await ws.inlineStep(runId, 'a', async () => 1)
+    ws.endReplay(runId)
+
+    assert.equal(
+      ws.runContexts.size,
+      0,
+      'the replay held on to its ordinals, lineage or step snapshot'
+    )
+  })
+
+  test('the step the walk last reached does not survive its replay', async () => {
+    const ws = service()
+    const runId = await newRun(ws)
+
+    await ws.beginReplay(runId)
+    await ws.inlineStep(runId, 'a', async () => 1)
+    ws.endReplay(runId)
+
+    assert.equal(ws.lastStepName(runId), undefined)
+  })
+
+  test('unregistering an inline run releases it', async () => {
+    const ws = service()
+    const runId = await newRun(ws)
+
+    ws.registerInlineRun(runId)
+    assert.equal(ws.isInline(runId), true)
+
+    ws.unregisterInlineRun(runId)
+    assert.equal(ws.isInline(runId), false)
+    assert.equal(ws.runContexts.size, 0)
+  })
+
+  test('a replay inside an inline run does not release the inline flag', async () => {
+    const ws = service()
+    const runId = await newRun(ws)
+
+    ws.registerInlineRun(runId)
+    await ws.beginReplay(runId)
+    ws.endReplay(runId)
+
+    assert.equal(
+      ws.isInline(runId),
+      true,
+      'ending a replay dropped state the run still needs'
+    )
+  })
+
+  test("a queued run's extension context is released when the run reaches a terminal state", async () => {
+    const ws = service()
+    const runId = await newRun(ws)
+    const detached = trackDetaches(ws)
+
+    await ws.updateRunStatus(runId, 'completed', null)
+
+    assert.deepEqual(
+      detached,
+      [runId],
+      'an extension holds live per-run state; a completed run must not keep it'
+    )
+    assert.equal(ws.runContexts.size, 0)
+  })
+
+  test('a suspended run keeps its extension context, because it can still be resumed', async () => {
+    const ws = service()
+    const runId = await newRun(ws)
+    const detached = trackDetaches(ws)
+
+    await ws.updateRunStatus(runId, 'suspended')
+
+    assert.deepEqual(detached, [])
+  })
+})
+
+describe('a replay reads the run once', () => {
+  test('the steps of a replay share one read of the run', async () => {
+    const ws = service()
+    const runId = await newRun(ws)
+
+    let reads = 0
+    const getRun = ws.getRun.bind(ws)
+    ws.getRun = async (id: string) => {
+      reads++
+      return getRun(id)
+    }
+
+    await ws.beginReplay(runId)
+    await ws.getRunIdentity(runId)
+    await ws.getRunIdentity(runId)
+    await ws.getRunIdentity(runId)
+    ws.endReplay(runId)
+
+    assert.equal(reads, 1, `the run was read ${reads} times in one replay`)
+  })
+
+  test('the next replay re-reads the run rather than trusting the last one', async () => {
+    const ws = service()
+    const runId = await newRun(ws)
+
+    let reads = 0
+    const getRun = ws.getRun.bind(ws)
+    ws.getRun = async (id: string) => {
+      reads++
+      return getRun(id)
+    }
+
+    await ws.beginReplay(runId)
+    await ws.getRunIdentity(runId)
+    ws.endReplay(runId)
+    await ws.beginReplay(runId)
+    await ws.getRunIdentity(runId)
+    ws.endReplay(runId)
+
+    assert.equal(reads, 2)
+  })
+
+  test('outside a replay the run is read every time', async () => {
+    const ws = service()
+    const runId = await newRun(ws)
+
+    let reads = 0
+    const getRun = ws.getRun.bind(ws)
+    ws.getRun = async (id: string) => {
+      reads++
+      return getRun(id)
+    }
+
+    await ws.getRunIdentity(runId)
+    await ws.getRunIdentity(runId)
+
+    assert.equal(reads, 2, 'a cached run outside a replay would go stale')
+    assert.equal(ws.runContexts.size, 0, 'reading a run must not create state')
+  })
+})

package/src/wirings/workflow/workflow-run-polling.test.ts

@@ -0,0 +1,132 @@
+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 type { WorkflowRun } from './workflow.types.js'
+
+/**
+ * A workflow service whose run reads are counted and timestamped, and whose
+ * run finishes only once it has been read `endAfter` times.
+ */
+class PollProbe extends InMemoryWorkflowService {
+  readonly reads: number[] = []
+  /** Every wait the loop asked for, in order — the schedule, not the clock. */
+  readonly waits: number[] = []
+  endAfter = 1
+
+  override async waitBeforeNextRead(ms: number): Promise<void> {
+    this.waits.push(ms)
+  }
+
+  override async startWorkflow(): Promise<{ runId: string }> {
+    return { runId: 'run-1' }
+  }
+
+  override async getRun(_runId: string): Promise<WorkflowRun | null> {
+    this.reads.push(Date.now())
+    const done = this.reads.length >= this.endAfter
+    return {
+      id: 'run-1',
+      status: done ? 'completed' : 'running',
+      output: 'result',
+    } as WorkflowRun
+  }
+}
+
+const probe = () => {
+  pikkuState(null, 'package', 'singletonServices', {
+    logger: { error() {}, info() {}, warn() {}, debug() {} },
+  } as any)
+  return new PollProbe()
+}
+
+describe('waiting for a run to finish', () => {
+  test('a run that finishes quickly is not held for a whole poll interval', async () => {
+    const ws = probe()
+    ws.endAfter = 2
+
+    const output = await ws.runToCompletion('flow', {}, {} as any)
+
+    assert.equal(output, 'result')
+    assert.equal(ws.waits.length, 1)
+    assert.ok(
+      ws.waits[0]! < 1000,
+      `a run done after one poll waited the full ${ws.waits[0]}ms default — a fixed interval makes every fast workflow pay for it`
+    )
+  })
+
+  test('reads spread out as a run keeps running', async () => {
+    const ws = probe()
+    ws.endAfter = 8
+
+    await ws.runToCompletion('flow', {}, {} as any)
+
+    assert.ok(ws.waits.length >= 6)
+    assert.ok(
+      ws.waits.at(-1)! > ws.waits[0]! * 2,
+      `waits stayed flat (${ws.waits.join('ms, ')}ms) — a run that drags on keeps costing the same read rate forever`
+    )
+    for (let i = 1; i < ws.waits.length; i++) {
+      assert.ok(
+        ws.waits[i]! >= ws.waits[i - 1]!,
+        `wait ${i} shrank (${ws.waits.join('ms, ')}ms)`
+      )
+    }
+  })
+
+  test('the wait never grows past the configured interval', async () => {
+    const ws = probe()
+    ws.endAfter = 12
+
+    await ws.runToCompletion('flow', {}, {} as any, { pollIntervalMs: 40 })
+
+    for (const wait of ws.waits) {
+      assert.ok(wait <= 40, `a wait of ${wait}ms overshot the 40ms ceiling`)
+    }
+    assert.equal(
+      ws.waits.at(-1),
+      40,
+      `the ceiling was never reached (${ws.waits.join('ms, ')}ms)`
+    )
+  })
+
+  test('a run that is already finished is returned without any wait', async () => {
+    const ws = probe()
+    ws.endAfter = 1
+
+    await ws.runToCompletion('flow', {}, {} as any)
+
+    assert.equal(ws.reads.length, 1)
+    assert.deepEqual(ws.waits, [])
+  })
+})
+
+describe('a run that ends badly', () => {
+  test('a failed run surfaces its error message', async () => {
+    const ws = probe()
+    ws.getRun = async () =>
+      ({
+        id: 'run-1',
+        status: 'failed',
+        error: { message: 'step blew up' },
+      }) as WorkflowRun
+
+    await assert.rejects(ws.runToCompletion('flow', {}, {} as any), /blew up/)
+  })
+
+  test('a cancelled run rejects', async () => {
+    const ws = probe()
+    ws.getRun = async () =>
+      ({ id: 'run-1', status: 'cancelled' }) as WorkflowRun
+
+    await assert.rejects(ws.runToCompletion('flow', {}, {} as any))
+  })
+
+  test('a run that disappears rejects rather than polling forever', async () => {
+    const ws = probe()
+    ws.getRun = async () => null
+
+    await assert.rejects(ws.runToCompletion('flow', {}, {} as any), /run-1/)
+  })
+})

package/src/wirings/workflow/workflow-step-ordinal.test.ts

@@ -19,7 +19,7 @@ describe('same step name invoked multiple times in one run', () => {
   test('each reach gets its own row + invocationId (no clobber)', async () => {
     const ws = inlineService()
     const runId = await ws.createRun('flow', {}, true, 'hash', { type: 'test' })
-    ;(ws as any).inlineRuns.add(runId)
+    ws.registerInlineRun(runId)
 
     // Two `do('process', fn)` reaches in the SAME replay (no reset between).
     const r1 = await (ws as any).inlineStep(runId, 'process', async () => 'first')
@@ -45,7 +45,7 @@ describe('same step name invoked multiple times in one run', () => {
   test('ordinal 0 is unchanged: a single call keeps the bare name + its old invocationId', async () => {
     const ws = inlineService()
     const runId = await ws.createRun('flow', {}, true, 'hash', { type: 'test' })
-    ;(ws as any).inlineRuns.add(runId)
+    ws.registerInlineRun(runId)
 
     await (ws as any).inlineStep(runId, 'solo', async () => 'x')
     // Stored under the bare name, and the dedupe key matches the pre-ordinal hash.
@@ -57,7 +57,7 @@ describe('same step name invoked multiple times in one run', () => {
   test('a fresh replay resets ordinals so the same call resolves to the same row', async () => {
     const ws = inlineService()
     const runId = await ws.createRun('flow', {}, true, 'hash', { type: 'test' })
-    ;(ws as any).inlineRuns.add(runId)
+    ws.registerInlineRun(runId)
 
     let runs = 0
     const r1 = await (ws as any).inlineStep(runId, 'once', async () => {
@@ -66,7 +66,7 @@ describe('same step name invoked multiple times in one run', () => {
     })
     // Next replay resets the counter; the same `do('once')` must hit the cached
     // row, not mint 'once#1'.
-    ;(ws as any).resetStepOrdinals(runId)
+    await (ws as any).beginReplay(runId)
     const r2 = await (ws as any).inlineStep(runId, 'once', async () => {
       runs++
       return 'v2'

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

@@ -254,9 +254,6 @@ export interface WorkflowRunService {
     name: string,
     graphHash: string
   ): Promise<{ graph: any; source: string } | null>
-  getAIGeneratedWorkflows(
-    agentName?: string
-  ): Promise<Array<{ workflowName: string; graphHash: string; graph: any }>>
   deleteRun(id: string): Promise<boolean>
 }
 
@@ -484,7 +481,7 @@ export interface WorkflowRuntimeMeta {
   /** Pikku function name (for execution) */
   pikkuFuncId: string
   /** Source type: 'dsl' (serializable), 'complex' (has inline steps), 'graph', 'scenario' (complex + actor steps) */
-  source: 'dsl' | 'complex' | 'graph' | 'dynamic-workflow' | 'scenario'
+  source: 'dsl' | 'complex' | 'graph' | 'scenario'
   /** Optional description */
   description?: string
   /** Tags for organization */