@mondaydotcomorg/atp-client 0.19.5 → 0.19.7

package/src/core/execution-operations.ts

@@ -1,19 +1,22 @@
 import type { ExecutionResult, ExecutionConfig } from '@mondaydotcomorg/atp-protocol';
 import { ExecutionStatus, CallbackType } from '@mondaydotcomorg/atp-protocol';
 import { log } from '@mondaydotcomorg/atp-runtime';
-import type { ClientSession } from './session.js';
+import type { ISession } from './session.js';
+import type { InProcessSession } from './in-process-session.js';
 import type { ServiceProviders } from './service-providers';
 import { ClientCallbackError } from '../errors.js';
 import { ProvenanceTokenRegistry } from './provenance-registry.js';
 
 export class ExecutionOperations {
-	private session: ClientSession;
+	private session: ISession;
+	private inProcessSession?: InProcessSession;
 	private serviceProviders: ServiceProviders;
 	private tokenRegistry: ProvenanceTokenRegistry;
 	private lastExecutionConfig: Partial<ExecutionConfig> | null = null;
 
-	constructor(session: ClientSession, serviceProviders: ServiceProviders) {
+	constructor(session: ISession, serviceProviders: ServiceProviders, inProcessSession?: InProcessSession) {
 		this.session = session;
+		this.inProcessSession = inProcessSession;
 		this.serviceProviders = serviceProviders;
 		this.tokenRegistry = new ProvenanceTokenRegistry();
 	}
@@ -132,24 +135,30 @@ export class ExecutionOperations {
 
 		this.lastExecutionConfig = executionConfig;
 
-		const url = `${this.session.getBaseUrl()}/api/execute`;
-		const body = JSON.stringify({ code, config: executionConfig });
-		const headers = await this.session.prepareHeaders('POST', url, body);
+		let result: ExecutionResult;
 
-		const response = await fetch(url, {
-			method: 'POST',
-			headers,
-			body,
-		});
+		if (this.inProcessSession) {
+			result = (await this.inProcessSession.execute(code, executionConfig)) as ExecutionResult;
+		} else {
+			const url = `${this.session.getBaseUrl()}/api/execute`;
+			const body = JSON.stringify({ code, config: executionConfig });
+			const headers = await this.session.prepareHeaders('POST', url, body);
 
-		this.session.updateToken(response);
+			const response = await fetch(url, {
+				method: 'POST',
+				headers,
+				body,
+			});
 
-		if (!response.ok) {
-			const error = (await response.json()) as { error: string };
-			throw new Error(`Execution failed: ${error.error || response.statusText}`);
-		}
+			this.session.updateToken(response);
 
-		const result = (await response.json()) as ExecutionResult;
+			if (!response.ok) {
+				const error = (await response.json()) as { error: string };
+				throw new Error(`Execution failed: ${error.error || response.statusText}`);
+			}
+
+			result = (await response.json()) as ExecutionResult;
+		}
 
 		if (result.provenanceTokens && result.provenanceTokens.length > 0) {
 			for (const { token } of result.provenanceTokens) {
@@ -383,24 +392,30 @@ export class ExecutionOperations {
 	async resume(executionId: string, callbackResult: unknown): Promise<ExecutionResult> {
 		await this.session.ensureInitialized();
 
-		const url = `${this.session.getBaseUrl()}/api/resume/${executionId}`;
-		const body = JSON.stringify({ result: callbackResult });
-		const headers = await this.session.prepareHeaders('POST', url, body);
+		let result: ExecutionResult;
 
-		const response = await fetch(url, {
-			method: 'POST',
-			headers,
-			body,
-		});
+		if (this.inProcessSession) {
+			result = (await this.inProcessSession.resume(executionId, callbackResult)) as ExecutionResult;
+		} else {
+			const url = `${this.session.getBaseUrl()}/api/resume/${executionId}`;
+			const body = JSON.stringify({ result: callbackResult });
+			const headers = await this.session.prepareHeaders('POST', url, body);
+
+			const response = await fetch(url, {
+				method: 'POST',
+				headers,
+				body,
+			});
 
-		this.session.updateToken(response);
+			this.session.updateToken(response);
 
-		if (!response.ok) {
-			const error = (await response.json()) as { error: string };
-			throw new Error(`Resume failed: ${error.error || response.statusText}`);
-		}
+			if (!response.ok) {
+				const error = (await response.json()) as { error: string };
+				throw new Error(`Resume failed: ${error.error || response.statusText}`);
+			}
 
-		const result = (await response.json()) as ExecutionResult;
+			result = (await response.json()) as ExecutionResult;
+		}
 
 		if (result.provenanceTokens && result.provenanceTokens.length > 0) {
 			for (const { token } of result.provenanceTokens) {
@@ -428,24 +443,33 @@ export class ExecutionOperations {
 	): Promise<ExecutionResult> {
 		await this.session.ensureInitialized();
 
-		const url = `${this.session.getBaseUrl()}/api/resume/${executionId}`;
-		const body = JSON.stringify({ results: batchResults });
-		const headers = await this.session.prepareHeaders('POST', url, body);
+		let result: ExecutionResult;
 
-		const response = await fetch(url, {
-			method: 'POST',
-			headers,
-			body,
-		});
+		if (this.inProcessSession) {
+			result = (await this.inProcessSession.resumeWithBatchResults(
+				executionId,
+				batchResults
+			)) as ExecutionResult;
+		} else {
+			const url = `${this.session.getBaseUrl()}/api/resume/${executionId}`;
+			const body = JSON.stringify({ results: batchResults });
+			const headers = await this.session.prepareHeaders('POST', url, body);
 
-		this.session.updateToken(response);
+			const response = await fetch(url, {
+				method: 'POST',
+				headers,
+				body,
+			});
 
-		if (!response.ok) {
-			const error = (await response.json()) as { error: string };
-			throw new Error(`Batch resume failed: ${error.error || response.statusText}`);
-		}
+			this.session.updateToken(response);
 
-		const result = (await response.json()) as ExecutionResult;
+			if (!response.ok) {
+				const error = (await response.json()) as { error: string };
+				throw new Error(`Batch resume failed: ${error.error || response.statusText}`);
+			}
+
+			result = (await response.json()) as ExecutionResult;
+		}
 
 		if (result.provenanceTokens && result.provenanceTokens.length > 0) {
 			for (const { token } of result.provenanceTokens) {

package/src/core/in-process-session.ts

@@ -0,0 +1,294 @@
+import type { ClientToolDefinition } from '@mondaydotcomorg/atp-protocol';
+import type { ISession } from './session.js';
+
+interface InProcessServer {
+	start(): Promise<void>;
+	handleInit(ctx: InProcessRequestContext): Promise<unknown>;
+	getDefinitions(ctx?: InProcessRequestContext): Promise<unknown>;
+	getRuntimeDefinitions(ctx?: InProcessRequestContext): Promise<string>;
+	getInfo(): unknown;
+	handleSearch(ctx: InProcessRequestContext): Promise<unknown>;
+	handleExplore(ctx: InProcessRequestContext): Promise<unknown>;
+	handleExecute(ctx: InProcessRequestContext): Promise<unknown>;
+	handleResume(ctx: InProcessRequestContext, executionId: string): Promise<unknown>;
+}
+
+interface InProcessRequestContext {
+	method: string;
+	path: string;
+	query: Record<string, string>;
+	headers: Record<string, string>;
+	body: unknown;
+	clientId?: string;
+	clientToken?: string;
+	userId?: string;
+	user?: unknown;
+	executionId?: string;
+	code?: string;
+	validation?: unknown;
+	result?: unknown;
+	error?: Error;
+	logger: { debug: () => void; info: () => void; warn: () => void; error: () => void };
+	status: number;
+	responseBody: unknown;
+	throw(status: number, message: string): never;
+	assert(condition: boolean, message: string): asserts condition;
+	set(header: string, value: string): void;
+}
+
+export class InProcessSession implements ISession {
+	private server: InProcessServer;
+	private clientId?: string;
+	private clientToken?: string;
+	private initialized: boolean = false;
+	private initPromise?: Promise<void>;
+
+	constructor(server: InProcessServer) {
+		this.server = server;
+	}
+
+	async init(
+		clientInfo?: { name?: string; version?: string; [key: string]: unknown },
+		tools?: ClientToolDefinition[],
+		services?: { hasLLM: boolean; hasApproval: boolean; hasEmbedding: boolean; hasTools: boolean }
+	): Promise<{
+		clientId: string;
+		token: string;
+		expiresAt: number;
+		tokenRotateAt: number;
+	}> {
+		if (this.initPromise) {
+			await this.initPromise;
+			return {
+				clientId: this.clientId!,
+				token: this.clientToken!,
+				expiresAt: 0,
+				tokenRotateAt: 0,
+			};
+		}
+
+		this.initPromise = (async () => {
+			await this.server.start();
+
+			const ctx = this.createContext({
+				method: 'POST',
+				path: '/api/init',
+				body: {
+					clientInfo,
+					tools: tools || [],
+					services,
+				},
+			});
+
+			const result = (await this.server.handleInit(ctx)) as {
+				clientId: string;
+				token: string;
+				expiresAt: number;
+				tokenRotateAt: number;
+			};
+
+			this.clientId = result.clientId;
+			this.clientToken = result.token;
+			this.initialized = true;
+		})();
+
+		await this.initPromise;
+
+		return {
+			clientId: this.clientId!,
+			token: this.clientToken!,
+			expiresAt: 0,
+			tokenRotateAt: 0,
+		};
+	}
+
+	getClientId(): string {
+		if (!this.clientId) {
+			throw new Error('Client not initialized. Call init() first.');
+		}
+		return this.clientId;
+	}
+
+	async ensureInitialized(): Promise<void> {
+		if (!this.initialized) {
+			throw new Error('Client not initialized. Call init() first.');
+		}
+	}
+
+	getHeaders(): Record<string, string> {
+		const headers: Record<string, string> = {
+			'content-type': 'application/json',
+		};
+
+		if (this.clientId) {
+			headers['x-client-id'] = this.clientId;
+		}
+
+		if (this.clientToken) {
+			headers['authorization'] = `Bearer ${this.clientToken}`;
+		}
+
+		return headers;
+	}
+
+	getBaseUrl(): string {
+		return '';
+	}
+
+	updateToken(_response: Response): void {
+		// No-op for in-process - tokens are managed directly
+	}
+
+	async prepareHeaders(
+		_method: string,
+		_url: string,
+		_body?: unknown
+	): Promise<Record<string, string>> {
+		return this.getHeaders();
+	}
+
+	async getDefinitions(options?: { apiGroups?: string[] }): Promise<{
+		typescript: string;
+		version: string;
+		apiGroups: string[];
+	}> {
+		await this.ensureInitialized();
+
+		const ctx = this.createContext({
+			method: 'GET',
+			path: '/api/definitions',
+			query: options?.apiGroups ? { apiGroups: options.apiGroups.join(',') } : {},
+		});
+
+		return (await this.server.getDefinitions(ctx)) as {
+			typescript: string;
+			version: string;
+			apiGroups: string[];
+		};
+	}
+
+	async getRuntimeDefinitions(options?: { apis?: string[] }): Promise<string> {
+		await this.ensureInitialized();
+
+		const ctx = this.createContext({
+			method: 'GET',
+			path: '/api/runtime',
+			query: options?.apis?.length ? { apis: options.apis.join(',') } : {},
+		});
+
+		return await this.server.getRuntimeDefinitions(ctx);
+	}
+
+	async getServerInfo(): Promise<{
+		version: string;
+		capabilities: Record<string, boolean>;
+	}> {
+		await this.ensureInitialized();
+		return this.server.getInfo() as {
+			version: string;
+			capabilities: Record<string, boolean>;
+		};
+	}
+
+	async search(query: string, options?: Record<string, unknown>): Promise<{ results: unknown[] }> {
+		await this.ensureInitialized();
+
+		const ctx = this.createContext({
+			method: 'POST',
+			path: '/api/search',
+			body: { query, ...options },
+		});
+
+		return (await this.server.handleSearch(ctx)) as { results: unknown[] };
+	}
+
+	async explore(path: string): Promise<unknown> {
+		await this.ensureInitialized();
+
+		const ctx = this.createContext({
+			method: 'POST',
+			path: '/api/explore',
+			body: { path },
+		});
+
+		return await this.server.handleExplore(ctx);
+	}
+
+	async execute(code: string, config?: Record<string, unknown>): Promise<unknown> {
+		await this.ensureInitialized();
+
+		const ctx = this.createContext({
+			method: 'POST',
+			path: '/api/execute',
+			body: { code, config },
+		});
+
+		return await this.server.handleExecute(ctx);
+	}
+
+	async resume(executionId: string, callbackResult: unknown): Promise<unknown> {
+		await this.ensureInitialized();
+
+		const ctx = this.createContext({
+			method: 'POST',
+			path: `/api/resume/${executionId}`,
+			body: { result: callbackResult },
+		});
+
+		return await this.server.handleResume(ctx, executionId);
+	}
+
+	async resumeWithBatchResults(
+		executionId: string,
+		batchResults: Array<{ id: string; result: unknown }>
+	): Promise<unknown> {
+		await this.ensureInitialized();
+
+		const ctx = this.createContext({
+			method: 'POST',
+			path: `/api/resume/${executionId}`,
+			body: { results: batchResults },
+		});
+
+		return await this.server.handleResume(ctx, executionId);
+	}
+
+	private createContext(options: {
+		method: string;
+		path: string;
+		query?: Record<string, string>;
+		body?: unknown;
+	}): InProcessRequestContext {
+		const noopLogger = {
+			debug: () => {},
+			info: () => {},
+			warn: () => {},
+			error: () => {},
+		};
+
+		return {
+			method: options.method,
+			path: options.path,
+			query: options.query || {},
+			headers: this.getHeaders(),
+			body: options.body,
+			clientId: this.clientId,
+			clientToken: this.clientToken,
+			logger: noopLogger,
+			status: 200,
+			responseBody: null,
+			throw: (status: number, message: string) => {
+				const error = new Error(message);
+				(error as Error & { status: number }).status = status;
+				throw error;
+			},
+			assert: (condition: boolean, message: string) => {
+				if (!condition) {
+					throw new Error(message);
+				}
+			},
+			set: () => {},
+		};
+	}
+}
+

package/src/core/index.ts

@@ -1,4 +1,5 @@
 export * from './session.js';
+export * from './in-process-session.js';
 export * from './api-operations.js';
 export * from './execution-operations.js';
 export * from './service-providers.js';

package/src/core/provenance-registry.ts

@@ -7,12 +7,14 @@
 export interface TokenEntry {
 	token: string;
 	addedAt: number;
+	sequence: number;
 }
 
 export class ProvenanceTokenRegistry {
 	private cache: Map<string, TokenEntry> = new Map();
 	private maxSize: number;
 	private ttl: number;
+	private sequenceCounter: number = 0;
 
 	constructor(maxSize: number = 10000, ttlHours: number = 1) {
 		this.maxSize = maxSize;
@@ -31,17 +33,23 @@ export class ProvenanceTokenRegistry {
 			this.evictLRU();
 		}
 
-		// Store token
+		// Store token with sequence number for stable ordering
 		this.cache.set(token, {
 			token,
 			addedAt: Date.now(),
+			sequence: this.sequenceCounter++,
 		});
 	}
 
 	/**
 	 * Get recent tokens (non-expired, sorted by age, limited)
+	 * Returns tokens in chronological order (oldest first, most recent last)
 	 */
 	getRecentTokens(maxCount: number = 1000): string[] {
+		if (maxCount <= 0) {
+			return [];
+		}
+
 		this.evictExpired();
 
 		const now = Date.now();
@@ -66,8 +74,8 @@ export class ProvenanceTokenRegistry {
 					return false;
 				}
 			})
-			.sort((a, b) => b.addedAt - a.addedAt)
-			.slice(0, maxCount);
+			.sort((a, b) => a.sequence - b.sequence)
+			.slice(-maxCount);
 
 		for (const token of expiredTokens) {
 			this.cache.delete(token);
@@ -113,11 +121,11 @@ export class ProvenanceTokenRegistry {
 	 */
 	private evictLRU(): void {
 		let oldestToken: string | null = null;
-		let oldestTime = Infinity;
+		let oldestSequence = Infinity;
 
 		for (const [token, entry] of this.cache.entries()) {
-			if (entry.addedAt < oldestTime) {
-				oldestTime = entry.addedAt;
+			if (entry.sequence < oldestSequence) {
+				oldestSequence = entry.sequence;
 				oldestToken = token;
 			}
 		}

package/src/core/session.ts

@@ -1,7 +1,26 @@
 import type { ClientHooks } from './types.js';
 import type { ClientToolDefinition } from '@mondaydotcomorg/atp-protocol';
 
-export class ClientSession {
+export interface ISession {
+	init(
+		clientInfo?: { name?: string; version?: string; [key: string]: unknown },
+		tools?: ClientToolDefinition[],
+		services?: { hasLLM: boolean; hasApproval: boolean; hasEmbedding: boolean; hasTools: boolean }
+	): Promise<{
+		clientId: string;
+		token: string;
+		expiresAt: number;
+		tokenRotateAt: number;
+	}>;
+	getClientId(): string;
+	ensureInitialized(): Promise<void>;
+	getHeaders(): Record<string, string>;
+	getBaseUrl(): string;
+	updateToken(response: Response): void;
+	prepareHeaders(method: string, url: string, body?: unknown): Promise<Record<string, string>>;
+}
+
+export class ClientSession implements ISession {
 	private baseUrl: string;
 	private customHeaders: Record<string, string>;
 	private clientId?: string;

package/src/index.ts

@@ -9,3 +9,5 @@ export type { RuntimeAPIName } from '@mondaydotcomorg/atp-runtime';
 export type { Tool, ToolName } from './tools/types.js';
 export { ToolNames } from './tools/types.js';
 export type { AgentToolProtocolClientOptions } from './client.js';
+export { InProcessSession } from './core/in-process-session.js';
+export type { ISession } from './core/session.js';