@agentuity/runtime 0.0.43 → 0.0.45

package/src/otel/otel.ts

@@ -28,7 +28,9 @@ import type { Logger } from '../logger';
 import { ConsoleLogRecordExporter } from './console';
 import { instrumentFetch } from './fetch';
 import { createLogger, patchConsole } from './logger';
-import { getSDKVersion } from '../_config';
+import { getSDKVersion, isAuthenticated } from '../_config';
+import type { LogLevel } from '@agentuity/core';
+import { JSONLLogExporter, JSONLTraceExporter, JSONLMetricExporter } from './exporters';
 
 /**
  * Configuration for OpenTelemetry initialization
@@ -45,6 +47,8 @@ export interface OtelConfig {
 	cliVersion?: string;
 	devmode?: boolean;
 	spanProcessors?: Array<SpanProcessor>;
+	logLevel?: LogLevel;
+	jsonlBasePath?: string;
 }
 
 /**
@@ -83,24 +87,33 @@ export const createAgentuityLoggerProvider = ({
 	url,
 	headers,
 	resource,
+	logLevel,
+	jsonlBasePath,
 }: {
 	url?: string;
 	headers?: Record<string, string>;
 	resource: Resource;
+	logLevel: LogLevel;
+	jsonlBasePath?: string;
 }) => {
 	let processor: LogRecordProcessor;
-	let exporter: OTLPLogExporter | undefined;
+	let exporter: OTLPLogExporter | JSONLLogExporter | undefined;
 
-	if (url) {
-		exporter = new OTLPLogExporter({
+	if (jsonlBasePath) {
+		exporter = new JSONLLogExporter(jsonlBasePath);
+		processor = new BatchLogRecordProcessor(exporter);
+	} else if (url) {
+		// Original OTLP export behavior
+		const otlpExporter = new OTLPLogExporter({
 			url: `${url}/v1/logs`,
 			headers,
 			compression: CompressionAlgorithm.GZIP,
 			timeoutMillis: 10_000,
 		});
-		processor = new BatchLogRecordProcessor(exporter);
+		exporter = otlpExporter;
+		processor = new BatchLogRecordProcessor(otlpExporter);
 	} else {
-		processor = new SimpleLogRecordProcessor(new ConsoleLogRecordExporter());
+		processor = new SimpleLogRecordProcessor(new ConsoleLogRecordExporter(logLevel));
 	}
 	const provider = new LoggerProvider({
 		resource,
@@ -159,6 +172,8 @@ export function registerOtel(config: OtelConfig): OtelResponse {
 		projectId,
 		deploymentId,
 		devmode = false,
+		logLevel = 'warn',
+		jsonlBasePath = undefined,
 	} = config;
 
 	let headers: Record<string, string> | undefined;
@@ -173,6 +188,8 @@ export function registerOtel(config: OtelConfig): OtelResponse {
 		url,
 		headers,
 		resource,
+		logLevel,
+		jsonlBasePath,
 	});
 	const attrs = {
 		'@agentuity/orgId': orgId ?? 'unknown',
@@ -182,25 +199,29 @@ export function registerOtel(config: OtelConfig): OtelResponse {
 		'@agentuity/devmode': devmode,
 		'@agentuity/language': 'javascript',
 	};
-	const logger = createLogger(!!url, attrs);
+	const logger = createLogger(!!url, attrs, logLevel);
 
 	// must do this after we have created the logger
-	patchConsole(!!url, attrs);
+	patchConsole(!!url, attrs, logLevel);
 
 	const traceExporter = url
-		? new OTLPTraceExporter({
-				url: `${url}/v1/traces`,
-				headers,
-				keepAlive: true,
-			})
+		? jsonlBasePath
+			? new JSONLTraceExporter(jsonlBasePath)
+			: new OTLPTraceExporter({
+					url: `${url}/v1/traces`,
+					headers,
+					keepAlive: true,
+				})
 		: undefined;
 
 	const metricExporter = url
-		? new OTLPMetricExporter({
-				url: `${url}/v1/metrics`,
-				headers,
-				keepAlive: true,
-			})
+		? jsonlBasePath
+			? new JSONLMetricExporter(jsonlBasePath)
+			: new OTLPMetricExporter({
+					url: `${url}/v1/metrics`,
+					headers,
+					keepAlive: true,
+				})
 		: undefined;
 
 	// Create a separate metric reader for the NodeSDK
@@ -260,8 +281,8 @@ export function registerOtel(config: OtelConfig): OtelResponse {
 
 		try {
 			const projectName = config.projectId || '';
-			const orgName = config.orgId || '';
-			const appName = `${orgName}:${projectName}`;
+			const orgId = config.orgId || '';
+			const appName = `${orgId}:${projectName}`;
 
 			const traceloopHeaders: Record<string, string> = {};
 			if (bearerToken) {
@@ -278,7 +299,7 @@ export function registerOtel(config: OtelConfig): OtelResponse {
 				// Note: JavaScript SDK doesn't support resourceAttributes like Python
 			});
 			logger.debug(`Telemetry initialized with app_name: ${appName}`);
-			logger.info('Telemetry configured successfully');
+			logger.debug('Telemetry configured successfully');
 		} catch (error) {
 			logger.warn('Telemetry not available, skipping automatic instrumentation', {
 				error: error instanceof Error ? error.message : String(error),
@@ -309,7 +330,7 @@ export function registerOtel(config: OtelConfig): OtelResponse {
 		}
 	};
 
-	if (url) {
+	if (url && isAuthenticated()) {
 		logger.debug('connected to Agentuity Agent Cloud');
 	}
 

package/src/router.ts

@@ -6,11 +6,17 @@ import { upgradeWebSocket as honoUpgradeWebSocket } from 'hono/bun';
 import { hash, returnResponse } from './_util';
 import type { Env } from './app';
 import { getAsyncLocalStorage } from './_context';
+import { parseEmail, type Email } from './io/email';
 
 type AgentHandler<E extends Env = Env, P extends string = string, I extends Input = {}> = (
 	c: Context<E, P, I>
 ) => any | Promise<any>;
 
+type EmailHandler<E extends Env = Env, P extends string = string, I extends Input = {}> = (
+	email: Email,
+	c: Context<E, P, I>
+) => any | Promise<any>;
+
 type StreamHandler<E extends Env = Env, P extends string = string, I extends Input = {}> = (
 	c: Context<E, P, I>
 ) => ReadableStream<any> | Promise<ReadableStream<any>>;
@@ -48,7 +54,12 @@ type ExtendedHono<E extends Env = Env, S extends Schema = {}> = {
 		): Hono<E, S>;
 	};
 } & {
-	email(address: string, handler: AgentHandler): Hono<E, S>;
+	email(address: string, handler: EmailHandler): Hono<E, S>;
+	email<I extends Input = {}>(
+		address: string,
+		middleware: MiddlewareHandler<E, string, I>,
+		handler: EmailHandler<E, string, I>
+	): Hono<E, S>;
 	sms(params: { number: string }, handler: AgentHandler): Hono<E, S>;
 	cron(schedule: string, handler: AgentHandler): Hono<E, S>;
 	stream<P extends string = string>(path: P, handler: StreamHandler<E, P>): Hono<E, S>;
@@ -119,16 +130,45 @@ export const createRouter = <E extends Env = Env, S extends Schema = Schema>():
 	}
 
 	// shim in special routes
-	_router.email = (address: string, handler: AgentHandler) => {
+	_router.email = (address: string, ...args: any[]) => {
+		let middleware: MiddlewareHandler | undefined;
+		let handler: EmailHandler;
+
+		if (args.length === 1) {
+			handler = args[0];
+		} else {
+			middleware = args[0];
+			handler = args[1];
+		}
+
 		const id = hash(address);
 		const path = `/${id}`;
 		// registerEmailHandler(address)
 		const wrapper = async (c: Context): Promise<Response> => {
-			let result = handler(c);
+			const contentType = (c.req.header('content-type') || '').trim().toLowerCase();
+			if (!contentType.includes('message/rfc822')) {
+				return c.text('Bad Request: Content-Type must be message/rfc822', 400);
+			}
+
+			const arrayBuffer = await c.req.arrayBuffer();
+			const buffer = Buffer.from(arrayBuffer);
+
+			const email = await parseEmail(buffer);
+
+			let result = handler(email, c);
 			if (result instanceof Promise) result = await result;
+
+			if (result === undefined) {
+				return c.text('OK', 200);
+			}
 			return returnResponse(c, result);
 		};
-		return router.post(path, wrapper);
+
+		if (middleware) {
+			return router.post(path, middleware, wrapper);
+		} else {
+			return router.post(path, wrapper);
+		}
 	};
 
 	_router.sms = ({ number }: { number: string }, handler: AgentHandler) => {

package/src/services/evalrun/composite.ts

@@ -0,0 +1,34 @@
+import {
+	type EvalRunEventProvider,
+	type EvalRunStartEvent,
+	type EvalRunCompleteEvent,
+} from '@agentuity/core';
+
+/**
+ * An implementation of the EvalRunEventProvider which wraps multiple providers
+ */
+export class CompositeEvalRunEventProvider implements EvalRunEventProvider {
+	private providers: EvalRunEventProvider[];
+
+	constructor(...providers: EvalRunEventProvider[]) {
+		this.providers = providers;
+	}
+
+	/**
+	 * called when the eval run starts
+	 *
+	 * @param event EvalRunStartEvent
+	 */
+	async start(event: EvalRunStartEvent): Promise<void> {
+		await Promise.allSettled(this.providers.map((provider) => provider.start(event)));
+	}
+
+	/**
+	 * called when the eval run completes
+	 *
+	 * @param event EvalRunCompleteEvent
+	 */
+	async complete(event: EvalRunCompleteEvent): Promise<void> {
+		await Promise.allSettled(this.providers.map((provider) => provider.complete(event)));
+	}
+}

