@pikku/core 0.12.57 → 0.12.60

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

@@ -677,6 +677,140 @@ describe('graph-runner bugs', () => {
     delete metaState['testInlineMetaGraph']
   })
 
+  test('executeGraphStep dispatches an agent-name node via the agent-run path and returns its result', async () => {
+    const ws = new InMemoryWorkflowService()
+
+    const agentsMeta = pikkuState(null, 'agent', 'agentsMeta')
+    agentsMeta['summarize'] = {
+      name: 'summarize',
+      inputSchema: null,
+      outputSchema: null,
+      workingMemorySchema: null,
+    } as any
+
+    const metaState = pikkuState(null, 'workflows', 'meta')
+    metaState['testAgentNode'] = {
+      name: 'testAgentNode',
+      pikkuFuncId: 'testAgentNode',
+      source: 'graph',
+      entryNodeIds: ['a'],
+      graphHash: 'agent-node-hash',
+      nodes: {
+        a: { nodeId: 'a', rpcName: 'summarize' },
+      },
+    }
+
+    const runId = await ws.createRun(
+      'testAgentNode',
+      {},
+      false,
+      'agent-node-hash',
+      { type: 'test' }
+    )
+    const agentInput = { message: 'hi', threadId: 't', resourceId: 'r' }
+    const step = await ws.insertStepState(runId, 'a', 'summarize', agentInput)
+
+    let agentRunCall: { name: string; input: any } | null = null
+    const rpcService = {
+      rpcWithWire: async () => {
+        throw new Error('should not invoke rpcWithWire for an agent node')
+      },
+      agent: {
+        run: async (name: string, input: any) => {
+          agentRunCall = { name, input }
+          return {
+            runId: 'agent-run-1',
+            result: { summary: 'done' },
+            usage: { inputTokens: 1, outputTokens: 2 },
+          }
+        },
+      },
+    }
+
+    const result = await executeGraphStep(
+      ws,
+      rpcService,
+      runId,
+      step.stepId,
+      'a',
+      'summarize',
+      agentInput,
+      'testAgentNode'
+    )
+
+    assert.deepEqual(result, { summary: 'done' })
+    assert.deepEqual(agentRunCall, { name: 'summarize', input: agentInput })
+
+    delete metaState['testAgentNode']
+    delete agentsMeta['summarize']
+  })
+
+  test('inline graph dispatches an agent node and a downstream node consumes its result', async () => {
+    const ws = new InMemoryWorkflowService()
+
+    const agentsMeta = pikkuState(null, 'agent', 'agentsMeta')
+    agentsMeta['classifier'] = {
+      name: 'classifier',
+      inputSchema: null,
+      outputSchema: null,
+      workingMemorySchema: null,
+    } as any
+
+    let consumed: any = null
+    const rpcService = {
+      rpcWithWire: async (rpcName: string, data: any) => {
+        if (rpcName === 'consume') {
+          consumed = data
+          return { ok: true }
+        }
+        return {}
+      },
+      agent: {
+        run: async () => ({
+          runId: 'r',
+          result: { category: 'urgent' },
+          usage: { inputTokens: 0, outputTokens: 0 },
+        }),
+      },
+    }
+
+    const metaState = pikkuState(null, 'workflows', 'meta')
+    metaState['testInlineAgentNode'] = {
+      name: 'testInlineAgentNode',
+      pikkuFuncId: 'testInlineAgentNode',
+      source: 'graph',
+      entryNodeIds: ['agentNode'],
+      graphHash: 'inline-agent-hash',
+      nodes: {
+        agentNode: {
+          nodeId: 'agentNode',
+          rpcName: 'classifier',
+          next: 'consume',
+        },
+        consume: {
+          nodeId: 'consume',
+          rpcName: 'consume',
+          input: { category: { $ref: 'agentNode', path: 'category' } },
+        },
+      },
+    }
+
+    const { runId } = await runWorkflowGraph(
+      ws,
+      'testInlineAgentNode',
+      { message: 'x', threadId: 't', resourceId: 'r' },
+      rpcService,
+      true
+    )
+
+    const run = await ws.getRun(runId)
+    assert.equal(run?.status, 'completed')
+    assert.deepEqual(consumed, { category: 'urgent' })
+
+    delete metaState['testInlineAgentNode']
+    delete agentsMeta['classifier']
+  })
+
   test('queueGraphNode forwards node retries to queue attempts and backoff', async () => {
     const ws = new InMemoryWorkflowService()
     const enqueued: Array<{ queueName: string; data: any; options: any }> = []

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

@@ -621,6 +621,9 @@ export async function executeGraphStep(
     let result: any
 
     const subWorkflowMeta = pikkuState(null, 'workflows', 'meta')[rpcName]
+    const agentMeta = subWorkflowMeta
+      ? undefined
+      : pikkuState(null, 'agent', 'agentsMeta')[rpcName]
     if (subWorkflowMeta) {
       const childWire: WorkflowRunWire = {
         type: 'workflow',
@@ -650,6 +653,9 @@ export async function executeGraphStep(
       } else {
         throw new ChildWorkflowStartedException(runId, stepId, childRunId)
       }
+    } else if (agentMeta) {
+      const agentRun = await rpcService.agent.run(rpcName, data)
+      result = agentRun.result
     } else {
       result = await invokeGraphNodeRpc(
         workflowService,
@@ -760,6 +766,9 @@ async function executeGraphNodeInline(
     let result: any
 
     const subWorkflowMeta = pikkuState(null, 'workflows', 'meta')[rpcName]
+    const agentMeta = subWorkflowMeta
+      ? undefined
+      : pikkuState(null, 'agent', 'agentsMeta')[rpcName]
     if (subWorkflowMeta) {
       const childWire: WorkflowRunWire = {
         type: 'workflow',
@@ -783,6 +792,9 @@ async function executeGraphNodeInline(
         throw new Error('Sub-workflow was cancelled')
       }
       result = childRun?.output
+    } else if (agentMeta) {
+      const agentRun = await rpcService.agent.run(rpcName, input)
+      result = agentRun.result
     } else {
       result = await invokeGraphNodeRpc(
         workflowService,

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

@@ -1732,7 +1732,11 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     data: any,
     rpcService: any
   ): Promise<any> {
+    // Carry the run's pikkuUserId onto the step wire so authed steps rehydrate their
+    // session on the queued path too (the bare job wire lacks it; inline already has it).
+    const run = await this.getRun(runId)
     return rpcService.rpcWithWire(rpcName, data, {
+      ...(run?.wire?.pikkuUserId ? { pikkuUserId: run.wire.pikkuUserId } : {}),
       workflowStep: {
         runId,
         stepId: stepState.stepId,

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

@@ -0,0 +1,78 @@
+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'
+
+// A queued workflow step is executed with the bare job wire (payload is just
+// { runId }), so its wire has no `pikkuUserId`. Without threading it from the
+// persisted run wire, an authed step (`pikkuFunc`) sees no session and throws
+// "Authentication required". These tests pin that `invokeStepRpc` merges the
+// run wire's `pikkuUserId` into the step wire override so the session rehydrates.
+
+const silentLogger = { error() {}, info() {}, warn() {}, debug() {} }
+
+// rpcService stand-in whose only job is to capture the wire override it's handed.
+function capturingRpcService(): {
+  service: { rpcWithWire: (n: string, d: any, w: any) => Promise<any> }
+  wire: () => any
+} {
+  let captured: any
+  return {
+    service: {
+      rpcWithWire: async (_rpcName: string, _data: any, wire: any) => {
+        captured = wire
+        return { ok: true }
+      },
+    },
+    wire: () => captured,
+  }
+}
+
+describe('queued workflow steps carry the run wire pikkuUserId', () => {
+  test('invokeStepRpc merges run.wire.pikkuUserId into the step wire override', async () => {
+    pikkuState(null, 'package', 'singletonServices', { logger: silentLogger } as any)
+
+    const ws = new InMemoryWorkflowService()
+    const runId = await ws.createRun('flow', {}, false, 'hash', {
+      type: 'queue',
+      pikkuUserId: 'user-abc',
+    })
+    await ws.insertStepState(runId, 'deploy', 'deployByStageKind', {})
+    const stepState = await ws.getStepState(runId, 'deploy')
+
+    const rpc = capturingRpcService()
+    await (ws as any).invokeStepRpc(
+      runId,
+      'deploy',
+      stepState,
+      'deployByStageKind',
+      {},
+      rpc.service
+    )
+
+    assert.equal(
+      rpc.wire().pikkuUserId,
+      'user-abc',
+      'the step wire override carries the run wire pikkuUserId so authed steps rehydrate'
+    )
+    assert.ok(rpc.wire().workflowStep, 'workflowStep provenance is still present')
+  })
+
+  test('no pikkuUserId key is injected when the run wire has none', async () => {
+    pikkuState(null, 'package', 'singletonServices', { logger: silentLogger } as any)
+
+    const ws = new InMemoryWorkflowService()
+    const runId = await ws.createRun('flow', {}, false, 'hash', { type: 'test' })
+    await ws.insertStepState(runId, 'noauth', 'someFn', {})
+    const stepState = await ws.getStepState(runId, 'noauth')
+
+    const rpc = capturingRpcService()
+    await (ws as any).invokeStepRpc(runId, 'noauth', stepState, 'someFn', {}, rpc.service)
+
+    assert.ok(
+      !('pikkuUserId' in rpc.wire()),
+      'no undefined pikkuUserId is added when the run wire lacks one'
+    )
+  })
+})