@agentuity/runtime 0.0.43 → 0.0.45

package/src/_services.ts

@@ -11,18 +11,42 @@ import {
 	type ListStreamsResponse,
 	type VectorUpsertResult,
 	type VectorSearchResult,
+	type Logger,
+	type SessionEventProvider,
+	type EvalRunEventProvider,
 } from '@agentuity/core';
-import { createServerFetchAdapter, getServiceUrls } from '@agentuity/server';
+import { /*APIClient,*/ createServerFetchAdapter, getServiceUrls } from '@agentuity/server';
+import {
+	CompositeSessionEventProvider,
+	LocalSessionEventProvider,
+	JSONSessionEventProvider,
+	// HTTPSessionEventProvider,
+} from './services/session';
+import {
+	CompositeEvalRunEventProvider,
+	LocalEvalRunEventProvider,
+	JSONEvalRunEventProvider,
+	// HTTPEvalRunEventProvider,
+} from './services/evalrun';
 import { injectTraceContextToHeaders } from './otel/http';
 import { getLogger, getTracer } from './_server';
-import { getSDKVersion, isAuthenticated } from './_config';
+import { getSDKVersion, isAuthenticated, isProduction } from './_config';
 import type { AppConfig } from './app';
 import {
-	UnauthenticatedKeyValueStorage,
-	UnauthenticatedObjectStorage,
-	UnauthenticatedStreamStorage,
-	UnauthenticatedVectorStorage,
-} from './_unauthenticated';
+	DefaultSessionProvider,
+	DefaultThreadProvider,
+	type ThreadProvider,
+	type SessionProvider,
+} from './session';
+import {
+	LocalKeyValueStorage,
+	LocalObjectStorage,
+	LocalStreamStorage,
+	LocalVectorStorage,
+	getLocalDB,
+	normalizeProjectPath,
+	createLocalStorageRouter,
+} from './services/local';
 
 const userAgent = `Agentuity SDK/${getSDKVersion()}`;
 const bearerKey = `Bearer ${process.env.AGENTUITY_SDK_KEY}`;
@@ -32,6 +56,7 @@ const kvBaseUrl = serviceUrls.keyvalue;
 const streamBaseUrl = serviceUrls.stream;
 const vectorBaseUrl = serviceUrls.vector;
 const objectBaseUrl = serviceUrls.objectstore;
