@agentuity/runtime 0.0.43 → 0.0.45

package/src/_server.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
 import {
 	context,
 	SpanKind,
@@ -7,29 +6,39 @@ import {
 	type Tracer,
 	trace,
 	type Attributes,
+	propagation,
 } from '@opentelemetry/api';
+import { TraceState } from '@opentelemetry/core';
 import type { Span } from '@opentelemetry/sdk-trace-base';
 import type { SpanProcessor } from '@opentelemetry/sdk-trace-base';
-import { ServiceException } from '@agentuity/core';
+import { type LogLevel, ServiceException } from '@agentuity/core';
 import { cors } from 'hono/cors';
 import { createMiddleware } from 'hono/factory';
-import { Hono } from 'hono';
+import { Hono, type Context as HonoContext } from 'hono';
 import { HTTPException } from 'hono/http-exception';
 import type { BunWebSocketData } from 'hono/bun';
+import { matchedRoutes } from 'hono/route';
 import { websocket } from 'hono/bun';
-import type { AppConfig, Env } from './app';
+import { join } from 'node:path';
+import type { AppConfig, Env, PrivateVariables } from './app';
 import { extractTraceContextFromRequest } from './otel/http';
 import { register } from './otel/config';
 import type { Logger } from './logger';
 import { isIdle } from './_idle';
 import * as runtimeConfig from './_config';
 import { inAgentContext, getAgentContext } from './_context';
-import { createServices } from './_services';
+import {
+	createServices,
+	getThreadProvider,
+	getSessionProvider,
+	getSessionEventProvider,
+} from './_services';
+import { generateId } from './session';
+import WaitUntilHandler from './_waituntil';
 
 let globalServerInstance: Bun.Server<BunWebSocketData> | null = null;
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let globalAppInstance: Hono<any> | null = null;
+let globalRouterInstance: Hono<Env> | null = null;
 
 let globalLogger: Logger | null = null;
 let globalTracer: Tracer | null = null;
@@ -38,8 +47,8 @@ export function getServer() {
 	return globalServerInstance;
 }
 
-export function getApp() {
-	return globalAppInstance;
+export function getRouter() {
+	return globalRouterInstance;
 }
 
 export function getLogger() {
@@ -57,7 +66,7 @@ function isDevelopment(): boolean {
 }
 
 function getPort(): number {
-	return Number.parseInt(process.env.AGENTUITY_PORT ?? process.env.PORT ?? '3000') || 3000;
+	return Number.parseInt(process.env.AGENTUITY_PORT ?? process.env.PORT ?? '3500', 10) || 3500;
 }
 
 const spanProcessors: SpanProcessor[] = [];
@@ -111,33 +120,46 @@ function registerAgentuitySpanProcessor() {
 	addSpanProcessor(new RegisterAgentSpanProcessor());
 }
 
-export const createServer = <E extends Env>(app: Hono<E>, config?: AppConfig) => {
+export function privateContext<E extends Env>(c: HonoContext<E>) {
+	return c as unknown as HonoContext<{ Variables: PrivateVariables }>;
+}
+
+export const createServer = <E extends Env>(router: Hono<E>, config?: AppConfig) => {
 	if (globalServerInstance) {
 		return globalServerInstance;
 	}
 
-	createServices(config);
+	const logLevel = process.env.AGENTUITY_LOG_LEVEL || 'info';
+	const port = getPort();
+	const hostname = '127.0.0.1';
+	const serverUrl = `http://${hostname}:${port}`;
+
+	// this must come before registering any otel stuff
 	registerAgentuitySpanProcessor();
 
+	// Create the telemetry and logger
+	const otel = register({ processors: spanProcessors, logLevel: logLevel as LogLevel });
+
+	// Create services (may return local router)
+	const servicesResult = createServices(otel.logger, config, serverUrl);
+
 	const server = Bun.serve({
-		hostname: '127.0.0.1',
+		hostname,
 		development: isDevelopment(),
-		fetch: app.fetch,
+		fetch: router.fetch,
 		idleTimeout: 0,
-		port: getPort(),
+		port,
 		websocket,
 	});
 
-	const otel = register({ processors: spanProcessors });
-
-	globalAppInstance = app;
+	globalRouterInstance = router as unknown as Hono<Env>;
 	globalServerInstance = server;
 	globalLogger = otel.logger;
 	globalTracer = otel.tracer;
 
 	let isShutdown = false;
 
-	app.onError((error, _c) => {
+	router.onError((error, _c) => {
 		if (error instanceof HTTPException) {
 			otel.logger.error('HTTP Error: %s (%d)', error.cause, error.status);
 			return error.getResponse();
@@ -150,16 +172,35 @@ export const createServer = <E extends Env>(app: Hono<E>, config?: AppConfig) =>
 			error instanceof ServiceException ||
 			('statusCode' in error && typeof error.statusCode === 'number')
 		) {
-			otel.logger.error('Service Exception: %s (%d)', error.message, error.statusCode);
+			const serviceError = error as ServiceException;
+			otel.logger.error(
+				'Service Exception: %s (%s returned HTTP status code: %d)',
+				error.message,
+				serviceError.url,
+				serviceError.statusCode
+			);
 			return new Response(error.message, {
-				status: (error.statusCode as number) ?? 500,
+				status: serviceError.statusCode ?? 500,
 			});
 		}
-		otel.logger.error('Unhandled Server Error: %s', error);
+		otel.logger.error('Unhandled Server Error: %s', JSON.stringify(error));
 		return new Response('Internal Server Error', { status: 500 });
 	});
 
-	app.use(async (c, next) => {
+	const threadProvider = getThreadProvider();
+	const sessionProvider = getSessionProvider();
+
+	let initPromise: Promise<void> | undefined = new Promise((resolve, reject) => {
+		Promise.all([threadProvider.initialize(), sessionProvider.initialize()])
+			.then(() => resolve())
+			.catch(reject);
+	});
+
+	router.use(async (c, next) => {
+		if (initPromise) {
+			await initPromise;
+			initPromise = undefined;
+		}
 		c.set('logger', otel.logger);
 		c.set('tracer', otel.tracer);
 		c.set('meter', otel.meter);
@@ -169,7 +210,9 @@ export const createServer = <E extends Env>(app: Hono<E>, config?: AppConfig) =>
 		if (!skipLogging) {
 			otel.logger.debug('%s %s started', c.req.method, c.req.path);
 		}
+
 		await next();
+
 		// Don't log completion for websocket upgrades - they stay open
 		if (!skipLogging && !isWebSocket) {
 			otel.logger.debug(
@@ -183,7 +226,7 @@ export const createServer = <E extends Env>(app: Hono<E>, config?: AppConfig) =>
 	});
 
 	// setup the cors middleware
-	app.use(
+	router.use(
 		'*',
 		cors({
 			origin: config?.cors?.origin ?? ((origin) => origin),
@@ -202,23 +245,78 @@ export const createServer = <E extends Env>(app: Hono<E>, config?: AppConfig) =>
 		})
 	);
 
-	app.route('/_agentuity', createAgentuityAPIs());
+	router.get('/_health', (c) => c.text('OK'));
+	router.route('/_agentuity', createAgentuityAPIs());
 
-	// Attach services to context for API routes
-	app.use('/api/*', async (c, next) => {
-		const { registerServices } = await import('./_services');
-		registerServices(c);
-		await next();
+	// Mount local storage router if using local services
+	if (servicesResult?.localRouter) {
+		router.route('/', servicesResult.localRouter);
+	}
+
+	// we create a middleware that attempts to match our routeid to the incoming route
+	let routeMapping: Record<string, string>;
+	const routePathMapper = createMiddleware<Env>(async (c, next) => {
+		if (!routeMapping) {
+			// Look for .routemapping.json in the project's .agentuity directory
+			// This is where the build plugin writes it (build.config.outdir)
+			const projectRoot = process.cwd();
+			const routeMappingPath = join(projectRoot, '.agentuity', '.routemapping.json');
+			const file = Bun.file(routeMappingPath);
+			if (!(await file.exists())) {
+				c.var.logger.fatal(
+					'error loading the .routemapping.json from the %s directory. this is a build issue!',
+					routeMappingPath
+				);
+			}
+			routeMapping = (await file.json()) as Record<string, string>;
+		}
+		const matches = matchedRoutes(c).filter(
+			(m) => m.method !== 'ALL' && (m.path.startsWith('/api') || m.path.startsWith('/agent/'))
+		);
+		const _c = privateContext(c);
+		if (matches.length > 0) {
+			const method = c.req.method.toLowerCase();
+			for (const m of matches) {
+				const found = routeMapping[`${method} ${m.path}`];
+				if (found) {
+					_c.set('routeId', found);
+					break;
+				}
+			}
+		}
+		_c.set('trigger', 'api'); // will get overwritten below if another trigger
+		return next();
+	});
+
+	router.use('/agent/*', routePathMapper);
+	router.use('/api/*', routePathMapper);
+
+	// Attach services and agent registry to context for API routes
+	router.use('/api/*', async (c, next) => {
+		const { createAgentMiddleware } = await import('./agent');
+		// Use a null agent name to just populate the agent registry without setting current agent
+		return createAgentMiddleware('')(c, next);
 	});
 
-	app.use('/api/*', otelMiddleware);
-	app.use('/agent/*', otelMiddleware);
+	// set the trigger for specific types
+	for (const trigger of ['sms', 'email', 'cron'] as const) {
+		const middleware = createMiddleware(async (c, next) => {
+			const _c = privateContext(c);
+			_c.set('trigger', trigger);
+			await next();
+		});
+		router.use(`/api/${trigger}/*`, middleware);
+		router.use(`/agent/${trigger}/*`, middleware);
+	}
+
+	router.use('/api/*', otelMiddleware);
+	router.use('/agent/*', otelMiddleware);
 
 	const shutdown = async () => {
 		if (isShutdown) {
 			return;
 		}
-		otel.logger.info('shutdown started');
+		otel.logger.debug('shutdown started');
 		isShutdown = true;
 		// Force exit after timeout if cleanup hangs
 		const forceExitTimer = setTimeout(() => {
@@ -228,7 +326,7 @@ export const createServer = <E extends Env>(app: Hono<E>, config?: AppConfig) =>
 		try {
 			await server.stop();
 			await otel.shutdown();
-			otel.logger.info('shutdown completed');
+			otel.logger.debug('shutdown completed');
 		} finally {
 			clearTimeout(forceExitTimer);
 		}
@@ -269,10 +367,11 @@ const createAgentuityAPIs = () => {
 	const router = new Hono<Env>();
 	router.get('idle', (c) => {
 		if (isIdle()) {
-			return new Response('OK', { status: 200 });
+			return c.text('OK', { status: 200 });
 		}
-		return new Response('NO', { status: 200 });
+		return c.text('NO', { status: 200 });
 	});
+	router.get('health', (c) => c.text('OK'));
 	return router;
 };
 
@@ -282,11 +381,15 @@ const otelMiddleware = createMiddleware<Env>(async (c, next) => {
 
 	const method = c.req.method;
 	const url = new URL(c.req.url);
+	const threadProvider = getThreadProvider();
+	const sessionProvider = getSessionProvider();
+	const sessionEventProvider = getSessionEventProvider();
 
 	// Execute the request handler within the extracted context
 	await context.with(extractedContext, async (): Promise<void> => {
 		// Create a span for this incoming request
-		await trace.getTracer('http-server').startActiveSpan(
+		const tracer = trace.getTracer('http-server');
+		await tracer.startActiveSpan(
 			`HTTP ${method}`,
 			{
 				kind: SpanKind.SERVER,
@@ -298,11 +401,126 @@ const otelMiddleware = createMiddleware<Env>(async (c, next) => {
 				},
 			},
 			async (span): Promise<void> => {
+				const sctx = span.spanContext();
+				const sessionId = sctx?.traceId ? `sess_${sctx.traceId}` : generateId('sess');
+
+				// Add to tracestate
+				let traceState = sctx.traceState ?? new TraceState();
+				const projectId = runtimeConfig.getProjectId();
+				const orgId = runtimeConfig.getOrganizationId();
+				const deploymentId = runtimeConfig.getDeploymentId();
+				const isDevMode = runtimeConfig.isDevMode();
+				if (projectId) {
+					traceState = traceState.set('pid', projectId);
+				}
+				if (orgId) {
+					traceState = traceState.set('oid', orgId);
+				}
+				if (isDevMode) {
+					traceState = traceState.set('d', '1');
+				}
+				sctx.traceState = traceState;
+
+				const thread = await threadProvider.restore(c as unknown as HonoContext<Env>);
+				const session = await sessionProvider.restore(thread, sessionId);
+				const handler = new WaitUntilHandler(tracer);
+
+				const _c = privateContext(c);
+				const agentIds = new Set<string>();
+				_c.set('agentIds', agentIds);
+
+				const shouldSendSession = orgId && projectId && _c.var.routeId;
+				let canSendSessionEvents = true;
+
+				if (shouldSendSession) {
+					await sessionEventProvider
+						.start({
+							id: sessionId,
+							orgId,
+							projectId,
+							threadId: thread.id,
+							routeId: _c.var.routeId,
+							deploymentId,
+							devmode: isDevMode,
+							environment: runtimeConfig.getEnvironment(),
+							method: c.req.method,
+							url: c.req.url,
+							trigger: _c.var.trigger,
+						})
+						.catch((ex) => {
+							canSendSessionEvents = false;
+							c.var.logger.error('error sending session start event: %s', ex);
+						});
+				}
+
+				c.set('sessionId', sessionId);
+				c.set('thread', thread);
+				c.set('session', session);
+				_c.set('waitUntilHandler', handler);
+
+				let hasPendingWaits = false;
+
 				try {
 					await next();
-					span.setStatus({
-						code: SpanStatusCode.OK,
-					});
+					if (handler?.hasPending()) {
+						hasPendingWaits = true;
+						handler
+							.waitUntilAll(c.var.logger, sessionId)
+							.then(async () => {
+								c.var.logger.debug('wait until finished for session %s', sessionId);
+								await sessionProvider.save(session);
+								await threadProvider.save(thread);
+								span.setStatus({ code: SpanStatusCode.OK });
+								if (shouldSendSession && canSendSessionEvents) {
+									sessionEventProvider
+										.complete({
+											id: sessionId,
+											statusCode: c.res.status,
+											agentIds: Array.from(agentIds),
+										})
+										.then(() => {})
+										.catch((ex) => c.var.logger.error(ex));
+								}
+							})
+							.catch((ex) => {
+								c.var.logger.error('wait until errored for session %s. %s', sessionId, ex);
+								if (ex instanceof Error) {
+									span.recordException(ex);
+								}
+								const message = (ex as Error).message ?? String(ex);
+								span.setStatus({
+									code: SpanStatusCode.ERROR,
+									message,
+								});
+								c.var.logger.error(message);
+								if (shouldSendSession && canSendSessionEvents) {
+									sessionEventProvider
+										.complete({
+											id: sessionId,
+											statusCode: c.res.status,
+											error: message,
+											agentIds: Array.from(agentIds),
+										})
+										.then(() => {})
+										.catch((ex) => c.var.logger.error(ex));
+								}
+							})
+							.finally(() => {
+								span.end();
+							});
+					} else {
+						span.setStatus({ code: SpanStatusCode.OK });
+						if (shouldSendSession && canSendSessionEvents) {
+							sessionEventProvider
+								.complete({
+									id: sessionId,
+									statusCode: c.res.status,
+									agentIds: Array.from(agentIds),
+								})
+								.then(() => {})
+								.catch((ex) => c.var.logger.error(ex));
+						}
+					}
 				} catch (ex) {
 					if (ex instanceof Error) {
 						span.recordException(ex);
@@ -312,10 +530,34 @@ const otelMiddleware = createMiddleware<Env>(async (c, next) => {
 						code: SpanStatusCode.ERROR,
 						message,
 					});
-					c.var.logger.error('ERROR: %s', message);
+					c.var.logger.error(message);
+					if (shouldSendSession && canSendSessionEvents) {
+						sessionEventProvider
+							.complete({
+								id: sessionId,
+								statusCode: c.res.status,
+								error: message,
+								agentIds: Array.from(agentIds),
+							})
+							.then(() => {})
+							.catch((ex) => c.var.logger.error(ex));
+					}
 					throw ex;
 				} finally {
-					span.end();
+					// add otel headers into HTTP response
+					const headers: Record<string, string> = {};
+					propagation.inject(context.active(), headers);
+					for (const key of Object.keys(headers)) {
+						c.header(key, headers[key]);
+					}
+					if (!hasPendingWaits) {
+						try {
+							await sessionProvider.save(session);
+							await threadProvider.save(thread);
+						} finally {
+							span.end();
+						}
+					}
 				}
 			}
 		);