@mondaydotcomorg/atp-server 0.17.14

package/src/executor/compiler-config.ts

@@ -0,0 +1,146 @@
+import type { Logger } from '@mondaydotcomorg/atp-runtime';
+import type { CacheProvider } from '@mondaydotcomorg/atp-protocol';
+import {
+	ATPCompiler,
+	initializeRuntime as initializeCompilerRuntime,
+	resumableForOf,
+	resumableWhile,
+	resumableForLoop,
+	resumableMap,
+	resumableForEach,
+	resumableFilter,
+	resumableReduce,
+	resumableFind,
+	resumableSome,
+	resumableEvery,
+	resumableFlatMap,
+	resumablePromiseAll,
+	resumablePromiseAllSettled,
+	batchParallel,
+} from '@mondaydotcomorg/atp-compiler';
+import { ATP_COMPILER_ENABLED, ATP_BATCH_SIZE_THRESHOLD } from './constants.js';
+
+const transformCache = new Map<string, string>();
+
+function getCodeHash(code: string): string {
+	let hash = 0;
+	for (let i = 0; i < code.length; i++) {
+		const char = code.charCodeAt(i);
+		hash = (hash << 5) - hash + char;
+		hash = hash & hash;
+	}
+	return hash.toString(36);
+}
+
+export interface CompilerResult {
+	code: string;
+	useCompiler: boolean;
+	metadata?: {
+		patterns?: string[];
+		batchable?: boolean;
+		loopCount?: number;
+		arrayMethodCount?: number;
+		parallelCallCount?: number;
+	};
+}
+
+export function getCompilerRuntime() {
+	return {
+		resumableForOf,
+		resumableWhile,
+		resumableForLoop,
+		resumableMap,
+		resumableForEach,
+		resumableFilter,
+		resumableReduce,
+		resumableFind,
+		resumableSome,
+		resumableEvery,
+		resumableFlatMap,
+		resumablePromiseAll,
+		resumablePromiseAllSettled,
+		batchParallel,
+	};
+}
+
+export async function transformCodeWithCompiler(
+	code: string,
+	executionId: string,
+	cacheProvider: CacheProvider,
+	executionLogger: Logger
+): Promise<CompilerResult> {
+	if (!ATP_COMPILER_ENABLED) {
+		return { code, useCompiler: false };
+	}
+
+	try {
+		const compiler = new ATPCompiler({
+			enableBatchParallel: true,
+			batchSizeThreshold: ATP_BATCH_SIZE_THRESHOLD,
+		});
+		const detection = compiler.detect(code);
+
+		executionLogger.info('ATP Compiler detection result', {
+			needsTransform: detection.needsTransform,
+			patterns: detection.patterns,
+			batchable: detection.batchableParallel,
+		});
+
+		if (detection.needsTransform) {
+			const codeHash = getCodeHash(code);
+			const cached = transformCache.get(codeHash);
+			if (cached) {
+				executionLogger.debug('Using cached transformed code', { codeHash });
+				initializeCompilerRuntime({
+					executionId,
+					cache: cacheProvider,
+				});
+				return {
+					code: cached,
+					useCompiler: true,
+					metadata: {
+						patterns: detection.patterns,
+						batchable: detection.batchableParallel,
+					},
+				};
+			}
+
+			initializeCompilerRuntime({
+				executionId,
+				cache: cacheProvider,
+			});
+
+			const transformed = compiler.transform(code);
+
+			transformCache.set(codeHash, transformed.code);
+
+			executionLogger.info('Code transformed by ATP compiler', {
+				patterns: detection.patterns,
+				batchable: detection.batchableParallel,
+				loopCount: transformed.metadata.loopCount,
+				arrayMethodCount: transformed.metadata.arrayMethodCount,
+				parallelCallCount: transformed.metadata.parallelCallCount,
+				batchSizeThreshold: ATP_BATCH_SIZE_THRESHOLD,
+			});
+
+			return {
+				code: transformed.code,
+				useCompiler: true,
+				metadata: {
+					patterns: detection.patterns,
+					batchable: detection.batchableParallel,
+					loopCount: transformed.metadata.loopCount,
+					arrayMethodCount: transformed.metadata.arrayMethodCount,
+					parallelCallCount: transformed.metadata.parallelCallCount,
+				},
+			};
+		}
+	} catch (error) {
+		executionLogger.error('ATP compiler transformation failed, falling back', {
+			error: error instanceof Error ? error.message : String(error),
+			stack: error instanceof Error ? error.stack : undefined,
+		});
+	}
+
+	return { code, useCompiler: false };
+}

package/src/executor/constants.ts

@@ -0,0 +1,5 @@
+export const PAUSE_EXECUTION_MARKER = '__PAUSE_EXECUTION__';
+
+export const ATP_COMPILER_ENABLED = true;
+
+export const ATP_BATCH_SIZE_THRESHOLD = parseInt(process.env.ATP_BATCH_SIZE_THRESHOLD || '10', 10);