+// const catalystBaseUrl = serviceUrls.catalyst;
 
 const adapter = createServerFetchAdapter({
 	headers: {
@@ -149,45 +174,113 @@ let kv: KeyValueStorage;
 let objectStore: ObjectStorage;
 let stream: StreamStorage;
 let vector: VectorStorage;
+let session: SessionProvider;
+let thread: ThreadProvider;
+let sessionEvent: SessionEventProvider;
+let evalRunEvent: EvalRunEventProvider;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let localRouter: any | null = null;
 
-export function createServices(config?: AppConfig) {
+export function createServices(logger: Logger, config?: AppConfig, serverUrl?: string) {
 	const authenticated = isAuthenticated();
+	const useLocal = config?.services?.useLocal ?? false;
 
-	if (config?.services?.keyvalue) {
-		kv = config.services.keyvalue;
-	} else if (authenticated) {
-		kv = new KeyValueStorageService(kvBaseUrl, adapter);
-	} else {
-		kv = new UnauthenticatedKeyValueStorage();
-	}
+	// Use local services if explicitly requested OR if not authenticated
+	const shouldUseLocal =
+		useLocal || !authenticated || process.env.AGENTUITY_FORCE_LOCAL_SERVICES === 'true';
 
-	if (config?.services?.object) {
-		objectStore = config.services.object;
-	} else if (authenticated) {
-		objectStore = new ObjectStorageService(objectBaseUrl, adapter);
-	} else {
-		objectStore = new UnauthenticatedObjectStorage();
+	if (shouldUseLocal) {
+		const db = getLocalDB();
+		const projectPath = normalizeProjectPath();
+
+		if (!serverUrl) {
+			throw new Error('serverUrl is required when using local services');
+		}
+
+		logger.info('Using local services (development only)');
+
+		kv = config?.services?.keyvalue || new LocalKeyValueStorage(db, projectPath);
+		objectStore = config?.services?.object || new LocalObjectStorage(db, projectPath, serverUrl);
+		stream = config?.services?.stream || new LocalStreamStorage(db, projectPath, serverUrl);
+		vector = config?.services?.vector || new LocalVectorStorage(db, projectPath);
+		session = config?.services?.session || new DefaultSessionProvider();
+		thread = config?.services?.thread || new DefaultThreadProvider();
+		sessionEvent = config?.services?.sessionEvent
+			? new CompositeSessionEventProvider(
+					new LocalSessionEventProvider(),
+					config.services.sessionEvent
+				)
+			: new LocalSessionEventProvider();
+		evalRunEvent = config?.services?.evalRunEvent
+			? new CompositeEvalRunEventProvider(
+					new LocalEvalRunEventProvider(),
+					config.services.evalRunEvent
+				)
+			: new LocalEvalRunEventProvider();
+
+		localRouter = createLocalStorageRouter(db, projectPath);
+
+		return { localRouter };
 	}
 
-	if (config?.services?.stream) {
-		stream = config.services.stream;
-	} else if (authenticated) {
-		stream = new StreamStorageService(streamBaseUrl, adapter);
-	} else {
-		stream = new UnauthenticatedStreamStorage();
+	// Reset local router if not using local services
+	localRouter = null;
+
+	// At this point we must be authenticated (since !authenticated would trigger local services above)
+	kv = config?.services?.keyvalue || new KeyValueStorageService(kvBaseUrl, adapter);
+	objectStore = config?.services?.object || new ObjectStorageService(objectBaseUrl, adapter);
+	stream = config?.services?.stream || new StreamStorageService(streamBaseUrl, adapter);
+	vector = config?.services?.vector || new VectorStorageService(vectorBaseUrl, adapter);
+	session = config?.services?.session || new DefaultSessionProvider();
+	thread = config?.services?.thread || new DefaultThreadProvider();
+	sessionEvent =
+		isProduction() && process.env.AGENTUITY_CLOUD_EXPORT_DIR
+			? new JSONSessionEventProvider(process.env.AGENTUITY_CLOUD_EXPORT_DIR)
+			: // FIXME: this is turned off for now for production until we have the new changes deployed
+
+				// ? new HTTPSessionEventProvider(new APIClient(catalystBaseUrl, logger))
+				new LocalSessionEventProvider();
+	if (config?.services?.sessionEvent) {
+		sessionEvent = new CompositeSessionEventProvider(sessionEvent, config.services.sessionEvent);
 	}
+	evalRunEvent =
+		isProduction() && process.env.AGENTUITY_CLOUD_EXPORT_DIR
+			? new JSONEvalRunEventProvider(process.env.AGENTUITY_CLOUD_EXPORT_DIR)
+			: // FIXME: this is turned off for now for production until we have the new changes deployed
 
-	if (config?.services?.vector) {
-		vector = config.services.vector;
-	} else if (authenticated) {
-		vector = new VectorStorageService(vectorBaseUrl, adapter);
-	} else {
-		vector = new UnauthenticatedVectorStorage();
+				// ? new HTTPEvalRunEventProvider(new APIClient(catalystBaseUrl, logger), logger, catalystBaseUrl)
+				new LocalEvalRunEventProvider();
+	if (config?.services?.evalRunEvent) {
+		evalRunEvent = new CompositeEvalRunEventProvider(evalRunEvent, config.services.evalRunEvent);
 	}
+
+	return {};
+}
+
+export function getThreadProvider(): ThreadProvider {
+	return thread;
+}
+
+export function getSessionProvider(): SessionProvider {
+	return session;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function getLocalRouter(): any | null {
+	return localRouter;
+}
+
+export function getSessionEventProvider() {
+	return sessionEvent;
+}
+
+export function getEvalRunEventProvider() {
+	return evalRunEvent;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function registerServices(o: any) {
+export function registerServices(o: any, includeAgents = false) {
 	Object.defineProperty(o, 'kv', {
 		get: () => kv,
 		enumerable: false,
@@ -208,4 +301,24 @@ export function registerServices(o: any) {
 		enumerable: false,
 		configurable: false,
 	});
+
+	// Also register agent registry if requested
+	if (includeAgents) {
+		// Cache the populated registry to avoid re-creating on every access
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		let cachedRegistry: any;
+		Object.defineProperty(o, 'agent', {
+			get: () => {
+				if (!cachedRegistry) {
+					// Lazy-load to avoid circular dependency
+					// eslint-disable-next-line @typescript-eslint/no-require-imports
+					const { populateAgentsRegistry } = require('./agent');
+					cachedRegistry = populateAgentsRegistry(o);
+				}
+				return cachedRegistry;
+			},
+			enumerable: false,
+			configurable: false,
+		});
+	}
 }

package/src/_util.ts

@@ -1,7 +1,6 @@
 import type { Context } from 'hono';
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function returnResponse(ctx: Context, result: any) {
+export function returnResponse(ctx: Context, result: unknown) {
 	if (result instanceof ReadableStream) return ctx.body(result);
 	if (result instanceof Response) return result;
 	if (typeof result === 'string') return ctx.text(result);
@@ -17,7 +16,7 @@ export function returnResponse(ctx: Context, result: any) {
  */
 export function hash(...val: string[]): string {
 	const hasher = new Bun.CryptoHasher('sha256');
-	val.forEach((val) => hasher.update(val));
+	val.map((val) => hasher.update(val));
 	return hasher.digest().toHex();
 }
 

package/src/_waituntil.ts

@@ -18,20 +18,16 @@ export default class WaitUntilHandler {
 	private tracer: Tracer;
 	private started: number | undefined;
 	private hasCalledWaitUntilAll = false;
-	private setHeader: (k: string, v: string) => void;
 
-	public constructor(setHeader: (k: string, v: string) => void, tracer: Tracer) {
+	public constructor(tracer: Tracer) {
 		this.tracer = tracer;
 		this.promises = [];
-		this.setHeader = setHeader;
-		this.hasCalledWaitUntilAll = false;
 	}
 
 	public waitUntil(promise: Promise<void> | (() => void | Promise<void>)): void {
 		if (this.hasCalledWaitUntilAll) {
 			throw new Error('Cannot call waitUntil after waitUntilAll has been called');
 		}
-		this.setHeader('x-agentuity-session-pending', 'true');
 		running++;
 		internal.debug('wait until called, running: %d', running);
 		const currentContext = context.active();
@@ -69,11 +65,6 @@ export default class WaitUntilHandler {
 		return this.promises.length > 0;
 	}
 
-	private async markSessionCompleted(sessionId: string, duration: number) {
-		// TODO:
-		internal.debug('markSessionCompleted sessionId: %s, duration: %dms', sessionId, duration);
-	}
-
 	public async waitUntilAll(logger: Logger, sessionId: string): Promise<void> {
 		internal.debug(`🔍 waitUntilAll() called for session ${sessionId} (count: %d)`, running);
 
@@ -93,12 +84,10 @@ export default class WaitUntilHandler {
 			// Promises are already executing, just wait for them to complete
 			await Promise.all(this.promises);
 			const duration = Date.now() - (this.started as number);
-			internal.debug('✅ All promises completed, marking session completed');
-			await this.markSessionCompleted(sessionId, duration);
-
-			// // Execute evals after session completion
-			// internal.debug('🚀 Starting eval execution after session completion');
-			// await this.executeEvalsForSession(logger, sessionId);
+			internal.debug(
+				'✅ All promises completed, marking session completed (duration %dms)',
+				duration
+			);
 		} catch (ex) {
 			logger.error('error sending session completed', ex);
 		} finally {
@@ -106,141 +95,4 @@ export default class WaitUntilHandler {
 			this.promises.length = 0;
 		}
 	}
-
-	// /**
-	//  * Execute evals for the completed session
-	//  */
-	// private async executeEvalsForSession(
-	// 	logger: Logger,
-	// 	sessionId: string
-	// ): Promise<void> {
-	// 	try {
-	// 		internal.debug(`🔍 Starting eval execution for session ${sessionId}`);
-
-	// 		// Get pending eval jobs for this session
-	// 		internal.debug('🔍 Getting EvalJobScheduler instance...');
-	// 		const evalJobScheduler = await EvalJobScheduler.getInstance();
-	// 		internal.debug('✅ EvalJobScheduler instance obtained');
-
-	// 		internal.debug(`🔍 Querying jobs for session ${sessionId}...`);
-	// 		const jobs = evalJobScheduler.getJobs({ sessionId });
-
-	// 		if (jobs.length === 0) {
-	// 			internal.debug(`📭 No eval jobs found for session ${sessionId}`);
-	// 			return;
-	// 		}
-
-	// 		internal.debug(
-	// 			`📋 Found ${jobs.length} eval jobs for session ${sessionId}`
-	// 		);
-
-	// 		// Load eval metadata map
-	// 		internal.debug('🔧 Loading eval metadata map...');
-	// 		const evalAPI = new EvalAPI();
-	// 		const evalMetadataMap = await evalAPI.loadEvalMetadataMap();
-	// 		internal.debug(`📚 Loaded ${evalMetadataMap.size} eval mappings`);
-
-	// 		// Execute evals for each job
-	// 		let totalEvalsExecuted = 0;
-	// 		for (let i = 0; i < jobs.length; i++) {
-	// 			const job = jobs[i];
-	// 			internal.debug(
-	// 				`🎯 Processing job ${i + 1}/${jobs.length} (spanId: ${job.spanId})`
-	// 			);
-	// 			const evalsInJob = await this.executeEvalsForJob(
-	// 				logger,
-	// 				job,
-	// 				evalAPI,
-	// 				evalMetadataMap
-	// 			);
-	// 			totalEvalsExecuted += evalsInJob;
-	// 			internal.debug(
-	// 				`✅ Completed job ${i + 1}/${jobs.length}: ${evalsInJob} evals executed`
-	// 			);
-	// 		}
-
-	// 		internal.debug(
-	// 			`✅ Completed eval execution for session ${sessionId}: ${totalEvalsExecuted} evals executed`
-	// 		);
-
-	// 		// Clean up completed jobs
-	// 		internal.debug(`🧹 Cleaning up ${jobs.length} completed jobs...`);
-	// 		for (const job of jobs) {
-	// 			evalJobScheduler.removeJob(job.spanId);
-	// 		}
-	// 		internal.debug(`✅ Cleaned up ${jobs.length} completed jobs`);
-	// 	} catch (error) {
-	// 		logger.error('❌ Error executing evals for session:', error);
-	// 	}
-	// }
-
-	// /**
-	//  * Execute evals for a specific job
-	//  */
-	// private async executeEvalsForJob(
-	// 	logger: Logger,
-	// 	job: {
-	// 		spanId: string;
-	// 		sessionId: string;
-	// 		promptMetadata: PromptAttributes[];
-	// 		input?: string;
-	// 		output?: string;
-	// 	},
-	// 	evalAPI: EvalAPI,
-	// 	evalMetadataMap: Map<string, string>
-	// ): Promise<number> {
-	// 	let evalsExecuted = 0;
-
-	// 	internal.debug(
-	// 		`🎯 Processing job ${job.spanId} with ${job.promptMetadata.length} prompt metadata entries`
-	// 	);
-
-	// 	for (const promptMeta of job.promptMetadata || []) {
-	// 		if (!promptMeta.evals || promptMeta.evals.length === 0) {
-	// 			logger.debug('⏭️  Skipping prompt metadata with no evals');
-	// 			continue;
-	// 		}
-
-	// 		internal.debug(
-	// 			`📝 Found ${promptMeta.evals.length} evals for prompt: ${promptMeta.evals.join(', ')}`
-	// 		);
-
-	// 		for (const evalSlug of promptMeta.evals) {
-	// 			try {
-	// 				internal.debug(
-	// 					`🚀 Running eval '${evalSlug}' for session ${job.sessionId}`
-	// 				);
-
-	// 				internal.debug(`🔑 Template hash: ${promptMeta.templateHash}`);
-	// 				internal.debug(`🔑 Compiled hash: ${promptMeta.compiledHash}`);
-
-	// 				const result = await evalAPI.runEval(
-	// 					evalSlug,
-	// 					job.input || '',
-	// 					job.output || '',
-	// 					job.sessionId,
-	// 					job.spanId,
-	// 					promptMeta.templateHash
-	// 				);
-
-	// 				if (result.success) {
-	// 					internal.debug(`✅ Successfully executed eval '${evalSlug}'`);
-	// 					evalsExecuted++;
-	// 				} else {
-	// 					logger.warn(
-	// 						`⚠️  Eval '${evalSlug}' completed but returned error: ${result.message}`
-	// 					);
-	// 				}
-	// 			} catch (error) {
-	// 				logger.error(`❌ Failed to execute eval '${evalSlug}':`, error);
-	// 				// Continue with other evals even if one fails
-	// 			}
-	// 		}
-	// 	}
-
-	// 	internal.debug(
-	// 		`📊 Job ${job.spanId} completed: ${evalsExecuted} evals executed`
-	// 	);
-	// 	return evalsExecuted;
-	// }
 }