@agentuity/runtime 0.0.71 → 0.0.73

package/src/_process-protection.ts

@@ -0,0 +1,66 @@
+/**
+ * Process protection utilities
+ *
+ * Prevents user code from calling process.exit() which would crash the server.
+ * The runtime can still exit gracefully using the internal exit function.
+ */
+
+import { StructuredError } from '@agentuity/core';
+
+// Store the original process.exit
+const originalExit = process.exit.bind(process);
+
+// Flag to track if protection is enabled
+let protectionEnabled = false;
+
+const ProcessExitAttemptError = StructuredError(
+	'ProcessExitAttemptError',
+	'Calling process.exit() is not allowed in agent code. The server must remain running to handle requests.'
+)<{
+	code?: number | string | null | undefined;
+}>();
+
+/**
+ * Enable protection against process.exit calls.
+ * After calling this, user code calling process.exit() will throw an error.
+ */
+export function enableProcessExitProtection(): void {
+	if (protectionEnabled) {
+		return;
+	}
+
+	protectionEnabled = true;
+
+	// Replace process.exit with a function that throws
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	(process as any).exit = function (code?: number | string | null | undefined): never {
+		throw new ProcessExitAttemptError({ code });
+	};
+}
+
+/**
+ * Disable protection (mainly for testing)
+ */
+export function disableProcessExitProtection(): void {
+	if (!protectionEnabled) {
+		return;
+	}
+
+	protectionEnabled = false;
+	process.exit = originalExit;
+}
+
+/**
+ * Internal function for the runtime to call when it needs to exit.
+ * This bypasses the protection and calls the original process.exit.
+ */
+export function internalExit(code?: number): never {
+	return originalExit(code);
+}
+
+/**
+ * Check if protection is currently enabled
+ */
+export function isProtectionEnabled(): boolean {
+	return protectionEnabled;
+}

package/src/_server.ts

@@ -26,8 +26,9 @@ import { register } from './otel/config';
 import type { Logger } from './logger';
 import { isIdle } from './_idle';
 import * as runtimeConfig from './_config';
-import { inAgentContext, runInHTTPContext } from './_context';
+import { runInHTTPContext } from './_context';
 import { runAgentShutdowns, createAgentMiddleware } from './agent';
+import { enableProcessExitProtection, internalExit } from './_process-protection';
 import {
 	createServices,
 	getThreadProvider,
@@ -107,17 +108,6 @@ function registerAgentuitySpanProcessor() {
 				'@agentuity/devmode': devmode,
 				'@agentuity/environment': environment,
 			};
-			if (inAgentContext()) {
-				// eslint-disable-next-line @typescript-eslint/no-require-imports
-				const { getCurrentAgentMetadata } = require('./_context');
-				const current = getCurrentAgentMetadata();
-				if (current) {
-					attrs['@agentuity/agentId'] = current.id;
-					attrs['@agentuity/agentInstanceId'] = current.agentId;
-					attrs['@agentuity/agentDescription'] = current.description;
-					attrs['@agentuity/agentName'] = current.name;
-				}
-			}
 			span.setAttributes(attrs);
 		}
 
