@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/server/workflows/WorkflowContract.test.js

@@ -0,0 +1,197 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { BranchNodeBuilder, ParallelNodeBuilder, SequenceNodeBuilder, ToolNodeBuilder, WorkflowBuilder, createWorkflow, } from '../../../src/server/workflows/WorkflowContract.js';
+describe('workflows/WorkflowContract', () => {
+    beforeEach(() => {
+    });
+    it('builds tool nodes with input, retry, and timeout', () => {
+        const node = new ToolNodeBuilder('tool-1', 'page_navigate')
+            .input({ url: 'https://example.com' })
+            .retry({ maxAttempts: 2, backoffMs: 10, multiplier: 2 })
+            .timeout(500)
+            .build();
+        expect(node).toEqual({
+            kind: 'tool',
+            id: 'tool-1',
+            toolName: 'page_navigate',
+            input: { url: 'https://example.com' },
+            retry: { maxAttempts: 2, backoffMs: 10, multiplier: 2 },
+            timeoutMs: 500,
+        });
+    });
+    it('builds nested sequence and parallel graphs with defaults', () => {
+        const node = new SequenceNodeBuilder('root')
+            .tool('tool-1', 'page_navigate', (builder) => builder.input({ url: 'https://example.com' }))
+            .parallel('parallel-1', (builder) => {
+            builder.tool('tool-2', 'page_click');
+        })
+            .build();
+        expect(node).toEqual({
+            kind: 'sequence',
+            id: 'root',
+            steps: [
+                {
+                    kind: 'tool',
+                    id: 'tool-1',
+                    toolName: 'page_navigate',
+                    input: { url: 'https://example.com' },
+                    retry: undefined,
+                    timeoutMs: undefined,
+                },
+                {
+                    kind: 'parallel',
+                    id: 'parallel-1',
+                    steps: [
+                        {
+                            kind: 'tool',
+                            id: 'tool-2',
+                            toolName: 'page_click',
+                            input: undefined,
+                            retry: undefined,
+                            timeoutMs: undefined,
+                        },
+                    ],
+                    maxConcurrency: 4,
+                    failFast: false,
+                },
+            ],
+        });
+    });
+    it('requires branch nodes to define whenTrue', () => {
+        expect(() => new BranchNodeBuilder('branch-1', 'always_true').build()).toThrow("BranchNode 'branch-1' requires a whenTrue step");
+    });
+    it('requires workflows to define a graph before build', () => {
+        expect(() => new WorkflowBuilder('wf', 'Workflow').build()).toThrow("WorkflowBuilder 'wf' needs a buildGraph() function.");
+    });
+    it('creates complete workflow contracts from the helper builder', () => {
+        const workflow = createWorkflow('wf-1', 'Workflow')
+            .description('Runs a simple flow')
+            .tags(['demo'])
+            .timeoutMs(1000)
+            .defaultMaxConcurrency(3)
+            .buildGraph(() => new SequenceNodeBuilder('root').tool('tool-1', 'page_navigate'))
+            .build();
+        expect(workflow).toMatchObject({
+            kind: 'workflow-contract',
+            version: 1,
+            id: 'wf-1',
+            displayName: 'Workflow',
+            description: 'Runs a simple flow',
+            tags: ['demo'],
+            timeoutMs: 1000,
+            defaultMaxConcurrency: 3,
+        });
+        expect(workflow.build({})).toEqual({
+            kind: 'sequence',
+            id: 'root',
+            steps: [
+                {
+                    kind: 'tool',
+                    id: 'tool-1',
+                    toolName: 'page_navigate',
+                    input: undefined,
+                    retry: undefined,
+                    timeoutMs: undefined,
+                },
+            ],
+        });
+    });
+    it('SequenceNodeBuilder supports nested sequence via step()', () => {
+        const inner = new SequenceNodeBuilder('inner').tool('t1', 'tool_a');
+        const outer = new SequenceNodeBuilder('outer').step(inner).build();
+        expect(outer.steps[0]).toEqual({
+            kind: 'sequence',
+            id: 'inner',
+            steps: [{ kind: 'tool', id: 't1', toolName: 'tool_a', input: undefined, retry: undefined, timeoutMs: undefined }],
+        });
+    });
+    it('SequenceNodeBuilder supports nested sequence via sequence()', () => {
+        const node = new SequenceNodeBuilder('outer')
+            .sequence('inner', (b) => {
+            b.tool('t2', 'tool_b');
+        })
+            .build();
+        expect(node.steps[0]).toMatchObject({ kind: 'sequence', id: 'inner' });
+    });
+    it('SequenceNodeBuilder supports branch()', () => {
+        const node = new SequenceNodeBuilder('seq')
+            .branch('br', 'always_true', (b) => {
+            b.whenTrue(new ToolNodeBuilder('yes', 'tool_y'));
+        })
+            .build();
+        expect(node.steps[0]).toMatchObject({ kind: 'branch', id: 'br', predicateId: 'always_true' });
+    });
+    it('ParallelNodeBuilder supports sequence and parallel children', () => {
+        const node = new ParallelNodeBuilder('par')
+            .sequence('seq-child', (b) => b.tool('t', 'tool'))
+            .parallel('par-child')
+            .step(new ToolNodeBuilder('step-tool', 'tool_x'))
+            .maxConcurrency(8)
+            .failFast(true)
+            .build();
+        expect(node.maxConcurrency).toBe(8);
+        expect(node.failFast).toBe(true);
+        expect(node.steps).toHaveLength(3);
+        expect(node.steps[0]).toMatchObject({ kind: 'sequence' });
+        expect(node.steps[1]).toMatchObject({ kind: 'parallel' });
+        expect(node.steps[2]).toMatchObject({ kind: 'tool' });
+    });
+    it('ParallelNodeBuilder supports branch()', () => {
+        const node = new ParallelNodeBuilder('par')
+            .branch('br', 'pred', (b) => {
+            b.whenTrue(new ToolNodeBuilder('true-tool', 'tool'));
+            b.whenFalse(new ToolNodeBuilder('false-tool', 'tool'));
+        })
+            .build();
+        const branch = node.steps[0];
+        expect(branch.kind).toBe('branch');
+        expect(branch.whenFalse).toBeDefined();
+    });
+    it('BranchNodeBuilder supports predicateFn', () => {
+        const predFn = () => true;
+        const node = new BranchNodeBuilder('br', 'pred')
+            .predicateFn(predFn)
+            .whenTrue(new ToolNodeBuilder('true', 'tool'))
+            .whenFalse(new ToolNodeBuilder('false', 'tool'))
+            .build();
+        expect(node.predicateFn).toBe(predFn);
+        expect(node.whenTrue).toMatchObject({ kind: 'tool', id: 'true' });
+        expect(node.whenFalse).toMatchObject({ kind: 'tool', id: 'false' });
+    });
+    it('BranchNodeBuilder omits whenFalse when not set', () => {
+        const node = new BranchNodeBuilder('br', 'pred')
+            .whenTrue(new ToolNodeBuilder('t', 'tool'))
+            .build();
+        expect(node.whenFalse).toBeUndefined();
+    });
+    it('WorkflowBuilder supports lifecycle callbacks', () => {
+        let started = false;
+        let finished = false;
+        let errored = false;
+        const workflow = createWorkflow('wf', 'Test')
+            .buildGraph(() => new SequenceNodeBuilder('root'))
+            .onStart(() => { started = true; })
+            .onFinish(() => { finished = true; })
+            .onError(() => { errored = true; })
+            .build();
+        expect(workflow.onStart).toBeDefined();
+        expect(workflow.onFinish).toBeDefined();
+        expect(workflow.onError).toBeDefined();
+        workflow.onStart({});
+        workflow.onFinish({}, null);
+        workflow.onError({}, new Error('test'));
+        expect(started).toBe(true);
+        expect(finished).toBe(true);
+        expect(errored).toBe(true);
+    });
+    it('ToolNodeBuilder builds minimal node without optional fields', () => {
+        const node = new ToolNodeBuilder('t', 'tool_name').build();
+        expect(node).toEqual({
+            kind: 'tool',
+            id: 't',
+            toolName: 'tool_name',
+            input: undefined,
+            retry: undefined,
+            timeoutMs: undefined,
+        });
+    });
+});