package/src/executor/error-handler.ts

@@ -0,0 +1,118 @@
+import { ExecutionStatus, ExecutionErrorCode } from '@mondaydotcomorg/atp-protocol';
+
+export interface ErrorCategory {
+	status: ExecutionStatus;
+	code: ExecutionErrorCode;
+	retryable: boolean;
+	suggestion?: string;
+}
+
+export function categorizeError(error: Error): ErrorCategory {
+	const message = error.message.toLowerCase();
+
+	if (message.includes('timed out') || message.includes('timeout')) {
+		return {
+			status: ExecutionStatus.TIMEOUT,
+			code: ExecutionErrorCode.TIMEOUT_ERROR,
+			retryable: true,
+			suggestion:
+				'Consider breaking down the operation into smaller steps or increasing the timeout',
+		};
+	}
+
+	if (message.includes('memory') || message.includes('heap')) {
+		return {
+			status: ExecutionStatus.MEMORY_EXCEEDED,
+			code: ExecutionErrorCode.MEMORY_LIMIT_EXCEEDED,
+			retryable: false,
+			suggestion: 'Reduce data size, use streaming, or request higher memory limits',
+		};
+	}
+
+	if (message.includes('exceeded max llm calls') || message.includes('llm call')) {
+		return {
+			status: ExecutionStatus.LLM_CALLS_EXCEEDED,
+			code: ExecutionErrorCode.LLM_CALL_LIMIT_EXCEEDED,
+			retryable: false,
+			suggestion: 'Reduce LLM calls, cache results, or request higher limits',
+		};
+	}
+
+	if (
+		message.includes('not allowed') ||
+		message.includes('forbidden') ||
+		message.includes('security')
+	) {
+		return {
+			status: ExecutionStatus.SECURITY_VIOLATION,
+			code: ExecutionErrorCode.SECURITY_VIOLATION,
+			retryable: false,
+			suggestion: 'Remove forbidden operations or use allowed APIs',
+		};
+	}
+
+	if (message.includes('syntaxerror') || message.includes('unexpected token')) {
+		return {
+			status: ExecutionStatus.PARSE_ERROR,
+			code: ExecutionErrorCode.SYNTAX_ERROR,
+			retryable: false,
+			suggestion: 'Check code syntax and fix any errors',
+		};
+	}
+
+	if (message.includes('typeerror') || message.includes('is not a function')) {
+		return {
+			status: ExecutionStatus.FAILED,
+			code: ExecutionErrorCode.TYPE_ERROR,
+			retryable: false,
+			suggestion: 'Check types and ensure methods are called correctly',
+		};
+	}
+
+	if (message.includes('referenceerror') || message.includes('is not defined')) {
+		return {
+			status: ExecutionStatus.FAILED,
+			code: ExecutionErrorCode.REFERENCE_ERROR,
+			retryable: false,
+			suggestion: 'Check variable names and ensure all are defined before use',
+		};
+	}
+
+	if (
+		message.includes('network') ||
+		message.includes('fetch') ||
+		message.includes('econnrefused')
+	) {
+		return {
+			status: ExecutionStatus.NETWORK_ERROR,
+			code: ExecutionErrorCode.NETWORK_ERROR,
+			retryable: true,
+			suggestion: 'Check network connectivity and try again',
+		};
+	}
+
+	if (message.includes('loop') || message.includes('infinite')) {
+		return {
+			status: ExecutionStatus.LOOP_DETECTED,
+			code: ExecutionErrorCode.INFINITE_LOOP_DETECTED,
+			retryable: false,
+			suggestion: 'Review loops and add proper exit conditions',
+		};
+	}
+
+	if (message.includes('isolate was disposed')) {
+		return {
+			status: ExecutionStatus.TIMEOUT,
+			code: ExecutionErrorCode.TIMEOUT_ERROR,
+			retryable: true,
+			suggestion: 'The execution was terminated. Consider increasing timeout or optimizing code',
+		};
+	}
+
+	return {
+		status: ExecutionStatus.FAILED,
+		code: ExecutionErrorCode.EXECUTION_FAILED,
+		retryable: false,
+		suggestion: 'Review error message and stack trace for details',
+	};
+}

package/src/executor/execution-error-handler.ts

