Superglue MCP

import { ApiConfig, ExecutionStep, HttpMethod, Tool } from '@superglue/shared'; import { describe, expect, it } from 'vitest'; import { ToolExecutor } from './tool-executor.js'; describe('ToolExecutor - Failure Behavior', () => { describe('Loop Steps with FAIL behavior (default)', () => { it('should stop execution on first failure in loop', async () => { const mockApiConfig: ApiConfig = { id: 'test-api', urlHost: 'https://api.example.com', urlPath: '/test', method: HttpMethod.GET, instruction: 'Test endpoint that fails on second iteration', }; const step: ExecutionStep = { id: 'testStep', apiConfig: mockApiConfig, loopSelector: '(sourceData) => [1, 2, 3]', // Will try 3 iterations failureBehavior: 'FAIL', // Explicit default }; const tool: Tool = { id: 'test-tool', steps: [step], finalTransform: '(sourceData) => sourceData', integrationIds: [], }; const executor = new ToolExecutor({ tool, metadata: { traceId: 'test-trace', orgId: '' }, integrations: [], }); // Mock the strategy registry to fail on second iteration let callCount = 0; (executor as any).strategyRegistry = { routeAndExecute: async () => { callCount++; if (callCount === 2) { return { success: false, error: 'Simulated failure on iteration 2' }; } return { success: true, strategyExecutionData: { result: `iteration ${callCount}` } }; }, }; const result = await executor.execute({ payload: {}, credentials: {}, options: {}, }); expect(result.success).toBe(false); expect(result.error).toContain('Simulated failure'); expect(callCount).toBe(2); // Should only reach 2nd iteration before failing }); }); describe('Loop Steps with CONTINUE behavior', () => { it('should continue execution through all iterations despite failures', async () => { const mockApiConfig: ApiConfig = { id: 'test-api', urlHost: 'https://api.example.com', urlPath: '/test', method: HttpMethod.GET, instruction: 'Test endpoint that fails on some iterations', }; const step: ExecutionStep = { id: 'testStep', apiConfig: mockApiConfig, loopSelector: '(sourceData) => [1, 2, 3, 4, 5]', failureBehavior: 'CONTINUE', }; const tool: Tool = { id: 'test-tool', steps: [step], finalTransform: '(sourceData) => sourceData', integrationIds: [], }; const executor = new ToolExecutor({ tool, metadata: { traceId: 'test-trace', orgId: '' }, integrations: [], }); // Mock the strategy registry to fail on iterations 2 and 4 let callCount = 0; (executor as any).strategyRegistry = { routeAndExecute: async () => { callCount++; if (callCount === 2 || callCount === 4) { return { success: false, error: `Simulated failure on iteration ${callCount}` }; } return { success: true, strategyExecutionData: { result: `success on iteration ${callCount}` } }; }, }; const result = await executor.execute({ payload: {}, credentials: {}, options: {}, }); // Workflow should succeed overall expect(result.success).toBe(true); // Step should succeed const stepResult = result.stepResults[0]; expect(stepResult.success).toBe(true); // All 5 iterations should be executed expect(callCount).toBe(5); // Check result structure - data should be array of objects with currentItem, data, and success expect(Array.isArray(stepResult.data)).toBe(true); expect(stepResult.data).toHaveLength(5); // Verify successful iterations expect(stepResult.data[0].success).toBe(true); expect(stepResult.data[0].data).toEqual({ result: 'success on iteration 1' }); expect(stepResult.data[2].success).toBe(true); expect(stepResult.data[2].data).toEqual({ result: 'success on iteration 3' }); expect(stepResult.data[4].success).toBe(true); expect(stepResult.data[4].data).toEqual({ result: 'success on iteration 5' }); // Verify failed iterations expect(stepResult.data[1].success).toBe(false); expect(stepResult.data[1].data).toBe(null); expect(stepResult.data[1].error).toContain('Simulated failure on iteration 2'); expect(stepResult.data[3].success).toBe(false); expect(stepResult.data[3].data).toBe(null); expect(stepResult.data[3].error).toContain('Simulated failure on iteration 4'); }); it('should include currentItem in both successful and failed iterations', async () => { const mockApiConfig: ApiConfig = { id: 'test-api', urlHost: 'https://api.example.com', urlPath: '/test', method: HttpMethod.GET, instruction: 'Test endpoint', }; const step: ExecutionStep = { id: 'testStep', apiConfig: mockApiConfig, loopSelector: '(sourceData) => [{id: 1, name: "Alice"}, {id: 2, name: "Bob"}, {id: 3, name: "Charlie"}]', failureBehavior: 'CONTINUE', }; const tool: Tool = { id: 'test-tool', steps: [step], finalTransform: '(sourceData) => sourceData', integrationIds: [], }; const executor = new ToolExecutor({ tool, metadata: { traceId: 'test-trace', orgId: '' }, integrations: [], }); let callCount = 0; (executor as any).strategyRegistry = { routeAndExecute: async () => { callCount++; if (callCount === 2) { return { success: false, error: 'Bob failed' }; } return { success: true, strategyExecutionData: { processed: true } }; }, }; const result = await executor.execute({ payload: {}, credentials: {}, options: {}, }); expect(result.success).toBe(true); const stepResult = result.stepResults[0]; // Check currentItem is preserved for all iterations expect(stepResult.data[0].currentItem).toEqual({id: 1, name: "Alice"}); expect(stepResult.data[0].success).toBe(true); expect(stepResult.data[1].currentItem).toEqual({id: 2, name: "Bob"}); expect(stepResult.data[1].success).toBe(false); expect(stepResult.data[1].error).toContain('Bob failed'); expect(stepResult.data[2].currentItem).toEqual({id: 3, name: "Charlie"}); expect(stepResult.data[2].success).toBe(true); }); }); describe('Direct Steps with CONTINUE behavior', () => { it('should mark step as successful even when execution fails', async () => { const mockApiConfig: ApiConfig = { id: 'test-api', urlHost: 'https://api.example.com', urlPath: '/test', method: HttpMethod.GET, instruction: 'Test endpoint that will fail', }; const step: ExecutionStep = { id: 'testStep', apiConfig: mockApiConfig, loopSelector: '(sourceData) => ({})', // Returns object for direct execution failureBehavior: 'CONTINUE', }; const tool: Tool = { id: 'test-tool', steps: [step], finalTransform: '(sourceData) => sourceData', integrationIds: [], }; const executor = new ToolExecutor({ tool, metadata: { traceId: 'test-trace', orgId: '' }, integrations: [], }); (executor as any).strategyRegistry = { routeAndExecute: async () => { return { success: false, error: 'Direct execution failed' }; }, }; const result = await executor.execute({ payload: {}, credentials: {}, options: {}, }); // Workflow should succeed overall expect(result.success).toBe(true); // Step should succeed const stepResult = result.stepResults[0]; expect(stepResult.success).toBe(true); // But data should indicate the failure expect(stepResult.data.success).toBe(false); expect(stepResult.data.data).toBe(null); expect(stepResult.data.error).toContain('Direct execution failed'); }); }); describe('Multi-step workflows with mixed failure behaviors', () => { it('should continue workflow when first step has CONTINUE behavior and fails', async () => { const mockApiConfig1: ApiConfig = { id: 'test-api-1', urlHost: 'https://api.example.com', urlPath: '/test1', method: HttpMethod.GET, instruction: 'First step that may fail', }; const mockApiConfig2: ApiConfig = { id: 'test-api-2', urlHost: 'https://api.example.com', urlPath: '/test2', method: HttpMethod.GET, instruction: 'Second step', }; const step1: ExecutionStep = { id: 'step1', apiConfig: mockApiConfig1, loopSelector: '(sourceData) => ({})', failureBehavior: 'CONTINUE', }; const step2: ExecutionStep = { id: 'step2', apiConfig: mockApiConfig2, loopSelector: '(sourceData) => ({})', failureBehavior: 'FAIL', // Default behavior }; const tool: Tool = { id: 'test-tool', steps: [step1, step2], finalTransform: '(sourceData) => sourceData', integrationIds: [], }; const executor = new ToolExecutor({ tool, metadata: { traceId: 'test-trace', orgId: '' }, integrations: [], }); let stepExecuted = 0; (executor as any).strategyRegistry = { routeAndExecute: async () => { stepExecuted++; if (stepExecuted === 1) { return { success: false, error: 'Step 1 failed' }; } return { success: true, strategyExecutionData: { result: 'step 2 success' } }; }, }; const result = await executor.execute({ payload: {}, credentials: {}, options: {}, }); // Workflow should succeed expect(result.success).toBe(true); // Both steps should have executed expect(stepExecuted).toBe(2); expect(result.stepResults).toHaveLength(2); // Step 1 should succeed at step level but show failure in data expect(result.stepResults[0].success).toBe(true); expect(result.stepResults[0].data.success).toBe(false); // Step 2 should succeed normally expect(result.stepResults[1].success).toBe(true); expect(result.stepResults[1].data.success).toBe(true); }); it('should stop workflow when step with FAIL behavior fails', async () => { const mockApiConfig1: ApiConfig = { id: 'test-api-1', urlHost: 'https://api.example.com', urlPath: '/test1', method: HttpMethod.GET, instruction: 'First step', }; const mockApiConfig2: ApiConfig = { id: 'test-api-2', urlHost: 'https://api.example.com', urlPath: '/test2', method: HttpMethod.GET, instruction: 'Second step that will fail', }; const step1: ExecutionStep = { id: 'step1', apiConfig: mockApiConfig1, loopSelector: '(sourceData) => ({})', failureBehavior: 'CONTINUE', }; const step2: ExecutionStep = { id: 'step2', apiConfig: mockApiConfig2, loopSelector: '(sourceData) => ({})', failureBehavior: 'FAIL', }; const tool: Tool = { id: 'test-tool', steps: [step1, step2], finalTransform: '(sourceData) => sourceData', integrationIds: [], }; const executor = new ToolExecutor({ tool, metadata: { traceId: 'test-trace', orgId: '' }, integrations: [], }); let stepExecuted = 0; (executor as any).strategyRegistry = { routeAndExecute: async () => { stepExecuted++; if (stepExecuted === 2) { return { success: false, error: 'Step 2 failed' }; } return { success: true, strategyExecutionData: { result: 'success' } }; }, }; const result = await executor.execute({ payload: {}, credentials: {}, options: {}, }); // Workflow should fail expect(result.success).toBe(false); expect(result.error).toContain('Step 2 failed'); // Both steps should have executed expect(stepExecuted).toBe(2); expect(result.stepResults).toHaveLength(2); }); }); describe('Empty loops with CONTINUE behavior', () => { it('should handle empty loop arrays gracefully', async () => { const mockApiConfig: ApiConfig = { id: 'test-api', urlHost: 'https://api.example.com', urlPath: '/test', method: HttpMethod.GET, instruction: 'Test endpoint', }; const step: ExecutionStep = { id: 'testStep', apiConfig: mockApiConfig, loopSelector: '(sourceData) => []', // Empty array failureBehavior: 'CONTINUE', }; const tool: Tool = { id: 'test-tool', steps: [step], finalTransform: '(sourceData) => sourceData', integrationIds: [], }; const executor = new ToolExecutor({ tool, metadata: { traceId: 'test-trace', orgId: '' }, integrations: [], }); let callCount = 0; (executor as any).strategyRegistry = { routeAndExecute: async () => { callCount++; return { success: true, strategyExecutionData: { result: 'success' } }; }, }; const result = await executor.execute({ payload: {}, credentials: {}, options: {}, }); expect(result.success).toBe(true); expect(callCount).toBe(0); // No iterations should execute const stepResult = result.stepResults[0]; expect(stepResult.success).toBe(true); expect(stepResult.data).toEqual([]); }); }); });