package/dist/tests/server/workflows/WorkflowEngine.additional.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/server/workflows/WorkflowEngine.additional.test.js

@@ -0,0 +1,414 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { createWorkflow, SequenceNodeBuilder, ToolNodeBuilder, } from '../../../src/server/workflows/WorkflowContract.js';
+const state = vi.hoisted(() => ({
+    randomUUID: vi.fn(() => 'run-additional'),
+}));
+vi.mock('node:crypto', () => ({
+    randomUUID: state.randomUUID,
+}));
+function successResponse(payload = {}) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify({ success: true, ...payload }) }],
+    };
+}
+function failureResponse(error = 'fail') {
+    return {
+        content: [{ type: 'text', text: JSON.stringify({ success: false, error }) }],
+    };
+}
+function mcpErrorResponse(text = 'MCP error') {
+    return {
+        isError: true,
+        content: [{ type: 'text', text }],
+    };
+}
+function mockCtx(overrides = {}) {
+    return {
+        baseTier: 'workflow',
+        config: {},
+        executeToolWithTracking: vi.fn(async () => successResponse()),
+        ...overrides,
+    };
+}
+describe('WorkflowEngine additional coverage', () => {
+    beforeEach(() => {
+        vi.useRealTimers();
+        vi.resetModules();
+        vi.clearAllMocks();
+    });
+    it('getConfig returns fallback for non-object config', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        let configResult;
+        const workflow = createWorkflow('wf', 'Test')
+            .buildGraph((ctx) => {
+            configResult = ctx.getConfig('some.deep.path', 'default-val');
+            return new SequenceNodeBuilder('root');
+        })
+            .build();
+        await executeExtensionWorkflow(mockCtx({ config: null }), workflow);
+        expect(configResult).toBe('default-val');
+    });
+    it('getConfig returns fallback for missing nested segment', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        let configResult;
+        const workflow = createWorkflow('wf', 'Test')
+            .buildGraph((ctx) => {
+            configResult = ctx.getConfig('a.b.c', 42);
+            return new SequenceNodeBuilder('root');
+        })
+            .build();
+        await executeExtensionWorkflow(mockCtx({ config: { a: { x: 1 } } }), workflow);
+        expect(configResult).toBe(42);
+    });
+    it('getConfig traverses primitive intermediate segment', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        let configResult;
+        const workflow = createWorkflow('wf', 'Test')
+            .buildGraph((ctx) => {
+            configResult = ctx.getConfig('a.b', 'fallback');
+            return new SequenceNodeBuilder('root');
+        })
+            .build();
+        await executeExtensionWorkflow(mockCtx({ config: { a: 'string-not-object' } }), workflow);
+        expect(configResult).toBe('fallback');
+    });
+    it('detects MCP isError response and throws during tool execution', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        const ctx = mockCtx({
+            executeToolWithTracking: vi.fn(async () => mcpErrorResponse('tool crashed')),
+        });
+        const workflow = createWorkflow('wf', 'Test')
+            .buildGraph(() => new SequenceNodeBuilder('root').tool('t1', 'broken_tool'))
+            .build();
+        await expect(executeExtensionWorkflow(ctx, workflow)).rejects.toThrow('Tool returned MCP error response');
+    });
+    it('detects success=false without error string and throws generic message', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        const ctx = mockCtx({
+            executeToolWithTracking: vi.fn(async () => ({
+                content: [{ type: 'text', text: JSON.stringify({ success: false }) }],
+            })),
+        });
+        const workflow = createWorkflow('wf', 'Test')
+            .buildGraph(() => new SequenceNodeBuilder('root').tool('t1', 'bad_tool'))
+            .build();
+        await expect(executeExtensionWorkflow(ctx, workflow)).rejects.toThrow('Tool reported success=false');
+    });
+    it('handles non-object response gracefully (no crash)', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        const ctx = mockCtx({
+            executeToolWithTracking: vi.fn(async () => 'just a string'),
+        });
+        const workflow = createWorkflow('wf', 'Test')
+            .buildGraph(() => new SequenceNodeBuilder('root').tool('t1', 'tool'))
+            .build();
+        const result = await executeExtensionWorkflow(ctx, workflow);
+        expect(result.stepResults['t1']).toBe('just a string');
+    });
+    it('handles response with no text content', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        const ctx = mockCtx({
+            executeToolWithTracking: vi.fn(async () => ({
+                content: [{ type: 'image', data: 'binary' }],
+            })),
+        });
+        const workflow = createWorkflow('wf', 'Test')
+            .buildGraph(() => new SequenceNodeBuilder('root').tool('t1', 'tool'))
+            .build();
+        const result = await executeExtensionWorkflow(ctx, workflow);
+        expect(result.stepResults).toHaveProperty('t1');
+    });
+    it('handles response with non-JSON text', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        const ctx = mockCtx({
+            executeToolWithTracking: vi.fn(async () => ({
+                content: [{ type: 'text', text: 'not-json' }],
+            })),
+        });
+        const workflow = createWorkflow('wf', 'Test')
+            .buildGraph(() => new SequenceNodeBuilder('root').tool('t1', 'tool'))
+            .build();
+        const result = await executeExtensionWorkflow(ctx, workflow);
+        expect(result.stepResults).toHaveProperty('t1');
+    });
+    it('handles response with JSON primitive (not object)', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        const ctx = mockCtx({
+            executeToolWithTracking: vi.fn(async () => ({
+                content: [{ type: 'text', text: '"just a string"' }],
+            })),
+        });
+        const workflow = createWorkflow('wf', 'Test')
+            .buildGraph(() => new SequenceNodeBuilder('root').tool('t1', 'tool'))
+            .build();
+        const result = await executeExtensionWorkflow(ctx, workflow);
+        expect(result.stepResults).toHaveProperty('t1');
+    });
+    it('always_true predicate routes to whenTrue', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        const ctx = mockCtx();
+        const workflow = createWorkflow('wf', 'Test')
+            .buildGraph(() => new SequenceNodeBuilder('root').branch('br', 'always_true', (b) => {
+            b.whenTrue(new ToolNodeBuilder('yes', 'tool'));
+            b.whenFalse(new ToolNodeBuilder('no', 'tool'));
+        }))
+            .build();
+        const result = await executeExtensionWorkflow(ctx, workflow);
+        expect(result.stepResults).toHaveProperty('yes');
+        expect(result.stepResults).not.toHaveProperty('no');
+    });
+    it('any_step_failed predicate detects failure in prior steps', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        let callCount = 0;
+        const ctx = mockCtx({
+            executeToolWithTracking: vi.fn(async () => {
+                callCount++;
+                if (callCount === 1)
+                    return failureResponse('step failed');
+                return successResponse();
+            }),
+        });
+        const workflow = createWorkflow('wf', 'Test')
+            .buildGraph(() => new SequenceNodeBuilder('root')
+            .parallel('par', (b) => {
+            b.failFast(false);
+            b.tool('may-fail', 'tool');
+        })
+            .branch('br', 'any_step_failed', (b) => {
+            b.whenTrue(new ToolNodeBuilder('recovery', 'recover_tool'));
+            b.whenFalse(new ToolNodeBuilder('continue', 'next_tool'));
+        }))
+            .build();
+        const result = await executeExtensionWorkflow(ctx, workflow);
+        expect(result.stepResults).toHaveProperty('recovery');
+    });
+    it('success_rate_gte_N predicate evaluates correctly', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        let callCount = 0;
+        const ctx = mockCtx({
+            executeToolWithTracking: vi.fn(async () => {
+                callCount++;
+                if (callCount === 2)
+                    return failureResponse('one fails');
+                return successResponse();
+            }),
+        });
+        const workflow = createWorkflow('wf', 'Test')
+            .buildGraph(() => new SequenceNodeBuilder('root')
+            .parallel('par', (b) => {
+            b.failFast(false);
+            b.tool('t1', 'tool');
+            b.tool('t2', 'tool');
+            b.tool('t3', 'tool');
+            b.tool('t4', 'tool');
+        })
+            .branch('br', 'success_rate_gte_50', (b) => {
+            b.whenTrue(new ToolNodeBuilder('above', 'tool'));
+            b.whenFalse(new ToolNodeBuilder('below', 'tool'));
+        }))
+            .build();
+        const result = await executeExtensionWorkflow(ctx, workflow);
+        expect(result.stepResults).toHaveProperty('above');
+    });
+    it('success_rate_gte predicate returns false when no steps exist', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        const ctx = mockCtx();
+        const workflow = createWorkflow('wf', 'Test')
+            .buildGraph(() => new SequenceNodeBuilder('root').branch('br', 'success_rate_gte_50', (b) => {
+            b.whenTrue(new ToolNodeBuilder('above', 'tool'));
+            b.whenFalse(new ToolNodeBuilder('below', 'tool'));
+        }))
+            .build();
+        const result = await executeExtensionWorkflow(ctx, workflow);
+        expect(result.stepResults).toHaveProperty('below');
+    });
+    it('unknown predicate throws error', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        const ctx = mockCtx();
+        const workflow = createWorkflow('wf', 'Test')
+            .buildGraph(() => new SequenceNodeBuilder('root').branch('br', 'unknown_predicate', (b) => {
+            b.whenTrue(new ToolNodeBuilder('t', 'tool'));
+        }))
+            .build();
+        await expect(executeExtensionWorkflow(ctx, workflow)).rejects.toThrow('Unknown workflow predicateId "unknown_predicate"');
+    });
+    it('branch with false predicate and no whenFalse returns undefined', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        const ctx = mockCtx();
+        const workflow = createWorkflow('wf', 'Test')
+            .buildGraph(() => new SequenceNodeBuilder('root').branch('br', 'always_false', (b) => {
+            b.whenTrue(new ToolNodeBuilder('t', 'tool'));
+        }))
+            .build();
+        const result = await executeExtensionWorkflow(ctx, workflow);
+        expect(result.stepResults['br']).toBeUndefined();
+    });
+    it('parallel failFast stops on first error', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        const ctx = mockCtx({
+            executeToolWithTracking: vi.fn(async (name) => {
+                if (name === 'slow_fail') {
+                    throw new Error('hard crash');
+                }
+                return successResponse();
+            }),
+        });
+        const workflow = createWorkflow('wf', 'Test')
+            .buildGraph(() => new SequenceNodeBuilder('root').parallel('par', (b) => {
+            b.failFast(true);
+            b.maxConcurrency(1);
+            b.tool('ok', 'good_tool');
+            b.tool('crash', 'slow_fail');
+            b.tool('never', 'good_tool');
+        }))
+            .build();
+        await expect(executeExtensionWorkflow(ctx, workflow)).rejects.toThrow('hard crash');
+    });
+    it('exhausted retries throw the last error', async () => {
+        vi.useFakeTimers();
+        try {
+            const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+            const ctx = mockCtx({
+                executeToolWithTracking: vi.fn(async () => failureResponse('always fails')),
+            });
+            const workflow = createWorkflow('wf', 'Test')
+                .buildGraph(() => new SequenceNodeBuilder('root').tool('t', 'tool', (b) => b.retry({ maxAttempts: 2, backoffMs: 10, multiplier: 2 })))
+                .build();
+            const promise = executeExtensionWorkflow(ctx, workflow).catch((e) => e);
+            await vi.advanceTimersByTimeAsync(100);
+            const err = await promise;
+            expect(err).toBeInstanceOf(Error);
+            expect(err.message).toBe('always fails');
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+    it('tool node timeout triggers error', async () => {
+        vi.useFakeTimers();
+        try {
+            const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+            const ctx = mockCtx({
+                executeToolWithTracking: vi.fn(() => new Promise(() => undefined)),
+            });
+            const workflow = createWorkflow('wf', 'Test')
+                .buildGraph(() => new SequenceNodeBuilder('root').tool('t', 'tool', (b) => b.timeout(50)))
+                .build();
+            const promise = executeExtensionWorkflow(ctx, workflow).catch((e) => e);
+            await vi.advanceTimersByTimeAsync(60);
+            const err = await promise;
+            expect(err).toBeInstanceOf(Error);
+            expect(err.message).toContain('timed out after 50ms');
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+    it('onStart and onFinish are called in order', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        const calls = [];
+        const ctx = mockCtx();
+        const workflow = createWorkflow('wf', 'Test')
+            .buildGraph(() => new SequenceNodeBuilder('root').tool('t', 'tool'))
+            .onStart(() => { calls.push('start'); })
+            .onFinish(() => { calls.push('finish'); })
+            .build();
+        await executeExtensionWorkflow(ctx, workflow);
+        expect(calls).toEqual(['start', 'finish']);
+    });
+    it('onError called when workflow throws, and error is re-thrown', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        const onError = vi.fn();
+        const ctx = mockCtx({
+            executeToolWithTracking: vi.fn(async () => { throw new Error('boom'); }),
+        });
+        const workflow = createWorkflow('wf', 'Test')
+            .buildGraph(() => new SequenceNodeBuilder('root').tool('t', 'tool'))
+            .onError(onError)
+            .build();
+        await expect(executeExtensionWorkflow(ctx, workflow)).rejects.toThrow('boom');
+        expect(onError).toHaveBeenCalledWith(expect.objectContaining({ workflowRunId: 'run-additional' }), expect.objectContaining({ message: 'boom' }));
+    });
+    it('wraps non-Error throws into Error', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        const ctx = mockCtx({
+            executeToolWithTracking: vi.fn(async () => {
+                throw 'string error';
+            }),
+        });
+        const workflow = createWorkflow('wf', 'Test')
+            .buildGraph(() => new SequenceNodeBuilder('root').tool('t', 'tool'))
+            .build();
+        await expect(executeExtensionWorkflow(ctx, workflow)).rejects.toThrow('string error');
+    });
+    it('executionContext.invokeTool delegates to ctx.executeToolWithTracking', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        const executeFn = vi.fn(async () => successResponse());
+        const ctx = mockCtx({ executeToolWithTracking: executeFn });
+        const workflow = createWorkflow('wf', 'Test')
+            .buildGraph((execCtx) => {
+            void execCtx.invokeTool('test_tool', { arg: 1 });
+            return new SequenceNodeBuilder('root');
+        })
+            .build();
+        await executeExtensionWorkflow(ctx, workflow);
+        expect(executeFn).toHaveBeenCalledWith('test_tool', { arg: 1 });
+    });
+    it('emitMetric records metrics during execution', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        const ctx = mockCtx();
+        const workflow = createWorkflow('wf', 'Test')
+            .buildGraph((execCtx) => {
+            execCtx.emitMetric('my.counter', 1, 'counter', { tag: 'test' });
+            return new SequenceNodeBuilder('root');
+        })
+            .build();
+        const result = await executeExtensionWorkflow(ctx, workflow);
+        expect(result.metrics).toContainEqual(expect.objectContaining({ name: 'my.counter', value: 1, type: 'counter' }));
+    });
+    it('defaults profile to baseTier when not specified', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        const ctx = mockCtx({ baseTier: 'full' });
+        const workflow = createWorkflow('wf', 'Test')
+            .buildGraph(() => new SequenceNodeBuilder('root'))
+            .build();
+        const result = await executeExtensionWorkflow(ctx, workflow);
+        expect(result.profile).toBe('full');
+    });
+    it('uses explicit profile over baseTier', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        const ctx = mockCtx({ baseTier: 'full' });
+        const workflow = createWorkflow('wf', 'Test')
+            .buildGraph(() => new SequenceNodeBuilder('root'))
+            .build();
+        const result = await executeExtensionWorkflow(ctx, workflow, { profile: 'custom' });
+        expect(result.profile).toBe('custom');
+    });
+    it('non-finite timeout passes promise through without wrapping', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        const ctx = mockCtx();
+        const workflow = createWorkflow('wf', 'Test')
+            .timeoutMs(0)
+            .buildGraph(() => new SequenceNodeBuilder('root').tool('t', 'tool'))
+            .build();
+        const result = await executeExtensionWorkflow(ctx, workflow);
+        expect(result.stepResults).toHaveProperty('t');
+    });
+    it('error key in response triggers failure count in any_step_failed', async () => {
+        const { executeExtensionWorkflow } = await import('../../../src/server/workflows/WorkflowEngine.js');
+        const ctx = mockCtx({
+            executeToolWithTracking: vi.fn(async () => {
+                return { error: 'something went wrong' };
+            }),
+        });
+        const workflow = createWorkflow('wf', 'Test')
+            .buildGraph(() => new SequenceNodeBuilder('root')
+            .tool('errored', 'tool')
+            .branch('br', 'any_step_failed', (b) => {
+            b.whenTrue(new ToolNodeBuilder('detected', 'tool'));
+        }))
+            .build();
+        const result = await executeExtensionWorkflow(ctx, workflow);
+        expect(result.stepResults).toHaveProperty('detected');
+    });
+});

package/dist/tests/server/workflows/WorkflowEngine.test.d.ts

@@ -0,0 +1 @@
+export {};