@agentuity/runtime 0.0.100 → 0.0.102

package/src/app.ts

@@ -1,6 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { type Env as HonoEnv } from 'hono';
 import type { cors } from 'hono/cors';
+import type { compress } from 'hono/compress';
 import type { Logger } from './logger';
 import type { Meter, Tracer } from '@opentelemetry/api';
 import type {
@@ -14,19 +15,78 @@ import type {
 import type { Email } from './io/email';
 import type { ThreadProvider, SessionProvider, Session, Thread } from './session';
 import type WaitUntilHandler from './_waituntil';
-
-// TODO: This should be imported from workbench package, but causes circular dependency
-export interface WorkbenchInstance {
-	config: { route?: string; headers?: Record<string, string> };
-}
+import type { Context } from 'hono';
 
 type CorsOptions = Parameters<typeof cors>[0];
+type HonoCompressOptions = Parameters<typeof compress>[0];
+
+/**
+ * Configuration options for response compression middleware.
+ *
+ * @example
+ * ```typescript
+ * const app = await createApp({
+ *   compression: {
+ *     enabled: true,
+ *     threshold: 1024,
+ *   }
+ * });
+ * ```
+ */
+export interface CompressionConfig {
+	/**
+	 * Enable or disable compression globally.
+	 * @default true
+	 */
+	enabled?: boolean;
+
+	/**
+	 * Minimum response body size in bytes before compression is attempted.
+	 * Responses smaller than this threshold will not be compressed.
+	 * @default 1024
+	 */
+	threshold?: number;
+
+	/**
+	 * Optional filter function to skip compression for specific requests.
+	 * Return false to skip compression for the request.
+	 *
+	 * @example
+	 * ```typescript
+	 * filter: (c) => !c.req.path.startsWith('/internal')
+	 * ```
+	 */
+	filter?: (c: Context) => boolean;
+
+	/**
+	 * Raw options passed through to Hono's compress middleware.
+	 * These are merged with Agentuity's defaults.
+	 */
+	honoOptions?: HonoCompressOptions;
+}
 
 export interface AppConfig<TAppState = Record<string, never>> {
 	/**
 	 * Override the default cors settings
 	 */
 	cors?: CorsOptions;
+	/**
+	 * Configure response compression.
+	 * Set to `false` to disable compression entirely.
+	 *
+	 * @example
+	 * ```typescript
+	 * const app = await createApp({
+	 *   compression: {
+	 *     threshold: 2048,
+	 *   }
+	 * });
+	 *
+	 * // Or disable compression:
+	 * const app = await createApp({ compression: false });
+	 * ```
+	 */
+	compression?: CompressionConfig | false;
 	/**
 	 * Override the default services
 	 */
@@ -63,10 +123,6 @@ export interface AppConfig<TAppState = Record<string, never>> {
 		 * the EvalRunEventProvider to override instead of the default
 		 */
 		evalRunEvent?: EvalRunEventProvider;
-		/**
-		 * the Workbench to override instead of the default
-		 */
-		workbench?: WorkbenchInstance;
 	};
 	/**
 	 * Optional setup function called before server starts

package/src/devmode.ts

@@ -78,12 +78,23 @@ const overlay = `
 </style>
 `;
 
+// Global controller to avoid registering multiple SIGINT listeners
+let globalController: AbortController | undefined;
+let globalSigintHandler: (() => void) | undefined;
+
 export function registerDevModeRoutes(router: Hono) {
-	const controller = new AbortController();
-	const signal = controller.signal;
-	process.on('SIGINT', () => {
-		controller.abort();
-	});
+	// Reuse existing controller or create new one
+	if (!globalController) {
+		globalController = new AbortController();
+
+		// Only register SIGINT handler once
+		globalSigintHandler = () => {
+			globalController?.abort();
+		};
+		process.on('SIGINT', globalSigintHandler);
+	}
+
+	const signal = globalController.signal;
 	router.get('/__dev__/reload', () => {
 		const stream = new ReadableStream({
 			start(controller): void {

package/src/index.ts

@@ -27,8 +27,8 @@ export {
 
 // app.ts exports (all app-related functionality)
 export {
-	type WorkbenchInstance,
 	type AppConfig,
+	type CompressionConfig,
 	type Variables,
 	type TriggerType,
 	type PrivateVariables,
@@ -44,7 +44,12 @@ export {
 export { addEventListener, removeEventListener } from './_events';
 
 // middleware.ts exports (Vite-native)
-export { createBaseMiddleware, createCorsMiddleware, createOtelMiddleware } from './middleware';
+export {
+	createBaseMiddleware,
+	createCorsMiddleware,
+	createOtelMiddleware,
+	createCompressionMiddleware,
+} from './middleware';
 
 // Internal exports needed by generated entry files
 export { register } from './otel/config';
@@ -193,3 +198,8 @@ export type { RouteSchema, GetRouteSchema } from './_validation';
  */
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 export interface AppState {}
+
+// Re-export bootstrapRuntimeEnv from @agentuity/server for convenience
+// This allows generated code to import from @agentuity/runtime instead of having
+// a direct dependency on @agentuity/server
+export { bootstrapRuntimeEnv, type RuntimeBootstrapOptions } from '@agentuity/server';

package/src/middleware.ts

@@ -5,8 +5,10 @@
 
 import { createMiddleware } from 'hono/factory';
 import { cors } from 'hono/cors';
-import type { Env } from './app';
+import { compress } from 'hono/compress';
+import type { Env, CompressionConfig } from './app';
 import type { Logger } from './logger';
+import { getAppConfig } from './app';
 import { generateId } from './session';
 import { runInHTTPContext } from './_context';
 import { DURATION_HEADER, TOKENS_HEADER } from './_tokens';
@@ -22,6 +24,8 @@ import {
 } from '@opentelemetry/api';
 import { TraceState } from '@opentelemetry/core';
 import * as runtimeConfig from './_config';
+import { getSessionEventProvider } from './_services';
+import { internal } from './logger/internal';
 
 const SESSION_HEADER = 'x-session-id';
 const THREAD_HEADER = 'x-thread-id';
@@ -74,7 +78,8 @@ export interface MiddlewareConfig {
  * Create base middleware that sets up context variables
  */
 export function createBaseMiddleware(config: MiddlewareConfig) {
-	return createMiddleware<Env>(async (c, next) => {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	return createMiddleware<Env<any>>(async (c, next) => {
 		c.set('logger', config.logger);
 		c.set('tracer', config.tracer);
 		c.set('meter', config.meter);
@@ -121,31 +126,77 @@ export function createBaseMiddleware(config: MiddlewareConfig) {
 }
 
 /**
- * Create CORS middleware
+ * Create CORS middleware with lazy config resolution.
+ *
+ * Handles Cross-Origin Resource Sharing (CORS) headers for API routes.
+ * Config is resolved at request time, allowing it to be set via createApp().
+ * Static options passed here take precedence over app config.
+ *
+ * Default behavior:
+ * - Reflects the request origin (allows any origin)
+ * - Allows common headers: Content-Type, Authorization, Accept, Origin, X-Requested-With
+ * - Allows all standard HTTP methods
+ * - Enables credentials
+ * - Sets max-age to 600 seconds (10 minutes)
+ *
+ * @param staticOptions - Optional static CORS options that override app config
+ *
+ * @example
+ * ```typescript
+ * // Use with default settings
+ * app.use('/api/*', createCorsMiddleware());
+ *
+ * // Or configure via createApp
+ * const app = await createApp({
+ *   cors: {
+ *     origin: 'https://example.com',
+ *     allowHeaders: ['Content-Type', 'Authorization', 'X-Custom-Header'],
+ *     maxAge: 3600,
+ *   }
+ * });
+ *
+ * // Or pass static options directly (overrides app config)
+ * app.use('/api/*', createCorsMiddleware({
+ *   origin: ['https://app.example.com', 'https://admin.example.com'],
+ *   credentials: true,
+ * }));
+ * ```
  */
-export function createCorsMiddleware(corsOptions?: Parameters<typeof cors>[0]) {
-	return cors({
-		origin: corsOptions?.origin ?? ((origin) => origin),
-		allowHeaders: corsOptions?.allowHeaders ?? [
-			'Content-Type',
-			'Authorization',
-			'Accept',
-			'Origin',
-			'X-Requested-With',
-			THREAD_HEADER,
-		],
-		allowMethods: ['POST', 'GET', 'OPTIONS', 'HEAD', 'PUT', 'DELETE', 'PATCH'],
-		exposeHeaders: [
-			'Content-Length',
-			TOKENS_HEADER,
-			DURATION_HEADER,
-			THREAD_HEADER,
-			SESSION_HEADER,
-			DEPLOYMENT_HEADER,
-		],
-		maxAge: 600,
-		credentials: true,
-		...(corsOptions ?? {}),
+export function createCorsMiddleware(staticOptions?: Parameters<typeof cors>[0]) {
+	// 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 corsOptions = {
+			...appConfig?.cors,
+			...staticOptions,
+		};
+
+		const corsMiddleware = cors({
+			origin: corsOptions?.origin ?? ((origin: string) => origin),
+			allowHeaders: corsOptions?.allowHeaders ?? [
+				'Content-Type',
+				'Authorization',
+				'Accept',
+				'Origin',
+				'X-Requested-With',
+				THREAD_HEADER,
+			],
+			allowMethods: ['POST', 'GET', 'OPTIONS', 'HEAD', 'PUT', 'DELETE', 'PATCH'],
+			exposeHeaders: [
+				'Content-Length',
+				TOKENS_HEADER,
+				DURATION_HEADER,
+				THREAD_HEADER,
+				SESSION_HEADER,
+				DEPLOYMENT_HEADER,
+			],
+			maxAge: 600,
+			credentials: true,
+			...(corsOptions ?? {}),
+		});
+
+		return corsMiddleware(c, next);
 	});
 }
 
@@ -154,7 +205,8 @@ export function createCorsMiddleware(corsOptions?: Parameters<typeof cors>[0]) {
  * This is the critical middleware that creates AgentContext
  */
 export function createOtelMiddleware() {
-	return createMiddleware<Env>(async (c, next) => {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	return createMiddleware<Env<any>>(async (c, next) => {
 		// Import providers dynamically to avoid circular deps
 		const { getThreadProvider, getSessionProvider } = await import('./_services');
 		const WaitUntilHandler = (await import('./_waituntil')).default;
@@ -188,6 +240,14 @@ export function createOtelMiddleware() {
 					const deploymentId = runtimeConfig.getDeploymentId();
 					const isDevMode = runtimeConfig.isDevMode();
 
+					internal.info(
+						'[session] config: orgId=%s, projectId=%s, deploymentId=%s, isDevMode=%s',
+						orgId ?? 'NOT SET (AGENTUITY_CLOUD_ORG_ID)',
+						projectId ?? 'NOT SET (AGENTUITY_CLOUD_PROJECT_ID)',
+						deploymentId ?? 'none',
+						isDevMode
+					);
+
 					if (projectId) traceState = traceState.set('pid', projectId);
 					if (orgId) traceState = traceState.set('oid', orgId);
 					if (isDevMode) traceState = traceState.set('d', '1');
@@ -211,17 +271,45 @@ export function createOtelMiddleware() {
 					c.set('session', session);
 					// eslint-disable-next-line @typescript-eslint/no-explicit-any
 					(c as any).set('waitUntilHandler', handler);
+					const agentIds = new Set<string>();
 					// eslint-disable-next-line @typescript-eslint/no-explicit-any
-					(c as any).set('agentIds', new Set<string>());
+					(c as any).set('agentIds', agentIds);
 					// eslint-disable-next-line @typescript-eslint/no-explicit-any
 					(c as any).set('trigger', 'api');
 
+					// Send session start event (so evalruns can reference this session)
+					const sessionEventProvider = getSessionEventProvider();
+					const shouldSendSession = !!(orgId && projectId);
+					if (shouldSendSession && sessionEventProvider) {
+						try {
+							// eslint-disable-next-line @typescript-eslint/no-explicit-any
+							const routeId = (c as any).var?.routeId || '';
+							await sessionEventProvider.start({
+								id: sessionId,
+								threadId: thread.id,
+								orgId,
+								projectId,
+								deploymentId: deploymentId || undefined,
+								devmode: isDevMode,
+								trigger: 'api',
+								routeId,
+								environment: runtimeConfig.getEnvironment(),
+								url: c.req.path,
+								method: c.req.method,
+							});
+						} catch (_ex) {
+							// Silently ignore session start errors - don't block request
+						}
+					}
+
 					try {
 						await next();
-
 						// Save session/thread and send events
+						internal.info('[session] saving session %s (thread: %s)', sessionId, thread.id);
 						await sessionProvider.save(session);
+						internal.info('[session] session saved, now saving thread');
 						await threadProvider.save(thread);
+						internal.info('[session] thread saved');
 						span.setStatus({ code: SpanStatusCode.OK });
 					} catch (ex) {
 						if (ex instanceof Error) {
@@ -233,6 +321,37 @@ export function createOtelMiddleware() {
 						});
 						throw ex;
 					} finally {
+						// Send session complete event
+						internal.info(
+							'[session] shouldSendSession: %s, hasSessionEventProvider: %s',
+							shouldSendSession,
+							!!sessionEventProvider
+						);
+						if (shouldSendSession && sessionEventProvider) {
+							try {
+								const userData = session.serializeUserData();
+								internal.info(
+									'[session] sending session complete event, userData: %s',
+									userData ? `${userData.length} bytes` : 'none'
+								);
+								// eslint-disable-next-line @typescript-eslint/no-explicit-any
+								const agentIdsSet = (c as any).get('agentIds') as Set<string> | undefined;
+								const agentIds = agentIdsSet ? [...agentIdsSet].filter(Boolean) : undefined;
+								internal.info('[session] agentIds: %o', agentIds);
+								await sessionEventProvider.complete({
+									id: sessionId,
+									threadId: thread.empty() ? null : thread.id,
+									statusCode: c.res?.status ?? 200,
+									agentIds: agentIds?.length ? agentIds : undefined,
+									userData,
+								});
+								internal.info('[session] session complete event sent');
+							} catch (ex) {
+								internal.info('[session] session complete event failed: %s', ex);
+								// Silently ignore session complete errors - don't block response
+							}
+						}
+
 						const headers: Record<string, string> = {};
 						propagation.inject(context.active(), headers);
 						for (const key of Object.keys(headers)) {
@@ -250,3 +369,76 @@ export function createOtelMiddleware() {
 		});
 	});
 }
+
+/**
+ * Create compression middleware with lazy config resolution.
+ *
+ * Compresses response bodies using gzip or deflate based on the Accept-Encoding header.
+ * Config is resolved at request time, allowing it to be set via createApp().
+ *
+ * @param staticConfig - Optional static config that overrides app config
+ *
+ * @example
+ * ```typescript
+ * // Use with default settings
+ * app.use('*', createCompressionMiddleware());
+ *
+ * // Or configure via createApp
+ * const app = await createApp({
+ *   compression: {
+ *     threshold: 2048,
+ *   }
+ * });
+ * ```
+ */
+export function createCompressionMiddleware(staticConfig?: CompressionConfig) {
+	// 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 = getAppConfig();
+		const appCompressionConfig = appConfig?.compression;
+
+		// Check if compression is explicitly disabled
+		if (appCompressionConfig === false || staticConfig?.enabled === false) {
+			return next();
+		}
+
+		// Merge configs: static config takes precedence over app config
+		const config: CompressionConfig = {
+			...(typeof appCompressionConfig === 'object' ? appCompressionConfig : {}),
+			...staticConfig,
+		};
+
+		const { enabled = true, threshold = 1024, filter, honoOptions } = config;
+
+		// Skip if explicitly disabled
+		if (!enabled) {
+			return next();
+		}
+
+		// Skip WebSocket upgrade requests
+		const upgrade = c.req.header('upgrade');
+		if (upgrade && upgrade.toLowerCase() === 'websocket') {
+			return next();
+		}
+
+		// Skip if no Accept-Encoding header
+		const acceptEncoding = c.req.header('accept-encoding');
+		if (!acceptEncoding) {
+			return next();
+		}
+
+		// Check custom filter
+		if (filter && !filter(c)) {
+			return next();
+		}
+
+		// Create and run the Hono compress middleware
+		const compressMiddleware = compress({
+			threshold,
+			...honoOptions,
+		});
+
+		await compressMiddleware(c, next);
+	});
+}

package/src/services/evalrun/http.ts

@@ -13,6 +13,7 @@ import {
 	type Logger,
 	StructuredError,
 } from '@agentuity/core';
+import { internal } from '../../logger/internal';
 
 const EvalRunResponseError = StructuredError('EvalRunResponseError');
 
@@ -38,12 +39,22 @@ export class HTTPEvalRunEventProvider implements EvalRunEventProvider {
 	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));
+
+		// Log full payload using internal logger
+		internal.info('[EVALRUN HTTP] ========== START PAYLOAD ==========');
+		internal.info('[EVALRUN HTTP] id: %s', payload.id);
+		internal.info('[EVALRUN HTTP] evalId: %s', payload.evalId);
+		internal.info('[EVALRUN HTTP] evalIdentifier: %s', payload.evalIdentifier);
+		internal.info('[EVALRUN HTTP] sessionId: %s', payload.sessionId);
+		internal.info('[EVALRUN HTTP] orgId: %s', payload.orgId);
+		internal.info('[EVALRUN HTTP] projectId: %s', payload.projectId);
+		internal.info('[EVALRUN HTTP] devmode: %s', payload.devmode);
+		internal.info('[EVALRUN HTTP] deploymentId: %s', payload.deploymentId);
+		internal.info('[EVALRUN HTTP] spanId: %s', payload.spanId);
+		internal.info('[EVALRUN HTTP] URL: POST %s', fullUrl);
+		internal.info('[EVALRUN HTTP] ============================================');
 
 		try {
 			const resp = await this.apiClient.post(

package/src/services/local/vector.ts

@@ -8,6 +8,8 @@ import type {
 	VectorSearchResultWithDocument,
 	VectorSearchParams,
 	VectorSearchResult,
+	VectorNamespaceStats,
+	VectorNamespaceStatsWithSamples,
 } from '@agentuity/core';
 import { randomUUID } from 'node:crypto';
 import { simpleEmbedding, cosineSimilarity, now } from './_util';
@@ -271,4 +273,162 @@ export class LocalVectorStorage implements VectorStorage {
 		const { count } = query.get(this.#projectPath, name) as { count: number };
 		return count > 0;
 	}
+
+	async getStats(name: string): Promise<VectorNamespaceStatsWithSamples> {
+		if (!name?.trim()) {
+			throw new Error('Vector storage name is required');
+		}
+
+		const countQuery = this.#db.query(`
+			SELECT COUNT(*) as count,
+			MIN(created_at) as created_at, MAX(updated_at) as last_used
+			FROM vector_storage 
+			WHERE project_path = ? AND name = ?
+		`);
+
+		const stats = countQuery.get(this.#projectPath, name) as {
+			count: number;
+			created_at: number | null;
+			last_used: number | null;
+		};
+
+		if (stats.count === 0) {
+			return { sum: 0, count: 0 };
+		}
+
+		const sampleQuery = this.#db.query(`
+			SELECT key, embedding, document, metadata, created_at, updated_at
+			FROM vector_storage 
+			WHERE project_path = ? AND name = ?
+			LIMIT 20
+		`);
+
+		const samples = sampleQuery.all(this.#projectPath, name) as Array<{
+			key: string;
+			embedding: string;
+			document: string | null;
+			metadata: string | null;
+			created_at: number;
+			updated_at: number;
+		}>;
+
+		const encoder = new TextEncoder();
+		let totalSum = 0;
+		const sampledResults: VectorNamespaceStatsWithSamples['sampledResults'] = {};
+		for (const sample of samples) {
+			const embeddingBytes = encoder.encode(sample.embedding).length;
+			const documentBytes = sample.document ? encoder.encode(sample.document).length : 0;
+			const size = embeddingBytes + documentBytes;
+			totalSum += size;
+			sampledResults![sample.key] = {
+				embedding: JSON.parse(sample.embedding),
+				document: sample.document || undefined,
+				size,
+				metadata: sample.metadata ? JSON.parse(sample.metadata) : undefined,
+				firstUsed: sample.created_at,
+				lastUsed: sample.updated_at,
+			};
+		}
+
+		// Estimate total size based on sampled average if we have more records than samples
+		const estimatedSum =
+			stats.count <= samples.length
+				? totalSum
+				: Math.round((totalSum / samples.length) * stats.count);
+
+		return {
+			sum: estimatedSum,
+			count: stats.count,
+			createdAt: stats.created_at || undefined,
+			lastUsed: stats.last_used || undefined,
+			sampledResults,
+		};
+	}
+
+	async getAllStats(): Promise<Record<string, VectorNamespaceStats>> {
+		const query = this.#db.query(`
+			SELECT name, embedding, document
+			FROM vector_storage 
+			WHERE project_path = ?
+		`);
+
+		const rows = query.all(this.#projectPath) as Array<{
+			name: string;
+			embedding: string;
+			document: string | null;
+		}>;
+
+		const encoder = new TextEncoder();
+		const namespaceStats = new Map<
+			string,
+			{ sum: number; count: number; createdAt?: number; lastUsed?: number }
+		>();
+
+		for (const row of rows) {
+			const embeddingBytes = encoder.encode(row.embedding).length;
+			const documentBytes = row.document ? encoder.encode(row.document).length : 0;
+			const size = embeddingBytes + documentBytes;
+
+			const existing = namespaceStats.get(row.name);
+			if (existing) {
+				existing.sum += size;
+				existing.count += 1;
+			} else {
+				namespaceStats.set(row.name, { sum: size, count: 1 });
+			}
+		}
+
+		// Get timestamps in a separate query
+		const timestampQuery = this.#db.query(`
+			SELECT name, MIN(created_at) as created_at, MAX(updated_at) as last_used
+			FROM vector_storage 
+			WHERE project_path = ?
+			GROUP BY name
+		`);
+
+		const timestamps = timestampQuery.all(this.#projectPath) as Array<{
+			name: string;
+			created_at: number | null;
+			last_used: number | null;
+		}>;
+
+		for (const ts of timestamps) {
+			const stats = namespaceStats.get(ts.name);
+			if (stats) {
+				stats.createdAt = ts.created_at || undefined;
+				stats.lastUsed = ts.last_used || undefined;
+			}
+		}
+
+		const results: Record<string, VectorNamespaceStats> = {};
+		for (const [name, stats] of namespaceStats) {
+			results[name] = stats;
+		}
+
+		return results;
+	}
+
+	async getNamespaces(): Promise<string[]> {
+		const query = this.#db.query(`
+			SELECT DISTINCT name 
+			FROM vector_storage 
+			WHERE project_path = ?
+		`);
+
+		const rows = query.all(this.#projectPath) as Array<{ name: string }>;
+		return rows.map((row) => row.name);
+	}
+
+	async deleteNamespace(name: string): Promise<void> {
+		if (!name?.trim()) {
+			throw new Error('Vector storage name is required');
+		}
+
+		const stmt = this.#db.prepare(`
+			DELETE FROM vector_storage 
+			WHERE project_path = ? AND name = ?
+		`);
+
+		stmt.run(this.#projectPath, name);
+	}
 }