@agentuity/runtime 0.0.101 → 0.0.103

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,14 +15,78 @@ import type {
 import type { Email } from './io/email';
 import type { ThreadProvider, SessionProvider, Session, Thread } from './session';
 import type WaitUntilHandler from './_waituntil';
+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
 	 */

package/src/eval.ts

@@ -1,34 +1,40 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type { StandardSchemaV1, InferInput, InferOutput } from '@agentuity/core';
 import type { AgentContext } from './agent';
+import { z } from 'zod';
 
 // Eval SDK types
 export type EvalContext = AgentContext<any, any, any>;
 
 export type EvalRunResultMetadata = {
-	reason: string;
 	// biome-ignore lint/suspicious/noExplicitAny: metadata can contain any type of data
 	[key: string]: any;
 };
 
-export type EvalRunResultBinary = {
-	success: true;
-	passed: boolean;
-	metadata: EvalRunResultMetadata;
-};
+export const EvalHandlerResultSchema = z.object({
+	passed: z.boolean(),
+	score: z.number().min(0).max(1).optional(),
+	metadata: z.record(z.string(), z.any()),
+});
 
-export type EvalRunResultScore = {
-	success: true;
-	score: number; // 0-1 range
-	metadata: EvalRunResultMetadata;
-};
+export type EvalHandlerResult = z.infer<typeof EvalHandlerResultSchema>;
+
+// Internal types for catalyst (include success field)
+export const EvalRunResultSuccessSchema = z.object({
+	success: z.literal(true),
+	passed: z.boolean(),
+	score: z.number().min(0).max(1).optional(),
+	metadata: z.record(z.string(), z.any()),
+});
+
+export type EvalRunResultSuccess = z.infer<typeof EvalRunResultSuccessSchema>;
 
 export type EvalRunResultError = {
 	success: false;
 	error: string;
 };
 
-export type EvalRunResult = EvalRunResultBinary | EvalRunResultScore | EvalRunResultError;
+export type EvalRunResult = EvalRunResultSuccess | EvalRunResultError;
 
 export type CreateEvalRunRequest = {
 	projectId: string;
@@ -80,11 +86,11 @@ type InferSchemaOutput<T> = T extends StandardSchemaV1 ? InferOutput<T> : any;
 
 export type EvalFunction<TInput = any, TOutput = any> = [TInput] extends [undefined]
 	? [TOutput] extends [undefined]
-		? (ctx: EvalContext) => Promise<EvalRunResult>
-		: (ctx: EvalContext, output: TOutput) => Promise<EvalRunResult>
+		? (ctx: EvalContext) => Promise<EvalHandlerResult>
+		: (ctx: EvalContext, output: TOutput) => Promise<EvalHandlerResult>
 	: [TOutput] extends [undefined]
-		? (ctx: EvalContext, input: TInput) => Promise<EvalRunResult>
-		: (ctx: EvalContext, input: TInput, output: TOutput) => Promise<EvalRunResult>;
+		? (ctx: EvalContext, input: TInput) => Promise<EvalHandlerResult>
+		: (ctx: EvalContext, input: TInput, output: TOutput) => Promise<EvalHandlerResult>;
 
 /**
  * The Eval handler interface.

package/src/index.ts

@@ -28,6 +28,7 @@ export {
 // app.ts exports (all app-related functionality)
 export {
 	type AppConfig,
+	type CompressionConfig,
 	type Variables,
 	type TriggerType,
 	type PrivateVariables,
@@ -43,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';
@@ -63,8 +69,8 @@ export { type HonoEnv, type WebSocketConnection, createRouter } from './router';
 export {
 	type EvalContext,
 	type EvalRunResultMetadata,
-	type EvalRunResultBinary,
-	type EvalRunResultScore,
+	type EvalHandlerResult,
+	type EvalRunResultSuccess,
 	type EvalRunResultError,
 	type EvalRunResult,
 	type CreateEvalRunRequest,

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';
@@ -124,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);
 	});
 }
 
@@ -321,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/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);
+	}
 }