@mondaydotcomorg/atp-server 0.17.14

package/src/executor/sandbox-injector.ts

@@ -0,0 +1,345 @@
+import ivm from 'isolated-vm';
+import type { Logger } from '@mondaydotcomorg/atp-runtime';
+import { isPauseError, runInExecutionContext } from '@mondaydotcomorg/atp-runtime';
+import { isBatchPauseError } from '@mondaydotcomorg/atp-compiler';
+import { PAUSE_EXECUTION_MARKER } from './constants.js';
+
+export async function injectTimerPolyfills(ivmContext: ivm.Context): Promise<void> {
+	await ivmContext.eval(`
+		globalThis._timerCounter = 1;
+		globalThis._activeTimers = new Map();
+		
+		globalThis.setTimeout = function(callback, delay) {
+			const timerId = globalThis._timerCounter++;
+			const startTime = Date.now();
+			
+			const pollTimer = () => {
+				if (!globalThis._activeTimers.has(timerId)) {
+					return;
+				}
+				
+				if (Date.now() - startTime >= delay) {
+					globalThis._activeTimers.delete(timerId);
+					callback();
+				} else {
+					Promise.resolve().then(pollTimer);
+				}
+			};
+			
+			globalThis._activeTimers.set(timerId, true);
+			Promise.resolve().then(pollTimer);
+			return timerId;
+		};
+		
+		globalThis.clearTimeout = function(timerId) {
+			globalThis._activeTimers.delete(timerId);
+		};
+	`);
+}
+
+export async function injectSandbox(
+	ivmContext: ivm.Context,
+	jail: ivm.Reference<Record<string, unknown>>,
+	sandbox: Record<string, unknown>,
+	executionLogger: Logger,
+	onPauseError: (error: unknown) => void,
+	executionId?: string,
+	provenanceMode?: string,
+	hintMetadata?: Map<string, any>
+): Promise<void> {
+	const injectFunctions = async (obj: unknown, prefix: string): Promise<void> => {
+		if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
+			return;
+		}
+
+		for (const [key, value] of Object.entries(obj)) {
+			if (typeof value === 'function') {
+				const boundFunc = value.bind(obj);
+
+				const isVoidFunction =
+					prefix === 'atp_log' || prefix === 'atp_progress' || prefix === 'atp_output';
+
+				if (isVoidFunction) {
+					await jail.set(
+						`__${prefix}_${key}`,
+						new ivm.Reference((...args: unknown[]) => {
+							try {
+								boundFunc(...args);
+							} catch (error) {
+								executionLogger.error('Error in void function', { prefix, key, error });
+							}
+						})
+					);
+				} else {
+					await jail.set(
+						`__${prefix}_${key}`,
+						new ivm.Reference(async (...args: unknown[]) => {
+							try {
+								const result = await boundFunc(...args);
+								return new ivm.ExternalCopy(result).copyInto();
+							} catch (error) {
+								const err = error as Error;
+								if (isPauseError(error) || err.message === PAUSE_EXECUTION_MARKER) {
+									if (isPauseError(error)) {
+										onPauseError(error);
+									}
+									throw new Error(PAUSE_EXECUTION_MARKER);
+								}
+								throw error;
+							}
+						})
+					);
+				}
+			} else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+				await injectFunctions(value, `${prefix}_${key}`);
+			}
+		}
+	};
+
+	const injectAPIFunctions = async (obj: unknown, pathPrefix: string): Promise<void> => {
+		if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
+			return;
+		}
+
+		for (const [key, value] of Object.entries(obj)) {
+			const newPath = pathPrefix ? `${pathPrefix}_${key}` : key;
+
+			if (typeof value === 'function') {
+				const boundFunc = value.bind(obj);
+				const safeName = newPath.replace(/-/g, '_').replace(/\//g, '_').replace(/\./g, '_');
+
+				await jail.set(
+					`__api_${safeName}`,
+					new ivm.Reference(async (...args: unknown[]) => {
+						try {
+							const result = await boundFunc(...args);
+							// In AST mode, tag result with provenance ID before copying so tag survives
+							if (isASTMode && result && typeof result === 'object') {
+								try {
+									// Generate unique ID for this API result
+									const provId = `tracked_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+									Object.defineProperty(result, '__prov_id__', {
+										value: provId,
+										writable: false,
+										enumerable: true,
+										configurable: true,
+									});
+								} catch (e) {
+									// If can't define property, that's ok
+								}
+							}
+							return new ivm.ExternalCopy(result).copyInto();
+						} catch (error) {
+							const err = error as Error;
+							if (isPauseError(error) || err.message === PAUSE_EXECUTION_MARKER) {
+								if (isPauseError(error)) {
+									onPauseError(error);
+								}
+								throw new Error(PAUSE_EXECUTION_MARKER);
+							}
+							throw error;
+						}
+					})
+				);
+			} else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+				await injectAPIFunctions(value, newPath);
+			}
+		}
+	};
+
+	const isASTMode = provenanceMode === 'ast';
+	if (isASTMode) {
+		if (hintMetadata && hintMetadata.size > 0) {
+			const hintsArray = Array.from(hintMetadata.entries());
+			await jail.set('__provenance_hints', new ivm.ExternalCopy(hintsArray).copyInto());
+			const valueMap = (hintMetadata as any).__valueMap;
+			if (valueMap && valueMap.size > 0) {
+				const valueMapArray = Array.from(valueMap.entries());
+				await jail.set('__provenance_hint_values', new ivm.ExternalCopy(valueMapArray).copyInto());
+			}
+		}
+		const { AST_TRACKING_RUNTIME } = await import('./ast-tracking-runtime.js');
+		await ivmContext.eval(AST_TRACKING_RUNTIME);
+		executionLogger.info('AST tracking runtime injected into isolate');
+	}
+
+	const hasASTTracking = isASTMode;
+
+	for (const [namespace, value] of Object.entries(sandbox)) {
+		if (
+			hasASTTracking &&
+			(namespace.startsWith('__track') ||
+				namespace.startsWith('__get_provenance') ||
+				namespace.startsWith('__mark_tainted'))
+		) {
+			continue;
+		}
+
+		if (namespace === '__runtime' && typeof value === 'object' && value !== null) {
+			for (const [key, fn] of Object.entries(value)) {
+				if (typeof fn === 'function') {
+					await jail.set(
+						`__runtime_${key}_impl`,
+						new ivm.Reference(async (...args: unknown[]) => {
+							try {
+								const execute = async () => {
+									const result = await fn(...args);
+									return new ivm.ExternalCopy(result).copyInto();
+								};
+
+								if (executionId) {
+									return await runInExecutionContext(executionId, execute);
+								} else {
+									return await execute();
+								}
+							} catch (error) {
+								const err = error as Error;
+								if (isBatchPauseError(error)) {
+									onPauseError(error);
+									throw new Error(PAUSE_EXECUTION_MARKER);
+								}
+								if (isPauseError(error) || err.message === PAUSE_EXECUTION_MARKER) {
+									if (isPauseError(error)) {
+										onPauseError(error);
+									}
+									throw new Error(PAUSE_EXECUTION_MARKER);
+								}
+								throw error;
+							}
+						})
+					);
+				}
+			}
+		} else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+			if (namespace === 'api') {
+				await injectAPIFunctions(value, '');
+			} else {
+				await injectFunctions(value, namespace);
+			}
+		}
+	}
+}
+
+export async function setupRuntimeNamespace(
+	ivmContext: ivm.Context,
+	sandbox: Record<string, unknown>
+): Promise<void> {
+	const runtimeObject = sandbox.__runtime as Record<string, unknown>;
+	if (!runtimeObject || typeof runtimeObject !== 'object') {
+		return;
+	}
+
+	const runtimeKeys = Object.keys(runtimeObject).filter(
+		(k) => typeof runtimeObject[k] === 'function'
+	);
+	if (runtimeKeys.length === 0) {
+		return;
+	}
+
+	let runtimeSetup = 'globalThis.__runtime = {\n';
+	runtimeSetup += runtimeKeys
+		.map(
+			(key) =>
+				`\t${key}: async (...args) => {\n\t\treturn await __runtime_${key}_impl.apply(undefined, args, { arguments: { copy: true }, result: { promise: true } });\n\t}`
+		)
+		.join(',\n');
+	runtimeSetup += '\n};';
+
+	await ivmContext.eval(runtimeSetup);
+}
+
+export async function setupAPINamespace(
+	ivmContext: ivm.Context,
+	sandbox: Record<string, unknown>,
+	provenanceMode?: string
+): Promise<void> {
+	const apiObject = sandbox.api as Record<string, unknown>;
+	if (!apiObject || typeof apiObject !== 'object') {
+		return;
+	}
+
+	const apiGroupNames = Object.keys(apiObject);
+	if (apiGroupNames.length === 0) {
+		return;
+	}
+
+	const isASTMode = provenanceMode === 'ast';
+	let apiSetup = 'globalThis.api = {};';
+
+	function setupNestedAPI(
+		obj: Record<string, unknown>,
+		pathPrefix: string,
+		accessPath: string
+	): void {
+		for (const [key, value] of Object.entries(obj)) {
+			const newPath = pathPrefix ? `${pathPrefix}_${key}` : key;
+			const safeKey = JSON.stringify(key);
+			const newAccessPath = `${accessPath}[${safeKey}]`;
+
+			if (typeof value === 'function') {
+				const safeName = newPath.replace(/-/g, '_').replace(/\//g, '_').replace(/\./g, '_');
+
+				if (isASTMode) {
+					const toolNameEscaped = newPath.replace(/'/g, "\\'");
+					apiSetup += `
+${newAccessPath} = async function(...args) {
+	// In AST mode, recursively wrap arguments to preserve tainted primitive provenance
+	function wrapTaintedValues(obj, visited = new WeakSet()) {
+		if (obj === null || obj === undefined) return obj;
+		
+		// If this is already a wrapped tainted value, don't wrap it again!
+		if (typeof obj === 'object' && '__tainted_value' in obj && '__prov_meta' in obj) {
+			return obj; // Return as-is, already wrapped
+		}
+		
+		// Check if this value itself has provenance (primitive or object)
+		if (typeof globalThis.__check_provenance === 'function') {
+			const prov = globalThis.__check_provenance(obj);
+			if (prov && (typeof obj === 'string' || typeof obj === 'number')) {
+				// Wrap tainted primitive
+				return { __tainted_value: obj, __prov_meta: prov };
+			}
+		}
+		
+		// For objects/arrays, recursively wrap their contents
+		if (typeof obj === 'object') {
+			if (visited.has(obj)) return obj; // Avoid circular refs
+			visited.add(obj);
+			
+			if (Array.isArray(obj)) {
+				return obj.map(item => wrapTaintedValues(item, visited));
+			} else {
+				const wrapped = {};
+				for (const [key, val] of Object.entries(obj)) {
+					wrapped[key] = wrapTaintedValues(val, visited);
+				}
+				return wrapped;
+			}
+		}
+		
+		return obj;
+	}
+	
+	const wrappedArgs = args.map(arg => wrapTaintedValues(arg));
+	const result = await __api_${safeName}.apply(undefined, wrappedArgs, { arguments: { copy: true }, result: { promise: true } });
+	if (typeof globalThis.__track === 'function' && result !== null && result !== undefined) {
+		return globalThis.__track(result, { type: 'tool', tool: '${toolNameEscaped}', operation: 'read' }, []);
+	}
+	return result;
+};`;
+				} else {
+					apiSetup += `
+${newAccessPath} = async function(...args) {
+	return await __api_${safeName}.apply(undefined, args, { arguments: { copy: true }, result: { promise: true } });
+};`;
+				}
+			} else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+				apiSetup += `\n${newAccessPath} = {};`;
+				setupNestedAPI(value as Record<string, unknown>, newPath, newAccessPath);
+			}
+		}
+	}
+
+	setupNestedAPI(apiObject, '', 'globalThis.api');
+	await ivmContext.eval(apiSetup);
+}

package/src/executor/types.ts

@@ -0,0 +1,22 @@
+import type { CacheProvider } from '@mondaydotcomorg/atp-protocol';
+
+export interface RuntimeContext {
+	llmCallCount: number;
+	approvalCallCount: number;
+	logs: string[];
+	startTime: number;
+	maxLLMCalls: number;
+	executionId: string;
+	clientId?: string;
+	hintMetadata?: Map<string, any>;
+}
+
+export interface ExecutorConfig {
+	defaultTimeout: number;
+	maxTimeout: number;
+	defaultMemoryLimit: number;
+	maxMemoryLimit: number;
+	defaultLLMCallLimit: number;
+	maxLLMCallLimit: number;
+	cacheProvider?: CacheProvider;
+}

package/src/explorer/index.ts

@@ -0,0 +1,297 @@
+import type { APIGroupConfig, CustomFunctionDef } from '@mondaydotcomorg/atp-protocol';
+
+interface TreeNode {
+	type: 'directory' | 'function';
+	name: string;
+	children?: Map<string, TreeNode>;
+	functionDef?: {
+		func: CustomFunctionDef;
+		group: string;
+	};
+}
+
+interface ExploreDirectoryResult {
+	type: 'directory';
+	path: string;
+	items: Array<{ name: string; type: 'directory' | 'function' }>;
+}
+
+interface ExploreFunctionResult {
+	type: 'function';
+	path: string;
+	name: string;
+	description: string;
+	definition: string;
+	group: string;
+}
+
+export type ExploreResult = ExploreDirectoryResult | ExploreFunctionResult;
+
+/**
+ * ExplorerService provides filesystem-like navigation of API groups.
+ * Enables progressive discovery of APIs by allowing agents to explore
+ * tool hierarchies on-demand rather than loading everything upfront.
+ */
+export class ExplorerService {
+	private root: TreeNode;
+
+	constructor(apiGroups: APIGroupConfig[]) {
+		this.root = { type: 'directory', name: '/', children: new Map() };
+		this.buildTree(apiGroups);
+	}
+
+	/**
+	 * Builds the virtual filesystem tree from API groups
+	 */
+	private buildTree(apiGroups: APIGroupConfig[]): void {
+		for (const group of apiGroups) {
+			if (!group.functions || group.functions.length === 0) continue;
+
+			const typeFolder = this.ensureDirectory(this.root, group.type);
+			const groupFolder = this.ensureDirectory(typeFolder, group.name);
+
+			for (const func of group.functions) {
+				const segments = this.extractSegments(func, group);
+
+				if (segments.length > 1) {
+					let current = groupFolder;
+					for (let i = 0; i < segments.length - 1; i++) {
+						current = this.ensureDirectory(current, segments[i]!);
+					}
+					this.addFunction(current, segments[segments.length - 1]!, func, group.name);
+				} else {
+					this.addFunction(groupFolder, func.name, func, group.name);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Extract path segments for organizing functions
+	 */
+	private extractSegments(func: CustomFunctionDef, group: APIGroupConfig): string[] {
+		if (group.type === 'openapi') {
+			const name = func.name;
+
+			const camelSplit = name.match(/[A-Z]?[a-z]+|[A-Z]+(?=[A-Z][a-z]|\b)/g);
+			if (camelSplit && camelSplit.length > 2) {
+				const verb = camelSplit[0].toLowerCase();
+				const isVerb = [
+					'get',
+					'list',
+					'create',
+					'update',
+					'delete',
+					'post',
+					'put',
+					'patch',
+				].includes(verb);
+
+				if (isVerb) {
+					const resource = camelSplit.slice(1).join('_').toLowerCase();
+					return [resource, name];
+				}
+			}
+
+			if (name.includes('_')) {
+				const parts = name.split('_');
+				if (parts.length > 1 && parts[0]) {
+					return [parts[0], name];
+				}
+			}
+
+			if (name.includes('-')) {
+				const parts = name.split('-');
+				if (parts.length > 1 && parts[0]) {
+					return [parts[0], name];
+				}
+			}
+		}
+
+		return [func.name];
+	}
+
+	/**
+	 * Ensures a directory exists at the given path
+	 */
+	private ensureDirectory(parent: TreeNode, name: string): TreeNode {
+		if (!parent.children) {
+			parent.children = new Map();
+		}
+
+		let child = parent.children.get(name);
+		if (!child) {
+			child = { type: 'directory', name, children: new Map() };
+			parent.children.set(name, child);
+		}
+
+		return child;
+	}
+
+	/**
+	 * Adds a function to the tree
+	 */
+	private addFunction(
+		parent: TreeNode,
+		name: string,
+		func: CustomFunctionDef,
+		group: string
+	): void {
+		if (!parent.children) {
+			parent.children = new Map();
+		}
+
+		parent.children.set(name, {
+			type: 'function',
+			name,
+			functionDef: { func, group },
+		});
+	}
+
+	/**
+	 * Explores the filesystem at the given path
+	 */
+	explore(path: string): ExploreResult | null {
+		const normalizedPath = this.normalizePath(path);
+		const segments = normalizedPath === '/' ? [] : normalizedPath.split('/').filter((s) => s);
+
+		let current = this.root;
+		let currentPath = '/';
+
+		for (const segment of segments) {
+			if (!current.children || !current.children.has(segment)) {
+				return null;
+			}
+			current = current.children.get(segment)!;
+			currentPath = currentPath === '/' ? `/${segment}` : `${currentPath}/${segment}`;
+		}
+
+		if (current.type === 'directory') {
+			const items: Array<{ name: string; type: 'directory' | 'function' }> = [];
+			if (current.children) {
+				for (const [name, node] of current.children) {
+					items.push({ name, type: node.type });
+				}
+			}
+			items.sort((a, b) => {
+				if (a.type === b.type) {
+					return a.name.localeCompare(b.name);
+				}
+				return a.type === 'directory' ? -1 : 1;
+			});
+
+			return {
+				type: 'directory',
+				path: currentPath,
+				items,
+			};
+		} else {
+			if (!current.functionDef) {
+				return null;
+			}
+
+			const { func, group } = current.functionDef;
+			const definition = this.generateFunctionDefinition(func);
+
+			return {
+				type: 'function',
+				path: currentPath,
+				name: func.name,
+				description: func.description,
+				definition,
+				group,
+			};
+		}
+	}
+
+	/**
+	 * Normalizes a path (removes trailing slashes, ensures leading slash)
+	 */
+	private normalizePath(path: string): string {
+		if (!path || path === '') return '/';
+
+		if (!path.startsWith('/')) {
+			path = '/' + path;
+		}
+
+		if (path !== '/' && path.endsWith('/')) {
+			path = path.slice(0, -1);
+		}
+
+		return path;
+	}
+
+	/**
+	 * Generates TypeScript function signature
+	 */
+	private generateFunctionDefinition(func: CustomFunctionDef): string {
+		const inputType = this.generateInputType(func.inputSchema);
+		const outputType = func.outputSchema ? this.generateOutputType(func.outputSchema) : 'unknown';
+
+		return `async function ${func.name}(params: ${inputType}): Promise<${outputType}>`;
+	}
+
+	/**
+	 * Generates TypeScript type from JSON schema
+	 */
+	private generateInputType(schema?: {
+		properties?: Record<string, any>;
+		required?: string[];
+	}): string {
+		if (!schema || !schema.properties) {
+			return '{}';
+		}
+
+		const props: string[] = [];
+		const required = schema.required || [];
+
+		for (const [key, value] of Object.entries(schema.properties)) {
+			const isRequired = required.includes(key);
+			const prop = value as { type?: string; description?: string };
+			const tsType = this.jsonSchemaTypeToTS(prop.type ?? 'any');
+			const optional = isRequired ? '' : '?';
+			props.push(`${key}${optional}: ${tsType}`);
+		}
+
+		return `{ ${props.join('; ')} }`;
+	}
+
+	/**
+	 * Generates output type from JSON schema
+	 */
+	private generateOutputType(schema: { properties?: Record<string, any> }): string {
+		if (!schema.properties) {
+			return 'unknown';
+		}
+
+		const props: string[] = [];
+		for (const [key, value] of Object.entries(schema.properties)) {
+			const prop = value as { type?: string };
+			const tsType = this.jsonSchemaTypeToTS(prop.type ?? 'any');
+			props.push(`${key}: ${tsType}`);
+		}
+
+		return `{ ${props.join('; ')} }`;
+	}
+
+	/**
+	 * Converts JSON Schema type to TypeScript type
+	 */
+	private jsonSchemaTypeToTS(type: string): string {
+		switch (type) {
+			case 'string':
+				return 'string';
+			case 'number':
+			case 'integer':
+				return 'number';
+			case 'boolean':
+				return 'boolean';
+			case 'array':
+				return 'any[]';
+			case 'object':
+				return 'Record<string, any>';
+			default:
+				return 'any';
+		}
+	}
+}

package/src/handlers/definitions.handler.ts

@@ -0,0 +1,13 @@
+import type { APIGroupConfig } from '@mondaydotcomorg/atp-protocol';
+import { APIAggregator } from '../aggregator/index.js';
+
+export async function getDefinitions(apiGroups: APIGroupConfig[]): Promise<unknown> {
+	const aggregator = new APIAggregator(apiGroups);
+	const typescript = await aggregator.generateTypeScript();
+
+	return {
+		typescript,
+		apiGroups: apiGroups.map((g) => g.name),
+		version: '1.0.0',
+	};
+}