package/src/services/evalrun/http.ts

@@ -0,0 +1,112 @@
+import { APIClient, APIResponseSchemaNoData, ValidationError } from '@agentuity/server';
+import {
+	type EvalRunEventProvider,
+	type EvalRunStartEvent,
+	EvalRunStartEventDelayedSchema,
+	EvalRunCompleteEventDelayedSchema,
+	type EvalRunCompleteEvent,
+	type Logger,
+} from '@agentuity/core';
+
+/**
+ * An implementation of the EvalRunEventProvider which uses HTTP for delivery
+ */
+export class HTTPEvalRunEventProvider implements EvalRunEventProvider {
+	private apiClient: APIClient;
+	private logger: Logger;
+	private baseUrl: string;
+
+	constructor(client: APIClient, logger: Logger, baseUrl: string) {
+		this.apiClient = client;
+		this.logger = logger;
+		this.baseUrl = baseUrl;
+	}
+
+	/**
+	 * called when the eval run starts
+	 *
+	 * @param event EvalRunStartEvent
+	 */
+	async start(event: EvalRunStartEvent): Promise<void> {
+		const endpoint = '/evalrun/2025-03-17';
+		const fullUrl = `${this.baseUrl}${endpoint}`;
+		this.logger.debug('[EVALRUN HTTP] Sending eval run start event: %s', event.id);
+		this.logger.debug('[EVALRUN HTTP] URL: %s %s', 'POST', fullUrl);
+		this.logger.debug('[EVALRUN HTTP] Base URL: %s', this.baseUrl);
+
+		const payload = { ...event, timestamp: Date.now() };
+		this.logger.debug('[EVALRUN HTTP] Start event payload: %s', JSON.stringify(payload, null, 2));
+
+		try {
+			const resp = await this.apiClient.request(
+				'POST',
+				endpoint,
+				APIResponseSchemaNoData(),
+				payload,
+				EvalRunStartEventDelayedSchema
+			);
+			if (resp.success) {
+				this.logger.debug('[EVALRUN HTTP] Start event sent successfully: %s', event.id);
+				return;
+			}
+			const errorMsg = resp.message || 'Unknown error';
+			this.logger.error('[EVALRUN HTTP] Start event failed: %s, error: %s', event.id, errorMsg);
+			throw new Error(errorMsg);
+		} catch (error) {
+			this.logger.error(
+				'[EVALRUN HTTP] Start event exception: %s, error: %s',
+				event.id,
+				error instanceof Error ? error.message : String(error)
+			);
+			// Log validation errors if available
+			if (error instanceof ValidationError) {
+				this.logger.error(
+					'[EVALRUN HTTP] Validation issues: %s',
+					JSON.stringify(error.issues, null, 2)
+				);
+			}
+			throw error;
+		}
+	}
+
+	/**
+	 * called when the eval run completes
+	 *
+	 * @param event EvalRunCompleteEvent
+	 */
+	async complete(event: EvalRunCompleteEvent): Promise<void> {
+		const endpoint = '/evalrun/2025-03-17';
+		const fullUrl = `${this.baseUrl}${endpoint}`;
+		this.logger.debug('[EVALRUN HTTP] Sending eval run complete event: %s', event.id);
+		this.logger.debug('[EVALRUN HTTP] URL: %s %s', 'PUT', fullUrl);
+		this.logger.debug('[EVALRUN HTTP] Base URL: %s', this.baseUrl);
+
+		try {
+			const resp = await this.apiClient.request(
+				'PUT',
+				endpoint,
+				APIResponseSchemaNoData(),
+				{ ...event, timestamp: Date.now() },
+				EvalRunCompleteEventDelayedSchema
+			);
+			if (resp.success) {
+				this.logger.debug('[EVALRUN HTTP] Complete event sent successfully: %s', event.id);
+				return;
+			}
+			const errorMsg = resp.message || 'Unknown error';
+			this.logger.error(
+				'[EVALRUN HTTP] Complete event failed: %s, error: %s',
+				event.id,
+				errorMsg
+			);
+			throw new Error(errorMsg);
+		} catch (error) {
+			this.logger.error(
+				'[EVALRUN HTTP] Complete event exception: %s, error: %s',
+				event.id,
+				error instanceof Error ? error.message : String(error)
+			);
+			throw error;
+		}
+	}
+}