@@ -0,0 +1,178 @@
+import ivm from 'isolated-vm';
+import { ExecutionStatus } from '@mondaydotcomorg/atp-protocol';
+import type { ExecutionResult } from '@mondaydotcomorg/atp-protocol';
+import type { Logger } from '@mondaydotcomorg/atp-runtime';
+import {
+	isPauseError,
+	getCallSequenceNumber,
+	setPauseForClient,
+	setReplayMode,
+	type PauseExecutionError,
+} from '@mondaydotcomorg/atp-runtime';
+import {
+	isBatchPauseError,
+	type BatchPauseExecutionError,
+} from '@mondaydotcomorg/atp-compiler';
+import { nanoid } from 'nanoid';
+import type { CallbackRecord } from '../execution-state/index.js';
+import type { RuntimeContext } from './types.js';
+import { categorizeError } from './error-handler.js';
+import { PAUSE_EXECUTION_MARKER } from './constants.js';
+
+export function handleExecutionError(
+	error: unknown,
+	pauseError: unknown,
+	context: RuntimeContext,
+	executionId: string,
+	callbackHistory: CallbackRecord[],
+	memoryBefore: number,
+	executionLogger: Logger,
+	isolate: ivm.Isolate,
+	transformedCode?: string
+): ExecutionResult {
+	const errMsg = error instanceof Error ? error.message : String(error);
+
+	if (errMsg.includes(PAUSE_EXECUTION_MARKER) && pauseError) {
+		error = pauseError;
+	}
+
+	if (isBatchPauseError(error)) {
+		const batchErr = error as BatchPauseExecutionError;
+
+		executionLogger.info('Execution paused for batch callbacks', {
+			batchId: batchErr.batchId,
+			callCount: batchErr.calls.length,
+			sequenceNumber: batchErr.sequenceNumber,
+		});
+
+		const batchCallbackRecord: CallbackRecord = {
+			type: (batchErr.calls[0]?.type as any) || 'llm',
+			operation: 'batch_parallel',
+			payload: {
+				batchId: batchErr.batchId,
+				calls: batchErr.calls,
+			},
+			sequenceNumber: batchErr.sequenceNumber,
+			result: undefined,
+			timestamp: Date.now(),
+		};
+		callbackHistory.push(batchCallbackRecord);
+
+		const memoryAfter = process.memoryUsage().heapUsed;
+		const memoryUsed = Math.max(0, memoryAfter - memoryBefore);
+
+		try {
+			isolate.dispose();
+		} catch (e) {}
+
+		setPauseForClient(false);
+		setReplayMode(undefined);
+
+		return {
+			executionId,
+			status: ExecutionStatus.PAUSED,
+			needsCallbacks: batchErr.calls.map((call: any) => ({
+				id: nanoid(),
+				type: call.type as any,
+				operation: call.operation,
+				payload: call.payload,
+			})),
+			callbackHistory,
+			stats: {
+				duration: Date.now() - context.startTime,
+				memoryUsed,
+				llmCallsCount: context.llmCallCount,
+				approvalCallsCount: context.approvalCallCount,
+			},
+			transformedCode,
+		};
+	}
+
+	if (isPauseError(error)) {
+		const pauseErr = error as PauseExecutionError;
+
+		const currentSequence = getCallSequenceNumber() - 1;
+		const callbackRecord: CallbackRecord = {
+			type: pauseErr.type,
+			operation: pauseErr.operation,
+			payload: pauseErr.payload,
+			result: undefined,
+			timestamp: Date.now(),
+			sequenceNumber: currentSequence,
+		};
+		callbackHistory.push(callbackRecord);
+
+		executionLogger.info('Execution paused for client callback', {
+			type: pauseErr.type,
+			operation: pauseErr.operation,
+			sequenceNumber: currentSequence,
+			historyLength: callbackHistory.length,
+		});
+
+		const memoryAfter = process.memoryUsage().heapUsed;
+		const memoryUsed = Math.max(0, memoryAfter - memoryBefore);
+
+		try {
+			isolate.dispose();
+		} catch (e) {}
+
+		setPauseForClient(false);
+		setReplayMode(undefined);
+
+		return {
+			executionId,
+			status: ExecutionStatus.PAUSED,
+			needsCallback: {
+				type: pauseErr.type,
+				operation: pauseErr.operation,
+				payload: pauseErr.payload,
+			},
+			callbackHistory,
+			stats: {
+				duration: Date.now() - context.startTime,
+				memoryUsed,
+				llmCallsCount: context.llmCallCount,
+				approvalCallsCount: context.approvalCallCount,
+			},
+			transformedCode,
+		};
+	}
+
+	const err = error as Error;
+	const errorInfo = categorizeError(err);
+
+	executionLogger.error('Code execution failed', {
+		error: err.message,
+		status: errorInfo.status,
+		code: errorInfo.code,
+		retryable: errorInfo.retryable,
+	});
+
+	const memoryAfter = process.memoryUsage().heapUsed;
+	const memoryUsed = Math.max(0, memoryAfter - memoryBefore);
+
+	try {
+		isolate.dispose();
+	} catch (e) {}
+
+	setPauseForClient(false);
+	setReplayMode(undefined);
+
+	return {
+		executionId,
+		status: errorInfo.status,
+		error: {
+			message: err.message,
+			code: errorInfo.code,
+			stack: err.stack,
+			retryable: errorInfo.retryable,
+			suggestion: errorInfo.suggestion,
+		},
+		stats: {
+			duration: Date.now() - context.startTime,
+			memoryUsed,
+			llmCallsCount: context.llmCallCount,
+			approvalCallsCount: context.approvalCallCount,
+		},
+	};
+}