@sprinterai/runtime 0.4.1 → 0.5.0

package/dist/workflow/workflow-runner.test.js

@@ -0,0 +1,657 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { runWorkflow } from './workflow-runner.js';
+// ─── In-Memory Mock Store ──────────────────────────────────────
+function createMockStore() {
+    const runs = [];
+    const nodeRuns = [];
+    let runCounter = 0;
+    let nodeCounter = 0;
+    return {
+        runs,
+        nodeRuns,
+        async listWorkflowRuns() {
+            return runs;
+        },
+        async getWorkflowRun(id) {
+            return runs.find((r) => r.id === id) ?? null;
+        },
+        async getNodeRuns(workflowRunId) {
+            return nodeRuns.filter((n) => n.workflow_run_id === workflowRunId);
+        },
+        async createWorkflowRun(input) {
+            runCounter++;
+            const run = {
+                id: `run-${runCounter}`,
+                entity_id: input.entityId,
+                tenant_id: input.tenantId,
+                status: 'pending',
+                trigger_type: input.triggerType,
+                started_at: new Date().toISOString(),
+                completed_at: null,
+                duration_ms: null,
+                metadata: input.metadata ?? null,
+                created_at: new Date().toISOString(),
+            };
+            runs.push(run);
+            return run;
+        },
+        async createNodeRuns(inputs) {
+            const created = [];
+            for (const input of inputs) {
+                nodeCounter++;
+                const nodeRun = {
+                    id: `nr-${nodeCounter}`,
+                    workflow_run_id: input.workflowRunId,
+                    entity_id: input.entityId,
+                    tenant_id: input.tenantId,
+                    node_key: input.nodeKey,
+                    node_type: input.nodeType,
+                    label: input.label,
+                    field_name: input.fieldName ?? null,
+                    block_id: input.blockId ?? null,
+                    output_type: input.outputType,
+                    status: input.status,
+                    assignee_type: input.assigneeType ?? null,
+                    assignee_agent_slug: input.assigneeAgentSlug ?? null,
+                    depends_on: input.dependsOn ?? null,
+                    instructions: input.instructions ?? null,
+                    metadata: null,
+                    error_message: null,
+                    claimed_by: null,
+                    claimed_at: null,
+                    attempt_count: 0,
+                    started_at: null,
+                    completed_at: null,
+                    duration_ms: null,
+                    created_at: new Date().toISOString(),
+                };
+                nodeRuns.push(nodeRun);
+                created.push(nodeRun);
+            }
+            return created;
+        },
+        async updateNodeRun(nodeRunId, updates) {
+            const node = nodeRuns.find((n) => n.id === nodeRunId);
+            if (!node)
+                return;
+            if (updates.status !== undefined)
+                node.status = updates.status;
+            if (updates.errorMessage !== undefined)
+                node.error_message = updates.errorMessage;
+            if (updates.startedAt !== undefined)
+                node.started_at = updates.startedAt;
+            if (updates.completedAt !== undefined)
+                node.completed_at = updates.completedAt;
+            if (updates.durationMs !== undefined)
+                node.duration_ms = updates.durationMs;
+            if (updates.attemptCount !== undefined)
+                node.attempt_count = updates.attemptCount;
+        },
+        async claimNodeRun(nodeRunId, claimedBy) {
+            const node = nodeRuns.find((n) => n.id === nodeRunId);
+            if (!node || node.claimed_by)
+                return null;
+            node.claimed_by = claimedBy;
+            node.claimed_at = new Date().toISOString();
+            return node;
+        },
+        async completeWorkflowRun(runId, status, durationMs) {
+            const run = runs.find((r) => r.id === runId);
+            if (!run)
+                return;
+            run.status = status;
+            run.completed_at = new Date().toISOString();
+            if (durationMs !== undefined)
+                run.duration_ms = durationMs;
+        },
+        async getClaimableNodes(tenantId, agentSlug) {
+            return nodeRuns.filter((n) => n.tenant_id === tenantId &&
+                n.status === 'pending' &&
+                (!agentSlug || n.assignee_agent_slug === agentSlug));
+        },
+        async expireStaleNodeClaims() {
+            return [];
+        },
+    };
+}
+// ─── Test Helpers ──────────────────────────────────────────────
+function successExecutor(extractedFields, content) {
+    return async (ctx) => ({
+        success: true,
+        fieldsExtracted: extractedFields ?? (ctx.node.field_name ? [ctx.node.field_name] : []),
+        updatedContent: content ??
+            (ctx.node.field_name ? { [ctx.node.field_name]: `extracted-${ctx.node.field_name}` } : {}),
+    });
+}
+function failingExecutor(error) {
+    return async () => ({
+        success: false,
+        fieldsExtracted: [],
+        error,
+    });
+}
+function throwingExecutor(error) {
+    return async () => {
+        throw new Error(error);
+    };
+}
+function makeDefinition(nodes) {
+    return { nodes };
+}
+function makeBaseOptions(store, definition, executeNode, overrides = {}) {
+    return {
+        entityId: 'ent-1',
+        tenantId: 'ten-1',
+        definition,
+        entityContent: {},
+        store,
+        executeNode,
+        ...overrides,
+    };
+}
+// ─── Tests ──────────────────────────────────────────────────────
+describe('runWorkflow', () => {
+    let store;
+    beforeEach(() => {
+        store = createMockStore();
+    });
+    describe('empty workflow', () => {
+        it('completes immediately with no nodes', async () => {
+            const definition = makeDefinition([]);
+            const result = await runWorkflow(makeBaseOptions(store, definition, successExecutor()));
+            expect(result.status).toBe('completed');
+            expect(result.fieldsExtracted).toEqual([]);
+            expect(result.claimedNodeCount).toBe(0);
+            expect(Object.keys(result.errors)).toHaveLength(0);
+        });
+    });
+    describe('simple linear workflow (A -> B -> C)', () => {
+        const definition = makeDefinition([
+            {
+                key: 'agent_task:title',
+                type: 'agent_task',
+                label: 'Extract title',
+                fieldName: 'title',
+                outputType: 'field',
+                dependsOn: [],
+                assigneeType: 'agent',
+            },
+            {
+                key: 'agent_task:summary',
+                type: 'agent_task',
+                label: 'Extract summary',
+                fieldName: 'summary',
+                outputType: 'field',
+                dependsOn: ['agent_task:title'],
+                assigneeType: 'agent',
+            },
+            {
+                key: 'agent_task:tags',
+                type: 'agent_task',
+                label: 'Extract tags',
+                fieldName: 'tags',
+                outputType: 'field',
+                dependsOn: ['agent_task:summary'],
+                assigneeType: 'agent',
+            },
+        ]);
+        it('executes all nodes in order', async () => {
+            const executionOrder = [];
+            const executor = async (ctx) => {
+                executionOrder.push(ctx.node.node_key);
+                return {
+                    success: true,
+                    fieldsExtracted: ctx.node.field_name ? [ctx.node.field_name] : [],
+                    updatedContent: ctx.node.field_name
+                        ? { [ctx.node.field_name]: `extracted-${ctx.node.field_name}` }
+                        : {},
+                };
+            };
+            const result = await runWorkflow(makeBaseOptions(store, definition, executor));
+            expect(result.status).toBe('completed');
+            expect(result.fieldsExtracted).toEqual(['title', 'summary', 'tags']);
+            expect(result.claimedNodeCount).toBe(3);
+            expect(executionOrder).toEqual(['agent_task:title', 'agent_task:summary', 'agent_task:tags']);
+        });
+        it('creates workflow run and node runs in store', async () => {
+            await runWorkflow(makeBaseOptions(store, definition, successExecutor()));
+            expect(store.runs).toHaveLength(1);
+            expect(store.runs[0].status).toBe('completed');
+            expect(store.nodeRuns).toHaveLength(3);
+            expect(store.nodeRuns.every((n) => n.status === 'completed')).toBe(true);
+        });
+    });
+    describe('parallel nodes', () => {
+        const definition = makeDefinition([
+            {
+                key: 'agent_task:title',
+                type: 'agent_task',
+                label: 'Extract title',
+                fieldName: 'title',
+                outputType: 'field',
+                dependsOn: [],
+                assigneeType: 'agent',
+            },
+            {
+                key: 'agent_task:author',
+                type: 'agent_task',
+                label: 'Extract author',
+                fieldName: 'author',
+                outputType: 'field',
+                dependsOn: [],
+                assigneeType: 'agent',
+            },
+            {
+                key: 'agent_task:summary',
+                type: 'agent_task',
+                label: 'Extract summary',
+                fieldName: 'summary',
+                outputType: 'field',
+                dependsOn: ['agent_task:title', 'agent_task:author'],
+                assigneeType: 'agent',
+            },
+        ]);
+        it('executes parallel nodes in the same iteration', async () => {
+            const executionOrder = [];
+            const executor = async (ctx) => {
+                executionOrder.push(ctx.node.node_key);
+                return {
+                    success: true,
+                    fieldsExtracted: ctx.node.field_name ? [ctx.node.field_name] : [],
+                    updatedContent: ctx.node.field_name
+                        ? { [ctx.node.field_name]: `val-${ctx.node.field_name}` }
+                        : {},
+                };
+            };
+            const result = await runWorkflow(makeBaseOptions(store, definition, executor));
+            expect(result.status).toBe('completed');
+            expect(result.fieldsExtracted).toContain('title');
+            expect(result.fieldsExtracted).toContain('author');
+            expect(result.fieldsExtracted).toContain('summary');
+            expect(result.claimedNodeCount).toBe(3);
+            // title and author should be in the first batch (before summary)
+            const titleIdx = executionOrder.indexOf('agent_task:title');
+            const authorIdx = executionOrder.indexOf('agent_task:author');
+            const summaryIdx = executionOrder.indexOf('agent_task:summary');
+            expect(summaryIdx).toBeGreaterThan(titleIdx);
+            expect(summaryIdx).toBeGreaterThan(authorIdx);
+        });
+    });
+    describe('wait_human nodes', () => {
+        const definition = makeDefinition([
+            {
+                key: 'wait_human:notes',
+                type: 'wait_human',
+                label: 'Human notes',
+                fieldName: 'notes',
+                outputType: 'field',
+                dependsOn: [],
+                assigneeType: 'human',
+            },
+            {
+                key: 'agent_task:summary',
+                type: 'agent_task',
+                label: 'Extract summary',
+                fieldName: 'summary',
+                outputType: 'field',
+                dependsOn: ['wait_human:notes'],
+                assigneeType: 'agent',
+            },
+        ]);
+        it('blocks dependent nodes when wait_human is not populated', async () => {
+            const result = await runWorkflow(makeBaseOptions(store, definition, successExecutor()));
+            // The workflow should end as waiting_human since the human node is unsatisfied
+            expect(result.status).toBe('waiting_human');
+            expect(result.fieldsExtracted).toEqual([]);
+            expect(result.claimedNodeCount).toBe(0);
+            // notes should be waiting_human, summary should be blocked
+            const notesNode = store.nodeRuns.find((n) => n.node_key === 'wait_human:notes');
+            const summaryNode = store.nodeRuns.find((n) => n.node_key === 'agent_task:summary');
+            expect(notesNode?.status).toBe('waiting_human');
+            expect(summaryNode?.status).toBe('blocked');
+        });
+        it('proceeds when wait_human field is already populated', async () => {
+            const result = await runWorkflow(makeBaseOptions(store, definition, successExecutor(), {
+                entityContent: { notes: 'User provided notes' },
+            }));
+            expect(result.status).toBe('completed');
+            expect(result.fieldsExtracted).toContain('summary');
+            expect(result.claimedNodeCount).toBe(1); // only summary was executed
+        });
+    });
+    describe('already-populated fields', () => {
+        const definition = makeDefinition([
+            {
+                key: 'agent_task:title',
+                type: 'agent_task',
+                label: 'Extract title',
+                fieldName: 'title',
+                outputType: 'field',
+                dependsOn: [],
+                assigneeType: 'agent',
+            },
+            {
+                key: 'agent_task:summary',
+                type: 'agent_task',
+                label: 'Extract summary',
+                fieldName: 'summary',
+                outputType: 'field',
+                dependsOn: ['agent_task:title'],
+                assigneeType: 'agent',
+            },
+        ]);
+        it('skips nodes whose fields are already populated', async () => {
+            const result = await runWorkflow(makeBaseOptions(store, definition, successExecutor(), {
+                entityContent: { title: 'Already have a title' },
+            }));
+            expect(result.status).toBe('completed');
+            // title was skipped, summary was extracted
+            expect(result.fieldsExtracted).toContain('summary');
+            expect(result.claimedNodeCount).toBe(1);
+        });
+        it('skips all nodes when all fields populated', async () => {
+            const result = await runWorkflow(makeBaseOptions(store, definition, successExecutor(), {
+                entityContent: { title: 'Title', summary: 'Summary' },
+            }));
+            expect(result.status).toBe('completed');
+            expect(result.fieldsExtracted).toEqual([]);
+            expect(result.claimedNodeCount).toBe(0);
+        });
+    });
+    describe('force re-extraction', () => {
+        const definition = makeDefinition([
+            {
+                key: 'agent_task:title',
+                type: 'agent_task',
+                label: 'Extract title',
+                fieldName: 'title',
+                outputType: 'field',
+                dependsOn: [],
+                assigneeType: 'agent',
+            },
+        ]);
+        it('re-extracts populated fields when force=true', async () => {
+            const result = await runWorkflow(makeBaseOptions(store, definition, successExecutor(), {
+                entityContent: { title: 'Old title' },
+                force: true,
+            }));
+            expect(result.status).toBe('completed');
+            expect(result.fieldsExtracted).toContain('title');
+            expect(result.claimedNodeCount).toBe(1);
+        });
+    });
+    describe('field filtering', () => {
+        const definition = makeDefinition([
+            {
+                key: 'agent_task:title',
+                type: 'agent_task',
+                label: 'Extract title',
+                fieldName: 'title',
+                outputType: 'field',
+                dependsOn: [],
+                assigneeType: 'agent',
+            },
+            {
+                key: 'agent_task:summary',
+                type: 'agent_task',
+                label: 'Extract summary',
+                fieldName: 'summary',
+                outputType: 'field',
+                dependsOn: ['agent_task:title'],
+                assigneeType: 'agent',
+            },
+            {
+                key: 'agent_task:tags',
+                type: 'agent_task',
+                label: 'Extract tags',
+                fieldName: 'tags',
+                outputType: 'field',
+                dependsOn: [],
+                assigneeType: 'agent',
+            },
+        ]);
+        it('only processes requested fields and their dependencies', async () => {
+            const executionOrder = [];
+            const executor = async (ctx) => {
+                executionOrder.push(ctx.node.node_key);
+                return {
+                    success: true,
+                    fieldsExtracted: ctx.node.field_name ? [ctx.node.field_name] : [],
+                    updatedContent: ctx.node.field_name
+                        ? { [ctx.node.field_name]: `val-${ctx.node.field_name}` }
+                        : {},
+                };
+            };
+            const result = await runWorkflow(makeBaseOptions(store, definition, executor, {
+                fields: ['summary'],
+            }));
+            expect(result.status).toBe('completed');
+            // Should include title (dependency) and summary, but not tags
+            expect(executionOrder).toContain('agent_task:title');
+            expect(executionOrder).toContain('agent_task:summary');
+            expect(executionOrder).not.toContain('agent_task:tags');
+            // Only 2 node runs should have been created
+            expect(store.nodeRuns).toHaveLength(2);
+        });
+    });
+    describe('error handling', () => {
+        const definition = makeDefinition([
+            {
+                key: 'agent_task:title',
+                type: 'agent_task',
+                label: 'Extract title',
+                fieldName: 'title',
+                outputType: 'field',
+                dependsOn: [],
+                assigneeType: 'agent',
+            },
+            {
+                key: 'agent_task:summary',
+                type: 'agent_task',
+                label: 'Extract summary',
+                fieldName: 'summary',
+                outputType: 'field',
+                dependsOn: [],
+                assigneeType: 'agent',
+            },
+        ]);
+        it('handles executor returning failure', async () => {
+            const result = await runWorkflow(makeBaseOptions(store, definition, failingExecutor('API timeout')));
+            expect(result.status).toBe('failed');
+            expect(result.errors['agent_task:title']).toBe('API timeout');
+            expect(result.errors['agent_task:summary']).toBe('API timeout');
+            expect(result.claimedNodeCount).toBe(2);
+        });
+        it('handles executor throwing an exception', async () => {
+            const result = await runWorkflow(makeBaseOptions(store, definition, throwingExecutor('Network error')));
+            expect(result.status).toBe('failed');
+            expect(result.errors['agent_task:title']).toBe('Network error');
+        });
+        it('partial completion when some nodes fail', async () => {
+            const mixedExecutor = async (ctx) => {
+                if (ctx.node.node_key === 'agent_task:title') {
+                    return {
+                        success: true,
+                        fieldsExtracted: ['title'],
+                        updatedContent: { title: 'Extracted' },
+                    };
+                }
+                return {
+                    success: false,
+                    fieldsExtracted: [],
+                    error: 'Failed to extract',
+                };
+            };
+            const result = await runWorkflow(makeBaseOptions(store, definition, mixedExecutor));
+            expect(result.status).toBe('partial');
+            expect(result.fieldsExtracted).toContain('title');
+            expect(result.errors['agent_task:summary']).toBe('Failed to extract');
+        });
+    });
+    describe('node claim racing', () => {
+        it('handles claim returning null (already claimed)', async () => {
+            const definition = makeDefinition([
+                {
+                    key: 'agent_task:title',
+                    type: 'agent_task',
+                    label: 'Extract title',
+                    fieldName: 'title',
+                    outputType: 'field',
+                    dependsOn: [],
+                    assigneeType: 'agent',
+                },
+            ]);
+            // Override claimNodeRun to always return null (simulating race condition)
+            store.claimNodeRun = async () => null;
+            const result = await runWorkflow(makeBaseOptions(store, definition, successExecutor()));
+            // Should complete but with 0 claimed nodes since claim always failed
+            expect(result.claimedNodeCount).toBe(0);
+        });
+    });
+    describe('event bus integration', () => {
+        it('emits workflow.started and workflow.completed events', async () => {
+            const definition = makeDefinition([
+                {
+                    key: 'agent_task:title',
+                    type: 'agent_task',
+                    label: 'Extract title',
+                    fieldName: 'title',
+                    outputType: 'field',
+                    dependsOn: [],
+                    assigneeType: 'agent',
+                },
+            ]);
+            const events = [];
+            const mockEventBus = {
+                emit: async (type, data) => {
+                    events.push({ type, data });
+                },
+                on: () => () => { },
+                onAny: () => () => { },
+                removeAllListeners: () => { },
+            };
+            await runWorkflow(makeBaseOptions(store, definition, successExecutor(), {
+                eventBus: mockEventBus,
+            }));
+            const eventTypes = events.map((e) => e.type);
+            expect(eventTypes).toContain('workflow.started');
+            expect(eventTypes).toContain('workflow.node_completed');
+            expect(eventTypes).toContain('workflow.completed');
+        });
+        it('works without event bus', async () => {
+            const definition = makeDefinition([
+                {
+                    key: 'agent_task:title',
+                    type: 'agent_task',
+                    label: 'Extract title',
+                    fieldName: 'title',
+                    outputType: 'field',
+                    dependsOn: [],
+                    assigneeType: 'agent',
+                },
+            ]);
+            const result = await runWorkflow(makeBaseOptions(store, definition, successExecutor()));
+            expect(result.status).toBe('completed');
+        });
+    });
+    describe('trigger metadata', () => {
+        it('stores triggeredBy in workflow run metadata', async () => {
+            const definition = makeDefinition([]);
+            await runWorkflow(makeBaseOptions(store, definition, successExecutor(), {
+                triggeredBy: 'user-123',
+                triggerType: 'manual',
+            }));
+            expect(store.runs[0].metadata).toEqual({ triggeredBy: 'user-123' });
+            expect(store.runs[0].trigger_type).toBe('manual');
+        });
+    });
+    describe('duration tracking', () => {
+        it('records workflow run duration', async () => {
+            const definition = makeDefinition([
+                {
+                    key: 'agent_task:title',
+                    type: 'agent_task',
+                    label: 'Extract title',
+                    fieldName: 'title',
+                    outputType: 'field',
+                    dependsOn: [],
+                    assigneeType: 'agent',
+                },
+            ]);
+            await runWorkflow(makeBaseOptions(store, definition, successExecutor()));
+            expect(store.runs[0].duration_ms).toBeGreaterThanOrEqual(0);
+            expect(store.runs[0].completed_at).not.toBeNull();
+        });
+        it('records node run duration on success', async () => {
+            const definition = makeDefinition([
+                {
+                    key: 'agent_task:title',
+                    type: 'agent_task',
+                    label: 'Extract title',
+                    fieldName: 'title',
+                    outputType: 'field',
+                    dependsOn: [],
+                    assigneeType: 'agent',
+                },
+            ]);
+            await runWorkflow(makeBaseOptions(store, definition, successExecutor()));
+            const nodeRun = store.nodeRuns[0];
+            expect(nodeRun.duration_ms).toBeGreaterThanOrEqual(0);
+            expect(nodeRun.completed_at).not.toBeNull();
+            expect(nodeRun.started_at).not.toBeNull();
+        });
+        it('records node run duration on failure', async () => {
+            const definition = makeDefinition([
+                {
+                    key: 'agent_task:title',
+                    type: 'agent_task',
+                    label: 'Extract title',
+                    fieldName: 'title',
+                    outputType: 'field',
+                    dependsOn: [],
+                    assigneeType: 'agent',
+                },
+            ]);
+            await runWorkflow(makeBaseOptions(store, definition, failingExecutor('error')));
+            const nodeRun = store.nodeRuns[0];
+            expect(nodeRun.duration_ms).toBeGreaterThanOrEqual(0);
+            expect(nodeRun.status).toBe('failed');
+        });
+    });
+    describe('safety: infinite loop protection', () => {
+        it('stops after max iterations', async () => {
+            const definition = makeDefinition([
+                {
+                    key: 'agent_task:title',
+                    type: 'agent_task',
+                    label: 'Extract title',
+                    fieldName: 'title',
+                    outputType: 'field',
+                    dependsOn: [],
+                    assigneeType: 'agent',
+                },
+            ]);
+            // An executor that always succeeds but doesn't update content,
+            // AND we make the store always re-create the node as pending
+            // by resetting status after each update
+            let executionCount = 0;
+            const nonTerminatingExecutor = async () => {
+                executionCount++;
+                return {
+                    success: true,
+                    fieldsExtracted: [],
+                    // Deliberately don't return updatedContent so field stays empty
+                };
+            };
+            const result = await runWorkflow(makeBaseOptions(store, definition, nonTerminatingExecutor));
+            // Should terminate due to max iterations, not infinite loop
+            // After first execution, node becomes completed but field stays empty.
+            // On next evaluation, the node gets set back to pending (no field value).
+            // However, since we claimed it already, claimNodeRun returns null (already claimed).
+            // So the loop breaks because no nodes could be executed.
+            expect(executionCount).toBeGreaterThanOrEqual(1);
+            expect(result.runId).toBeDefined();
+        });
+    });
+});
+//# sourceMappingURL=workflow-runner.test.js.map