package/src/services/evalrun/index.ts

@@ -0,0 +1,4 @@
+export { HTTPEvalRunEventProvider } from './http';
+export { LocalEvalRunEventProvider } from './local';
+export { JSONEvalRunEventProvider } from './json';
+export { CompositeEvalRunEventProvider } from './composite';

package/src/services/evalrun/json.ts

@@ -0,0 +1,46 @@
+import {
+	type EvalRunEventProvider,
+	type EvalRunStartEvent,
+	type EvalRunCompleteEvent,
+} from '@agentuity/core';
+
+/**
+ * An implementation of the EvalRunEventProvider which writes to JSON files
+ */
+export class JSONEvalRunEventProvider implements EvalRunEventProvider {
+	private exportDir: string;
+
+	constructor(exportDir: string) {
+		this.exportDir = exportDir;
+	}
+
+	/**
+	 * called when the eval run starts
+	 *
+	 * @param event EvalRunStartEvent
+	 */
+	async start(event: EvalRunStartEvent): Promise<void> {
+		const data = {
+			type: 'evalrun_start',
+			timestamp: Date.now(),
+			...event,
+		};
+		const filename = `${this.exportDir}/evalrun-${event.id}-start.json`;
+		await Bun.write(filename, JSON.stringify(data, null, 2));
+	}
+
+	/**
+	 * called when the eval run completes
+	 *
+	 * @param event EvalRunCompleteEvent
+	 */
+	async complete(event: EvalRunCompleteEvent): Promise<void> {
+		const data = {
+			type: 'evalrun_complete',
+			timestamp: Date.now(),
+			...event,
+		};
+		const filename = `${this.exportDir}/evalrun-${event.id}-complete.json`;
+		await Bun.write(filename, JSON.stringify(data, null, 2));
+	}
+}

package/src/services/evalrun/local.ts

@@ -0,0 +1,28 @@
+import {
+	type EvalRunEventProvider,
+	type EvalRunStartEvent,
+	type EvalRunCompleteEvent,
+} from '@agentuity/core';
+
+/**
+ * An implementation of the EvalRunEventProvider which just logs locally
+ */
+export class LocalEvalRunEventProvider implements EvalRunEventProvider {
+	/**
+	 * called when the eval run starts
+	 *
+	 * @param event EvalRunStartEvent
+	 */
+	async start(event: EvalRunStartEvent): Promise<void> {
+		console.log('EvalRun started:', event);
+	}
+
+	/**
+	 * called when the eval run completes
+	 *
+	 * @param event EvalRunCompleteEvent
+	 */
+	async complete(event: EvalRunCompleteEvent): Promise<void> {
+		console.log('EvalRun completed:', event);
+	}
+}