@pikku/core 0.12.79 → 0.12.82

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

@@ -9,13 +9,13 @@ import { closeWireServices } from '../../utils.js'
 import { PikkuError, addError } from '../../errors/error-handler.js'
 import { InMemoryWorkflowService } from '../../services/in-memory-workflow-service.js'
 import { runScheduledTask } from '../scheduler/scheduler-runner.js'
-import {
-  WorkflowStepNameNotString,
-  type RunLifecycleContext,
-  type WorkflowRunEngine,
-  type WorkflowRunExtension,
-} from './pikku-workflow-service.js'
-import type { PikkuWire } from '../../types/core.types.js'
+import { WorkflowStepNameNotString } from './workflow-errors.js'
+import type {
+  RunLifecycleContext,
+  WorkflowRunEngine,
+  WorkflowRunExtension,
+} from './workflow-run-engine.types.js'
+import type { PikkuRawWire } from '../../types/core.types.js'
 import type { ScenarioPersonas } from '../../services/personas-service.js'
 import type { CorePikkuFunctionConfig } from '../../function/functions.types.js'
 import type {
@@ -29,11 +29,14 @@ import { resolveScenarioSurfaces, witnessesAgree } from './scenario-surface.js'
 import type {
   PikkuScenarioWire,
   PikkuWorkflowWire,
+  WorkflowQueueOptions,
+} from './workflow.types.js'
+import type {
   WorkflowExpectEventuallyOptions,
   WorkflowExpectErrorOptions,
+  WorkflowExpectScoreOptions,
   WorkflowExpectServiceOptions,
-  WorkflowQueueOptions,
-} from './workflow.types.js'
+} from './dsl/workflow-dsl.types.js'
 
 /**
  * A workflow service with the scenario capability attached — the two lines
@@ -66,7 +69,7 @@ export const createScenarioRunner = (
 type ScenarioHook = (
   services: any,
   data: any,
-  wire: PikkuWire
+  wire: PikkuRawWire
 ) => Promise<void> | void
 
 /**
@@ -245,6 +248,10 @@ export class PikkuScenarioService implements WorkflowRunExtension {
   // Scenario actors per run: live authenticated clients (cookie jars) are
   // process-local by nature, so they ride this map, never the persisted wire.
   private runActors = new Map<string, ScenarioPersonas>()
+  // What each run has accumulated so far — process-local like the actors above,
+  // so the body and its hooks share one object rather than reading it back off
+  // the persisted wire.
+  private runContexts = new Map<string, Record<string, unknown>>()
   private scenarioBrowserProvider?: ScenarioBrowserProvider
   private scenarioEnvironment?: ScenarioEnvironment
   private runSurface: ScenarioSurface = 'default'
@@ -304,14 +311,42 @@ export class PikkuScenarioService implements WorkflowRunExtension {
     if (actors) {
       this.runActors.set(runId, actors)
     }
+    if (workflowMeta.source === 'scenario') {
+      this.runContexts.set(runId, {})
+    }
   }
 
   public detachRunContext(runId: string): void {
     this.runActors.delete(runId)
+    this.runContexts.delete(runId)
+  }
+
+  /**
+   * What the run has accumulated.
+   *
+   * Undefined only for a run whose wire was never decorated — decoration calls
+   * `contextForRun` unconditionally, so a plain workflow that has reached a
+   * step holds an empty context rather than none.
+   */
+  public getRunContext(runId: string): Record<string, unknown> | undefined {
+    return this.runContexts.get(runId)
+  }
+
+  /**
+   * The run's context, created on demand because the wire is also built on
+   * paths that skip `attachRunContext`.
+   */
+  private contextForRun(runId: string): Record<string, unknown> {
+    let runContext = this.runContexts.get(runId)
+    if (!runContext) {
+      runContext = {}
+      this.runContexts.set(runId, runContext)
+    }
+    return runContext
   }
 
   public decorateRunWire(
-    wire: PikkuWire,
+    wire: PikkuRawWire,
     context: {
       runId: string
       workflowMeta: any
@@ -409,7 +444,7 @@ export class PikkuScenarioService implements WorkflowRunExtension {
     phase: 'before' | 'after',
     scenarioName: string,
     hook: ScenarioHook,
-    wire: PikkuWire,
+    wire: PikkuRawWire,
     data: unknown,
     packageName: string | null
   ): Promise<void> {
@@ -424,10 +459,9 @@ export class PikkuScenarioService implements WorkflowRunExtension {
 
     let wireServices: Record<string, unknown> | undefined
     try {
-      wireServices = (await createWireServices?.(
-        singletonServices,
-        wire as any
-      )) as Record<string, unknown> | undefined
+      wireServices = (await createWireServices?.(singletonServices, wire)) as
+        | Record<string, unknown>
+        | undefined
       const services =
         wireServices && Object.keys(wireServices).length > 0
           ? { ...singletonServices, ...wireServices }
@@ -508,6 +542,8 @@ export class PikkuScenarioService implements WorkflowRunExtension {
       rpcService,
     })
     Object.assign(workflowWire, {
+      context: this.contextForRun(runId),
+
       // Durable polling step: invoke an RPC (as an actor when options.as is
       // set) until the predicate passes or `within` elapses. The whole poll is
       // ONE recorded step, so replay returns the cached outcome.
@@ -648,12 +684,52 @@ export class PikkuScenarioService implements WorkflowRunExtension {
         )
       },
 
-      // Scenario steps: a named `pikkuScenarioStep` run as one durable step.
-      // `given`/`when` are sugar for each other, differing only in the
-      // prose a reporter renders. `then` is not: the phase is what decides
-      // whether the step's bindings are alternatives or witnesses, so the same
-      // step function called two ways runs differently. See
-      // {@link resolveScenarioSurfaces}.
+      expectScore: async (
+        stepName: string,
+        agentRunId: string,
+        scorerName: string,
+        options?: WorkflowExpectScoreOptions
+      ) => {
+        this.engine.verifyStepName(stepName)
+        return await this.engine.inlineStep(
+          runId,
+          stepName,
+          async () => {
+            const rpcName = 'pikkuScenarioGradeRun'
+            const data = {
+              runId: agentRunId,
+              scorer: scorerName,
+              ...(options?.reference !== undefined
+                ? { reference: options.reference }
+                : {}),
+            }
+            const grade: { score: number; reason?: string } = options?.actor
+              ? await options.actor.invoke(rpcName, data)
+              : await rpcService.rpcWithWire(rpcName, data, {})
+
+            // A scorer that graded is a scorer that answered, so an unstated
+            // bound still fails a zero rather than passing anything at all.
+            const atLeast = options?.atLeast ?? 0.5
+            const failed =
+              grade.score < atLeast ||
+              (options?.atMost !== undefined && grade.score > options.atMost)
+            if (failed) {
+              const bound =
+                options?.atMost !== undefined
+                  ? `between ${atLeast} and ${options.atMost}`
+                  : `at least ${atLeast}`
+              throw new Error(
+                `[workflow] expectScore '${stepName}' expected '${scorerName}' to grade run ${agentRunId} ${bound}, got ${grade.score}` +
+                  `${grade.reason ? `: ${grade.reason}` : ''}`
+              )
+            }
+            return grade
+          },
+          options
+        )
+      },
+
+      // knowledge: decisions/internals/scenario-given-and-when-are-sugar-but-then-is-not.md
       given: (stepName, stepFunc, data, options) =>
         this.scenarioStep(
           'given',
@@ -696,8 +772,7 @@ export class PikkuScenarioService implements WorkflowRunExtension {
     data?: any,
     options?: ScenarioStepOptions
   ): Promise<any> {
-    const { runId, workflowName, addonNamespace, workflowWire, rpcService } =
-      context
+    const { runId, workflowName, addonNamespace, workflowWire } = context
     // Also the guard for `then` being a wire member: an accidental
     // `await scenario` calls it with a resolve function, which lands here as a
     // loud, named error instead of a silent hang.
@@ -727,11 +802,10 @@ export class PikkuScenarioService implements WorkflowRunExtension {
       stepName,
       async () => {
         const runOnSurface = async (surface: ScenarioSurface) => {
-          const wire: PikkuWire = {
+          // No `rpc` yet — runPikkuFunc attaches it lazily for the invocation.
+          const wire: PikkuRawWire = {
             workflow: workflowWire,
             scenario: workflowWire,
-            rpc: rpcService?.wire?.rpc,
-            session: rpcService?.wire?.session,
             pikkuUserId: workflowWire.pikkuUserId,
             actors: this.runActors.get(runId),
             scenarioStep: {

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

@@ -8,8 +8,8 @@ import { addWorkflow } from './dsl/workflow-runner.js'
 import {
   WorkflowApprovalResolvedError,
   WorkflowSuspendedException,
-  type PikkuWorkflowWire,
-} from './pikku-workflow-service.js'
+} from './workflow-errors.js'
+import type { PikkuWorkflowWire } from './workflow.types.js'
 
 describe('pikku-workflow-service worker registration', () => {
   test('registers sleeper function metadata after wireQueueWorkers', () => {
@@ -661,12 +661,9 @@ describe('pikku-workflow-service approval', () => {
 
     const run = await ws.getRun(runId)
     assert.equal(run?.status, 'completed')
-    assert.deepEqual(run?.output, {
-      decision: {
-        status: 'decided',
-        data: { approved: true, comment: 'lgtm' },
-      },
-    })
+    const decision = (run?.output as any)?.decision
+    assert.equal(decision.status, 'decided')
+    assert.deepEqual(decision.data, { approved: true, comment: 'lgtm' })
 
     cleanup()
   })
@@ -714,9 +711,9 @@ describe('pikku-workflow-service approval', () => {
     await ws.runWorkflowJob(runId, {})
     const run = await ws.getRun(runId)
     assert.equal(run?.status, 'completed')
-    assert.deepEqual(run?.output, {
-      decision: { status: 'decided', data: { approved: false } },
-    })
+    const decision = (run?.output as any)?.decision
+    assert.equal(decision.status, 'decided')
+    assert.deepEqual(decision.data, { approved: false })
 
     cleanup()
   })
@@ -834,9 +831,13 @@ describe('pikku-workflow-service approval', () => {
 
     const run = await ws.getRun(runId)
     assert.equal(run?.status, 'completed')
-    assert.deepEqual(run?.output, {
-      decision: { status: 'decided', data: { approved: true } },
-    })
+    const decision = (run?.output as any)?.decision
+    assert.equal(decision.status, 'decided')
+    assert.deepEqual(decision.data, { approved: true })
+    // Answered with no session, so there is nobody to name — but when the
+    // answer arrived is recorded either way.
+    assert.equal(decision.decidedBy, undefined)
+    assert.ok(!Number.isNaN(Date.parse(decision.decidedAt)))
 
     cleanup()
   })