@agentuity/runtime 1.0.48 → 2.0.0-beta.0

package/src/index.ts

@@ -29,6 +29,8 @@ export {
 // app.ts exports (all app-related functionality)
 export {
 	type AppConfig,
+	type AnalyticsOptions,
+	type WorkbenchOptions,
 	type CompressionConfig,
 	type CorsConfig,
 	type Variables,
@@ -40,9 +42,6 @@ export {
 	type ShutdownHook,
 	createApp,
 	getApp,
-	getAppState,
-	getAppConfig,
-	getUserRouter,
 	runShutdown,
 	registerShutdownHook,
 	fireEvent,

package/src/middleware.ts

@@ -10,7 +10,7 @@ import { setSignedCookie } from 'hono/cookie';
 import type { Env, CompressionConfig, CorsConfig } from './app';
 import { createTrustedCorsOrigin } from './cors';
 import type { Logger } from './logger';
-import { getAppConfig } from './app';
+
 import { generateId } from './session';
 import { runInHTTPContext } from './_context';
 import { DURATION_HEADER, TOKENS_HEADER } from './_tokens';
@@ -111,10 +111,6 @@ export function createBaseMiddleware(config: MiddlewareConfig) {
 
 		// Import services dynamically to avoid circular deps
 		const { getServices } = await import('./_services');
-		const { getAppState } = await import('./app');
-
-		c.set('app', getAppState());
-
 		const services = getServices();
 		c.set('kv', services.kv);
 		c.set('stream', services.stream);
@@ -201,13 +197,7 @@ export function createBaseMiddleware(config: MiddlewareConfig) {
 export function createCorsMiddleware(staticOptions?: CorsConfig) {
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	return createMiddleware<Env<any>>(async (c, next) => {
-		// Lazy resolve: merge app config with static options
-		const appConfig = getAppConfig();
-		const appCors = appConfig?.cors;
-		const corsOptions = {
-			...appCors,
-			...staticOptions,
-		};
+		const corsOptions = { ...staticOptions };
 
 		// Extract Agentuity-specific options
 		const { sameOrigin, allowedOrigins, ...honoCorsOptions } = corsOptions;
@@ -689,18 +679,27 @@ export function createOtelMiddleware() {
 								}
 							});
 						} else if (wsDone) {
-							// WebSocket connection — defer finalization until onClose fires
+							// WebSocket upgrade — end the span immediately (short-lived upgrade span)
+							// Per OTel conventions, spans should be short-lived. The HTTP upgrade
+							// request is a discrete event that completes in milliseconds. Keeping
+							// a span open for the entire WS connection lifetime (minutes/hours) is
+							// non-standard and causes issues with OTel backends.
 							internal.info(
-								'[request] %s %s - websocket response, deferring finalization until close (session: %s)',
+								'[request] %s %s - websocket upgrade, ending span immediately (session: %s)',
 								method,
 								url.pathname,
 								sessionId
 							);
 
-							// For WebSocket, we end the span inside waitUntil after the connection closes
-							shouldEndSpanInFinally = false;
+							// End the upgrade span now with the upgrade duration
+							const upgradeDurationNs = Math.round(handlerDurationMs * 1_000_000);
+							span.setAttribute('@agentuity/request.duration', upgradeDurationNs);
+							span.setAttribute('http.status_code', responseStatus);
+							span.setStatus({ code: SpanStatusCode.OK });
+							span.end();
+							shouldEndSpanInFinally = false; // already ended
 
-							// Capture pending promises BEFORE adding finalization waitUntil to avoid deadlock
+							// Session finalization still defers until WS close, but without holding a span
 							const pendingPromises = handler.getPendingSnapshot();
 							const hasPendingTasks = pendingPromises.length > 0;
 
@@ -714,11 +713,6 @@ export function createOtelMiddleware() {
 								);
 							}
 
-							// Capture values needed for span attributes
-							const capturedResponseStatus = responseStatus;
-							const capturedErrorMessage = errorMessage;
-
-							// Use waitUntil to handle WebSocket close and finalization
 							handler.waitUntil(async () => {
 								let wsError: unknown = undefined;
 
@@ -741,81 +735,43 @@ export function createOtelMiddleware() {
 									);
 								}
 
-								// Record duration now that WebSocket is closed
-								const wsDurationMs = performance.now() - requestStartTime;
-								const durationNs = Math.round(wsDurationMs * 1_000_000);
-								internal.info(
-									'[request] %s %s - recording websocket duration: %sms (session: %s)',
-									method,
-									url.pathname,
-									wsDurationMs.toFixed(2),
-									sessionId
-								);
-
-								// Determine final status
-								const finalStatus = wsError ? 500 : capturedResponseStatus;
+								const finalStatus = wsError ? 500 : responseStatus;
 								const finalErrorMessage = wsError
 									? wsError instanceof Error
 										? (wsError.stack ?? wsError.message)
 										: String(wsError)
-									: capturedErrorMessage;
+									: errorMessage;
 
-								try {
-									// Wait for pending tasks captured BEFORE this waitUntil was added
-									if (hasPendingTasks) {
-										internal.info(
-											'[request] %s %s - waiting for %d pending waitUntil tasks (session: %s)',
-											method,
-											url.pathname,
-											pendingPromises.length,
-											sessionId
-										);
-										const logger = c.get('logger');
-										await handler.waitForPromises(pendingPromises, logger, sessionId);
-										internal.info(
-											'[request] %s %s - all waitUntil tasks complete (session: %s)',
-											method,
-											url.pathname,
-											sessionId
-										);
-									}
-
-									// Finalize session after WebSocket closes
-									await finalizeSession(
-										finalStatus >= 500 ? finalStatus : undefined,
-										finalErrorMessage
-									);
+								// Wait for pending tasks captured BEFORE this waitUntil was added
+								if (hasPendingTasks) {
 									internal.info(
-										'[request] %s %s - websocket session finalization complete (session: %s)',
+										'[request] %s %s - waiting for %d pending waitUntil tasks (session: %s)',
 										method,
 										url.pathname,
+										pendingPromises.length,
 										sessionId
 									);
-								} finally {
-									// Set span attributes and end span AFTER all work is done
-									span.setAttribute('@agentuity/request.duration', durationNs);
-									span.setAttribute('http.status_code', finalStatus);
-
-									if (wsError) {
-										span.setStatus({
-											code: SpanStatusCode.ERROR,
-											message: finalErrorMessage ?? 'WebSocket ended with error',
-										});
-										if (wsError instanceof Error) {
-											span.recordException(wsError);
-										}
-									} else {
-										span.setStatus({ code: SpanStatusCode.OK });
-									}
-
-									span.end();
+									const logger = c.get('logger');
+									await handler.waitForPromises(pendingPromises, logger, sessionId);
 									internal.info(
-										'[request] %s %s - websocket span ended (session: %s)',
+										'[request] %s %s - all waitUntil tasks complete (session: %s)',
 										method,
 										url.pathname,
 										sessionId
 									);
 								}
+
+								// Finalize session after WebSocket closes
+								await finalizeSession(
+									finalStatus >= 500 ? finalStatus : undefined,
+									finalErrorMessage
+								);
+								internal.info(
+									'[request] %s %s - websocket session finalization complete (session: %s)',
+									method,
+									url.pathname,
+									sessionId
+								);
 							});
 						} else {
 							// Non-streaming: record duration immediately
@@ -1041,30 +997,15 @@ export function createOtelMiddleware() {
  * });
  * ```
  */
-export function createCompressionMiddleware(
-	staticConfig?: CompressionConfig,
-	/**
-	 * Optional config resolver for testing. When provided, this is used instead of getAppConfig().
-	 * @internal
-	 */
-	configResolver?: () => { compression?: CompressionConfig | false } | undefined
-) {
+export function createCompressionMiddleware(staticConfig?: CompressionConfig | false) {
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	return createMiddleware<Env<any>>(async (c, next) => {
-		// Lazy resolve: merge app config with static config
-		const appConfig = configResolver ? configResolver() : getAppConfig();
-		const appCompressionConfig = appConfig?.compression;
-
 		// Check if compression is explicitly disabled
-		if (appCompressionConfig === false || staticConfig?.enabled === false) {
+		if (staticConfig === false || staticConfig?.enabled === false) {
 			return next();
 		}
 
-		// Merge configs: static config takes precedence over app config
-		const config: CompressionConfig = {
-			...(typeof appCompressionConfig === 'object' ? appCompressionConfig : {}),
-			...staticConfig,
-		};
+		const config: CompressionConfig = { ...staticConfig };
 
 		const { enabled = true, threshold = 1024, filter, honoOptions } = config;
 

package/src/otel/logger.ts

@@ -4,20 +4,17 @@ import * as LogsAPI from '@opentelemetry/api-logs';
 import type { Logger } from '../logger';
 import ConsoleLogger from '../logger/console';
 
+import { originalConsole as originalConsoleGlobal } from '../_globals';
+
 /**
  * Reference to the original console object before patching.
- * We use a global symbol to ensure we only capture the original console once,
- * preventing double-patching on hot reload.
+ * Stored in a Symbol.for() global to survive hot reloads.
  */
-const ORIGINAL_CONSOLE_KEY = Symbol.for('agentuity.originalConsole');
-
-// Check if we've already saved the original console (prevents double-patching on reload)
-const existingOriginal = (globalThis as Record<symbol, Console>)[ORIGINAL_CONSOLE_KEY];
+const existingOriginal = originalConsoleGlobal.get();
 export const __originalConsole: Console = existingOriginal ?? Object.create(console);
 
-// Save to global if not already saved
 if (!existingOriginal) {
-	(globalThis as Record<symbol, Console>)[ORIGINAL_CONSOLE_KEY] = __originalConsole;
+	originalConsoleGlobal.set(__originalConsole);
 }
 
 export class OtelLogger implements Logger {

package/src/otel/otel.ts

@@ -158,13 +158,23 @@ export const createUserLoggerProvider = ({
 	};
 };
 
+import { otel as otelGlobal } from '../_globals';
+
 /**
- * Registers and initializes OpenTelemetry with the specified configuration
+ * Registers and initializes OpenTelemetry with the specified configuration.
+ *
+ * Idempotent: if called again (e.g. during bun --hot reload), the previous
+ * instance is shut down before creating a new one.
  *
  * @param config - The configuration for OpenTelemetry
  * @returns An object containing the tracer, logger, and shutdown function
  */
 export function registerOtel(config: OtelConfig): OtelResponse {
+	// Shut down previous instance if this is a hot reload
+	const previous = otelGlobal.get();
+	if (previous) {
+		previous.shutdown().catch(() => {});
+	}
 	const {
 		url,
 		name,
@@ -338,5 +348,7 @@ export function registerOtel(config: OtelConfig): OtelResponse {
 		logger.info('connected to Agentuity Agent Cloud');
 	}
 
-	return { tracer, meter, logger, shutdown };
+	const instance: OtelResponse = { tracer, meter, logger, shutdown };
+	otelGlobal.set(instance);
+	return instance;
 }

package/src/router.ts

@@ -1,7 +1,5 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { type Context, Hono, type Env as HonoEnv, type Schema } from 'hono';
-import { loadBuildMetadata } from './_metadata';
-import { returnResponse } from './_util';
+import { Hono, type Env as HonoEnv, type Schema } from 'hono';
+import type { BlankSchema } from 'hono/types';
 import type { Env } from './app';
 
 // Re-export both Env types
@@ -14,7 +12,6 @@ export type { WebSocketConnection } from './handlers/websocket';
 // Module augmentation to extend Hono types for Agentuity runtime
 declare module 'hono' {
 	// Extend Context with waitUntil for route handlers
-	// Note: executionCtx is already provided by Hono's Context class
 	interface Context {
 		/**
 		 * Schedule a background task that runs after the response is sent.
@@ -32,63 +29,20 @@ declare module 'hono' {
 		 */
 		waitUntil(callback: Promise<void> | (() => void | Promise<void>)): void;
 	}
-
-	// Deprecated router methods (stubs that throw errors with migration instructions)
-	interface Hono {
-		/**
-		 * @deprecated Use the `websocket` middleware instead:
-		 * ```typescript
-		 * import { websocket } from '@agentuity/runtime';
-		 * router.get('/ws', websocket((c, ws) => { ... }));
-		 * ```
-		 */
-		websocket(path: string, ...args: any[]): this;
-
-		/**
-		 * @deprecated Use the `sse` middleware instead:
-		 * ```typescript
-		 * import { sse } from '@agentuity/runtime';
-		 * router.get('/events', sse((c, stream) => { ... }));
-		 * ```
-		 */
-		sse(path: string, ...args: any[]): this;
-
-		/**
-		 * @deprecated Use the `stream` middleware instead:
-		 * ```typescript
-		 * import { stream } from '@agentuity/runtime';
-		 * router.post('/data', stream((c) => new ReadableStream({ ... })));
-		 * ```
-		 */
-		stream(path: string, ...args: any[]): this;
-
-		/**
-		 * @deprecated Use the `cron` middleware instead:
-		 * ```typescript
-		 * import { cron } from '@agentuity/runtime';
-		 * router.post('/job', cron('0 0 * * *', (c) => { ... }));
-		 * ```
-		 */
-		cron(schedule: string, ...args: any[]): this;
-	}
 }
 
 /**
- * Creates a Hono router with extended methods for Agentuity-specific routing patterns.
- *
- * Standard HTTP methods (get, post, put, delete, patch) are available, plus middleware
- * functions for specialized protocols:
+ * Creates a Hono router for use with Agentuity.
  *
- * - **websocket()** - WebSocket connections (import { websocket } from '@agentuity/runtime')
- * - **sse()** - Server-Sent Events (import { sse } from '@agentuity/runtime')
- * - **stream()** - Streaming responses (import { stream } from '@agentuity/runtime')
- * - **cron()** - Scheduled tasks (import { cron } from '@agentuity/runtime')
- * - **webrtc()** - WebRTC signaling (import { webrtc } from '@agentuity/runtime')
+ * This is a thin wrapper around `new Hono()` that provides the correct
+ * Agentuity environment types. Hono's full type inference chain is
+ * preserved — the Schema type parameter accumulates route definitions
+ * as you chain `.get()`, `.post()`, etc.
  *
- * @template E - Environment type (Hono Env)
+ * @template E - Environment type (defaults to Agentuity's Env)
  * @template S - Schema type for route definitions
  *
- * @returns Extended Hono router
+ * @returns Hono router instance
  *
  * @example
  * ```typescript
@@ -96,7 +50,7 @@ declare module 'hono' {
  *
  * const router = createRouter();
  *
- * // Standard HTTP routes
+ * // Standard HTTP routes — full type inference
  * router.get('/hello', (c) => c.text('Hello!'));
  * router.post('/data', async (c) => {
  *   const body = await c.req.json();
@@ -114,166 +68,8 @@ declare module 'hono' {
  * router.get('/events', sse((c, stream) => {
  *   stream.writeSSE({ data: 'Hello', event: 'message' });
  * }));
- *
- * // Streaming response
- * router.post('/stream', stream((c) => {
- *   return new ReadableStream({
- *     start(controller) {
- *       controller.enqueue('data\n');
- *       controller.close();
- *     }
- *   });
- * }));
- *
- * // Cron job
- * router.post('/daily', cron('0 0 * * *', (c) => {
- *   return { status: 'complete' };
- * }));
  * ```
  */
-export const createRouter = <E extends Env = Env, S extends Schema = Schema>(): Hono<E, S> => {
-	const router = new Hono<E, S>();
-	// tslint:disable-next-line:no-any no-unused-variable
-	const _router = router as any;
-
-	for (const method of ['get', 'put', 'post', 'delete', 'options', 'patch']) {
-		const _originalInvoker = _router[method].bind(router);
-		_router[method] = (path: string, ...args: any[]) => {
-			// Pass through to original Hono - it handles all the complex type inference
-			// We'll only wrap the final handler to add our response handling
-			if (args.length === 0) {
-				return _originalInvoker(path);
-			}
-
-			// Find the last function in args - that's the handler (everything else is middleware)
-			let handlerIndex = args.length - 1;
-			while (handlerIndex >= 0 && typeof args[handlerIndex] !== 'function') {
-				handlerIndex--;
-			}
-
-			if (handlerIndex < 0) {
-				// No handler found, pass through as-is
-				return _originalInvoker(path, ...args);
-			}
-
-			const handler = args[handlerIndex];
-
-			// Check if this is middleware (2 params: c, next) vs handler (1 param: c)
-			if (handler.length === 2) {
-				// This is middleware-only, pass through
-				return _originalInvoker(path, ...args);
-			}
-
-			// Wrap the handler to add our response conversion and set routeId
-			const wrapper = async (c: Context): Promise<Response> => {
-				// Look up the route ID from build metadata by matching method and path
-				// Try both the registered path and the actual request path (which may include base path)
-				const metadata = loadBuildMetadata();
-				const methodUpper = method.toUpperCase();
-				const requestPath = c.req.routePath || c.req.path;
-
-				// Try matching by registered path first, then by request path, then by path ending
-				let route = metadata?.routes?.find(
-					(r) => r.method.toUpperCase() === methodUpper && r.path === path
-				);
-				if (!route) {
-					route = metadata?.routes?.find(
-						(r) => r.method.toUpperCase() === methodUpper && r.path === requestPath
-					);
-				}
-				if (!route) {
-					// Try matching by path ending (handles /api/translate matching /translate)
-					route = metadata?.routes?.find(
-						(r) => r.method.toUpperCase() === methodUpper && r.path.endsWith(path)
-					);
-				}
-
-				if (route?.id) {
-					(c as any).set('routeId', route.id);
-				}
-
-				let result = handler(c);
-				if (result instanceof Promise) result = await result;
-				// If handler returns a Response, return it unchanged
-				if (result instanceof Response) return result;
-				return returnResponse(c, result);
-			};
-
-			// Replace the handler with our wrapper
-			const newArgs = [...args];
-			newArgs[handlerIndex] = wrapper;
-
-			return _originalInvoker(path, ...newArgs);
-		};
-	}
-
-	// Deprecated stubs that throw errors with migration instructions
-	_router.websocket = (path: string, ..._args: any[]) => {
-		throw new Error(
-			'router.websocket() is deprecated and has been removed.\n\n' +
-				'Migration: Use the websocket middleware instead:\n\n' +
-				`  import { createRouter, websocket } from '@agentuity/runtime';\n\n` +
-				'  const router = createRouter();\n\n' +
-				'  // Before (deprecated):\n' +
-				`  // router.websocket('${path}', (c) => (ws) => { ... });\n\n` +
-				'  // After:\n' +
-				`  router.get('${path}', websocket((c, ws) => {\n` +
-				'    ws.onMessage((event) => {\n' +
-				`      ws.send('Echo: ' + event.data);\n` +
-				'    });\n' +
-				'  }));'
-		);
-	};
-
-	_router.sse = (path: string, ..._args: any[]) => {
-		throw new Error(
-			'router.sse() is deprecated and has been removed.\n\n' +
-				'Migration: Use the sse middleware instead:\n\n' +
-				`  import { createRouter, sse } from '@agentuity/runtime';\n\n` +
-				'  const router = createRouter();\n\n' +
-				'  // Before (deprecated):\n' +
-				`  // router.sse('${path}', (c) => async (stream) => { ... });\n\n` +
-				'  // After:\n' +
-				`  router.get('${path}', sse((c, stream) => {\n` +
-				`    stream.writeSSE({ data: 'Hello', event: 'message' });\n` +
-				'  }));'
-		);
-	};
-
-	_router.stream = (path: string, ..._args: any[]) => {
-		throw new Error(
-			'router.stream() is deprecated and has been removed.\n\n' +
-				'Migration: Use the stream middleware instead:\n\n' +
-				`  import { createRouter, stream } from '@agentuity/runtime';\n\n` +
-				'  const router = createRouter();\n\n' +
-				'  // Before (deprecated):\n' +
-				`  // router.stream('${path}', (c) => new ReadableStream({ ... }));\n\n` +
-				'  // After:\n' +
-				`  router.post('${path}', stream((c) => {\n` +
-				'    return new ReadableStream({\n' +
-				'      start(controller) {\n' +
-				`        controller.enqueue('data\\n');\n` +
-				'        controller.close();\n' +
-				'      }\n' +
-				'    });\n' +
-				'  }));'
-		);
-	};
-
-	_router.cron = (schedule: string, ..._args: any[]) => {
-		throw new Error(
-			'router.cron() is deprecated and has been removed.\n\n' +
-				'Migration: Use the cron middleware instead:\n\n' +
-				`  import { createRouter, cron } from '@agentuity/runtime';\n\n` +
-				'  const router = createRouter();\n\n' +
-				'  // Before (deprecated):\n' +
-				`  // router.cron('${schedule}', (c) => { ... });\n\n` +
-				'  // After:\n' +
-				`  router.post('/your-cron-path', cron('${schedule}', (c) => {\n` +
-				`    return { status: 'complete' };\n` +
-				'  }));'
-		);
-	};
-
-	return router;
+export const createRouter = <E extends Env = Env, S extends Schema = BlankSchema>(): Hono<E, S> => {
+	return new Hono<E, S>();
 };