@@ -168,6 +158,9 @@ export const createServer = async <TAppState>(
 	const hostname = '127.0.0.1';
 	const serverUrl = `http://${hostname}:${port}`;
 
+	// Enable process.exit protection before any user code can run
+	enableProcessExitProtection();
+
 	// this must come before registering any otel stuff
 	registerAgentuitySpanProcessor();
 	registerTokenProcessor();
@@ -377,7 +370,7 @@ export const createServer = async <TAppState>(
 		// Force exit after timeout if cleanup hangs
 		const forceExitTimer = setTimeout(() => {
 			otel.logger.warn('shutdown timed out after 5s, forcing exit');
-			process.exit(1);
+			internalExit(1);
 		}, 5_000);
 		try {
 			// stop accepting new connections
@@ -424,21 +417,21 @@ export const createServer = async <TAppState>(
 
 	process.once('SIGINT', async () => {
 		await shutdown();
-		process.exit(0);
+		internalExit(0);
 	});
 	process.once('SIGTERM', async () => {
 		await shutdown();
-		process.exit(0);
+		internalExit(0);
 	});
 	process.once('uncaughtException', async (err) => {
 		otel.logger.error('An uncaught exception was received: %s', err);
 		await shutdown();
-		process.exit(1);
+		internalExit(1);
 	});
 	process.once('unhandledRejection', async (reason) => {
 		otel.logger.error('An unhandled promise rejection was received: %s', reason);
 		await shutdown();
-		process.exit(1);
+		internalExit(1);
 	});
 
 	const server = Bun.serve({

package/src/_waituntil.ts

@@ -61,7 +61,8 @@ export default class WaitUntilHandler {
 			} catch (ex: unknown) {
 				span.recordException(ex as Error);
 				span.setStatus({ code: SpanStatusCode.ERROR });
-				throw ex;
+				// Log the error but don't re-throw - background tasks should never crash the server
+				internal.error('Background task error: %s', ex);
 			} finally {
 				span.end();
 			}
@@ -93,8 +94,16 @@ export default class WaitUntilHandler {
 		internal.debug(`⏳ Waiting for ${this.promises.length} promises to complete...`);
 		try {
 			// Promises are already executing, just wait for them to complete
-			await Promise.all(this.promises);
+			// Use allSettled so one failing promise doesn't stop others
+			const results = await Promise.allSettled(this.promises);
 			const duration = Date.now() - (this.started as number);
+
+			// Log any failures
+			const failures = results.filter((r) => r.status === 'rejected');
+			if (failures.length > 0) {
+				logger.error('%d background task(s) failed during execution', failures.length);
+			}
+
 			internal.debug(
 				'✅ All promises completed, marking session completed (duration %dms)',
 				duration

package/src/agent.ts

@@ -7,6 +7,7 @@ import {
 	type VectorStorage,
 	type InferOutput,
 	toCamelCase,
+	EvalRunStartEvent,
 } from '@agentuity/core';
 import { context, SpanStatusCode, type Tracer, trace } from '@opentelemetry/api';
 import type { Context, MiddlewareHandler } from 'hono';
@@ -15,6 +16,8 @@ import { validator } from 'hono/validator';
 import { AGENT_RUNTIME, INTERNAL_AGENT, CURRENT_AGENT } from './_config';
 import {
 	getAgentContext,
+	inHTTPContext,
+	getHTTPContext,
 	setupRequestAgentContext,
 	type RequestAgentContextArgs,
 } from './_context';
@@ -27,7 +30,6 @@ import { privateContext, notifyReady } from './_server';
 import { generateId } from './session';
 import { getEvalRunEventProvider } from './_services';
 import * as runtimeConfig from './_config';
-import type { EvalRunStartEvent } from '@agentuity/core';
 import type { AppState } from './index';
 import { validateSchema, formatValidationIssues } from './_validation';
 
@@ -1198,10 +1200,15 @@ async function fireAgentEvent(
 		const callbacks = listeners.get(eventName);
 		if (callbacks && callbacks.size > 0) {
 			for (const callback of callbacks) {
-				if (eventName === 'errored' && data) {
-					await (callback as any)(eventName, agent, context, data);
-				} else if (eventName === 'started' || eventName === 'completed') {
-					await (callback as any)(eventName, agent, context);
+				try {
+					if (eventName === 'errored' && data) {
+						await (callback as any)(eventName, agent, context, data);
+					} else if (eventName === 'started' || eventName === 'completed') {
+						await (callback as any)(eventName, agent, context);
+					}
+				} catch (error) {
+					// Log but don't re-throw - event listener errors should not crash the server
+					internal.error(`Error in agent event listener for '${eventName}':`, error);
 				}
 			}
 		}
@@ -1516,6 +1523,29 @@ export function createAgent<
 		// Store current agent for telemetry (using Symbol to keep it internal)
 		(agentCtx as any)[CURRENT_AGENT] = agent;
 
+		const attrs = {
+			'@agentuity/agentId': agent.metadata.id,
+			'@agentuity/agentInstanceId': agent.metadata.agentId,
+			'@agentuity/agentDescription': agent.metadata.description,
+			'@agentuity/agentName': agent.metadata.name,
+		};
+
+		// Set agent attributes on the current active span
+		const activeSpan = trace.getActiveSpan();
+		if (activeSpan) {
+			activeSpan.setAttributes(attrs);
+		}
+
+		if (inHTTPContext()) {
+			const honoCtx = privateContext(getHTTPContext());
+			if (honoCtx.var.agentIds) {
+				honoCtx.var.agentIds.add(agent.metadata.id);
+				honoCtx.var.agentIds.add(agent.metadata.agentId);
+			}
+		}
+
+		agentCtx.logger = agentCtx.logger.child(attrs);
+
 		// Get the agent instance from the runtime state to fire events
 		const runtime = getAgentRuntime(agentCtx);
 

package/src/app.ts

@@ -6,6 +6,7 @@ import type { BunWebSocketData } from 'hono/bun';
 import type { Logger } from './logger';
 import { createServer, getLogger } from './_server';
 import type { Meter, Tracer } from '@opentelemetry/api';
+import { internal } from './logger/internal';
 import type {
 	KeyValueStorage,
 	SessionEventProvider,
@@ -279,7 +280,12 @@ export class App<TAppState = Record<string, never>> {
 		if (!callbacks || callbacks.size === 0) return;
 
 		for (const callback of callbacks) {
-			await callback(eventName, ...args);
+			try {
+				await callback(eventName, ...args);
+			} catch (error) {
+				// Log but don't re-throw - event listener errors should not crash the server
+				internal.error(`Error in app event listener for '${eventName}':`, error);
+			}
 		}
 	}
 }

package/src/otel/console.ts

@@ -9,6 +9,11 @@ import { __originalConsole } from './logger';
  * Uses __originalConsole to avoid infinite loop when console is patched
  */
 export class ConsoleLogRecordExporter implements LogRecordExporter {
+	private dumpRecords = false;
+
+	constructor(dumpRecords: boolean) {
+		this.dumpRecords = dumpRecords;
+	}
 	/**
 	 * Exports log records to the console
 	 *
@@ -17,24 +22,35 @@ export class ConsoleLogRecordExporter implements LogRecordExporter {
 	 */
 	export(logs: ReadableLogRecord[], resultCallback: (result: ExportResult) => void): void {
 		for (const log of logs) {
-			const severity = log.severityNumber ? SeverityNumber[log.severityNumber] : 'INFO';
-			const msg = `[${severity}] ${log.body}`;
-			switch (log.severityNumber) {
-				case SeverityNumber.DEBUG:
-					__originalConsole.debug(msg);
-					break;
-				case SeverityNumber.INFO:
-					__originalConsole.info(msg);
-					break;
-				case SeverityNumber.WARN:
-					__originalConsole.warn(msg);
-					break;
-				case SeverityNumber.ERROR:
-					__originalConsole.error(msg);
-					break;
-				default:
-					__originalConsole.log(msg);
-					break;
+			if (this.dumpRecords) {
+				__originalConsole.log('[LOG]', {
+					body: log.body,
+					severityNumber: log.severityNumber,
+					severityText: log.severityText,
+					timestamp: log.hrTime,
+					attributes: log.attributes,
+					resource: log.resource.attributes,
+				});
+			} else {
+				const severity = log.severityNumber ? SeverityNumber[log.severityNumber] : 'INFO';
+				const msg = `[${severity}] ${log.body}`;
+				switch (log.severityNumber) {
+					case SeverityNumber.DEBUG:
+						__originalConsole.debug(msg);
+						break;
+					case SeverityNumber.INFO:
+						__originalConsole.info(msg);
+						break;
+					case SeverityNumber.WARN:
+						__originalConsole.warn(msg);
+						break;
+					case SeverityNumber.ERROR:
+						__originalConsole.error(msg);
+						break;
+					default:
+						__originalConsole.log(msg);
+						break;
+				}
 			}
 		}
 		resultCallback({ code: ExportResultCode.SUCCESS });

package/src/otel/otel.ts

@@ -102,7 +102,7 @@ export const createAgentuityLoggerProvider = ({
 	let exporter: OTLPLogExporter | JSONLLogExporter | undefined;
 
 	if (useConsoleExporters) {
-		processor = new SimpleLogRecordProcessor(new ConsoleLogRecordExporter());
+		processor = new SimpleLogRecordProcessor(new ConsoleLogRecordExporter(true));
 	} else if (jsonlBasePath) {
 		exporter = new JSONLLogExporter(jsonlBasePath);
 		processor = new BatchLogRecordProcessor(exporter);
@@ -117,7 +117,7 @@ export const createAgentuityLoggerProvider = ({
 		exporter = otlpExporter;
 		processor = new BatchLogRecordProcessor(otlpExporter);
 	} else {
-		processor = new SimpleLogRecordProcessor(new ConsoleLogRecordExporter());
+		processor = new SimpleLogRecordProcessor(new ConsoleLogRecordExporter(false));
 	}
 	const provider = new LoggerProvider({
 		resource,
@@ -210,7 +210,10 @@ export function registerOtel(config: OtelConfig): OtelResponse {
 	const logger = createLogger(!!url, attrs, logLevel);
 
 	// must do this after we have created the logger
-	patchConsole(!!url, attrs, logLevel);
+	// don't patch console if we're using console exporters (to avoid double logging)
+	if (!useConsoleExporters) {
+		patchConsole(!!url, attrs, logLevel);
+	}
 
 	// Build trace exporter (OTLP or JSONL)
 	const traceExporter = jsonlBasePath

package/src/services/evalrun/http.ts

@@ -46,11 +46,10 @@ export class HTTPEvalRunEventProvider implements EvalRunEventProvider {
 		this.logger.debug('[EVALRUN HTTP] Start event payload: %s', JSON.stringify(payload, null, 2));
 
 		try {
-			const resp = await this.apiClient.request(
-				'POST',
+			const resp = await this.apiClient.post(
 				endpoint,
-				APIResponseSchemaNoData(),
 				payload,
+				APIResponseSchemaNoData(),
 				EvalRunStartEventDelayedSchema
 			);
 			if (resp.success) {
@@ -93,11 +92,10 @@ export class HTTPEvalRunEventProvider implements EvalRunEventProvider {
 		this.logger.debug('[EVALRUN HTTP] Base URL: %s', this.baseUrl);
 
 		try {
-			const resp = await this.apiClient.request(
-				'PUT',
+			const resp = await this.apiClient.put(
 				endpoint,
-				APIResponseSchemaNoData(),
 				{ ...event, timestamp: Date.now() },
+				APIResponseSchemaNoData(),
 				EvalRunCompleteEventDelayedSchema
 			);
 			if (resp.success) {

package/src/services/local/keyvalue.ts

@@ -83,10 +83,16 @@ export class LocalKeyValueStorage implements KeyValueStorage {
 			buffer = Buffer.from(value);
 		} else if (value instanceof ArrayBuffer) {
 			buffer = Buffer.from(new Uint8Array(value));
-		} else if (typeof value === 'object') {
+		} else if (
+			typeof value === 'number' ||
+			typeof value === 'boolean' ||
+			typeof value === 'object'
+		) {
+			// Use JSON for numbers, booleans, and objects to preserve type on round-trip
 			buffer = Buffer.from(JSON.stringify(value), 'utf-8');
 			contentType = 'application/json';
 		} else {
+			// Fallback for other types
 			buffer = Buffer.from(String(value), 'utf-8');
 		}
 

package/src/services/session/http.ts

@@ -30,11 +30,10 @@ export class HTTPSessionEventProvider implements SessionEventProvider {
 	 */
 	async start(event: SessionStartEvent): Promise<void> {
 		this.logger.debug('Sending session start event: %s', event.id);
-		const resp = await this.apiClient.request(
-			'POST',
+		const resp = await this.apiClient.post(
 			'/session/2025-03-17',
-			APIResponseSchemaNoData(),
 			{ ...event, timestamp: Date.now() },
+			APIResponseSchemaNoData(),
 			SessionStartEventDelayedSchema
 		);
 		if (resp.success) {
@@ -51,11 +50,10 @@ export class HTTPSessionEventProvider implements SessionEventProvider {
 	 */
 	async complete(event: SessionCompleteEvent): Promise<void> {
 		this.logger.debug('Sending session complete event: %s', event.id);
-		const resp = await this.apiClient.request(
-			'PUT',
+		const resp = await this.apiClient.put(
 			'/session/2025-03-17',
-			APIResponseSchemaNoData(),
 			{ ...event, timestamp: Date.now() },
+			APIResponseSchemaNoData(),
 			SessionCompleteEventDelayedSchema
 		);
 		if (resp.success) {

package/src/session.ts

@@ -6,6 +6,7 @@ import { type Env, fireEvent } from './app';
 import type { AppState } from './index';
 import { getServiceUrls } from '@agentuity/server';
 import { WebSocket } from 'ws';
+import { internal } from './logger/internal';
 
 export type ThreadEventName = 'destroyed';
 export type SessionEventName = 'completed';
@@ -418,7 +419,12 @@ async function fireThreadEvent(thread: Thread, eventName: ThreadEventName): Prom
 	if (!callbacks || callbacks.size === 0) return;
 
 	for (const callback of callbacks) {
-		await (callback as any)(eventName, thread);
+		try {
+			await (callback as any)(eventName, thread);
+		} catch (error) {
+			// Log but don't re-throw - event listener errors should not crash the server
+			internal.error(`Error in thread event listener for '${eventName}':`, error);
+		}
 	}
 }
 
@@ -431,7 +437,12 @@ async function fireSessionEvent(session: Session, eventName: SessionEventName):
 	if (!callbacks || callbacks.size === 0) return;
 
 	for (const callback of callbacks) {
-		await (callback as any)(eventName, session);
+		try {
+			await (callback as any)(eventName, session);
+		} catch (error) {
+			// Log but don't re-throw - event listener errors should not crash the server
+			internal.error(`Error in session event listener for '${eventName}':`, error);
+		}
 	}
 }
 
@@ -977,8 +988,12 @@ export class DefaultThreadProvider implements ThreadProvider {
 				if (this.wsClient) {
 					try {
 						await this.wsClient.delete(thread.id);
-					} catch (err) {
-						console.error(`Failed to delete thread ${thread.id} from remote storage:`, err);
+					} catch {
+						// Thread might not exist in remote storage if it was never persisted
+						// This is normal for ephemeral threads, so just log at debug level
+						internal.debug(
+							`Thread ${thread.id} not found in remote storage (already deleted or never persisted)`
+						);
 						// Continue with local cleanup even if remote delete fails
 					}
 				}

package/src/workbench.ts

@@ -1,7 +1,6 @@
-import { z } from 'zod';
 import type { Context, Handler } from 'hono';
-import { s } from '@agentuity/schema';
 import { timingSafeEqual } from 'node:crypto';
+import { toJSONSchema } from '@agentuity/server';
 import { getAgents, createAgentMiddleware } from './agent';
 import { createRouter } from './router';
 import type { WebSocketConnection } from './router';
@@ -135,25 +134,6 @@ export const createWorkbenchRouter = () => {
 	return router;
 };
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const toJSONSchema = (schema: any) => {
-	// Check if it's an Agentuity schema via StandardSchemaV1 vendor
-	if (schema?.['~standard']?.vendor === 'agentuity') {
-		return s.toJSONSchema(schema);
-	}
-	// Check if it's a Zod schema
-	if (schema?._def?.typeName) {
-		try {
-			return z.toJSONSchema(schema);
-		} catch {
-			return {};
-		}
-	}
-	// TODO: this is going to only work for zod schema for now. need a way to handle others
-	// Unknown schema type
-	return {};
-};
-
 export const createWorkbenchMetadataRoute = (): Handler => {
 	const authHeader = process.env.AGENTUITY_WORKBENCH_APIKEY
 		? `Bearer ${process.env.AGENTUITY_WORKBENCH_APIKEY}`