@mondaydotcomorg/atp-client 0.19.6 → 0.19.8

package/src/core/execution-operations.ts

@@ -1,19 +1,26 @@
 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 +139,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 +396,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 +447,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,293 @@
+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/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';