@agentuity/cli 0.0.103 → 0.0.105

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agentuity/cli",
-	"version": "0.0.103",
+	"version": "0.0.105",
 	"license": "Apache-2.0",
 	"author": "Agentuity employees and contributors",
 	"type": "module",
@@ -40,8 +40,8 @@
 		"prepublishOnly": "bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@agentuity/core": "0.0.103",
-		"@agentuity/server": "0.0.103",
+		"@agentuity/core": "0.0.105",
+		"@agentuity/server": "0.0.105",
 		"@datasert/cronjs-parser": "^1.4.0",
 		"@terascope/fetch-github-release": "^2.2.1",
 		"@vitejs/plugin-react": "^5.1.2",
@@ -61,7 +61,7 @@
 		"zod": "^4.1.12"
 	},
 	"devDependencies": {
-		"@agentuity/test-utils": "0.0.103",
+		"@agentuity/test-utils": "0.0.105",
 		"@types/adm-zip": "^0.5.7",
 		"@types/bun": "latest",
 		"@types/tar-fs": "^2.0.4",

package/src/cmd/ai/prompt/api.md

@@ -311,40 +311,45 @@ return c.json({ data: 'value' }, 200, {
 ## Streaming Routes
 
 ```typescript
-import { createRouter } from '@agentuity/runtime';
+import { createRouter, stream, sse, websocket } from '@agentuity/runtime';
 
 const router = createRouter();
 
-// Stream response
-router.stream('/events', (c) => {
-	return new ReadableStream({
-		start(controller) {
-			controller.enqueue('event 1\n');
-			controller.enqueue('event 2\n');
-			controller.close();
-		},
-	});
-});
+// Stream response (use with POST)
+router.post(
+	'/events',
+	stream((c) => {
+		return new ReadableStream({
+			start(controller) {
+				controller.enqueue('event 1\n');
+				controller.enqueue('event 2\n');
+				controller.close();
+			},
+		});
+	})
+);
 
-// Server-Sent Events
-router.sse('/notifications', (c) => {
-	return (stream) => {
+// Server-Sent Events (use with GET)
+router.get(
+	'/notifications',
+	sse((c, stream) => {
 		stream.writeSSE({ data: 'Hello', event: 'message' });
 		stream.writeSSE({ data: 'World', event: 'message' });
-	};
-});
+	})
+);
 
-// WebSocket
-router.websocket('/ws', (c) => {
-	return (ws) => {
+// WebSocket (use with GET)
+router.get(
+	'/ws',
+	websocket((c, ws) => {
 		ws.onOpen(() => {
 			ws.send('Connected!');
 		});
 		ws.onMessage((event) => {
 			ws.send(`Echo: ${event.data}`);
 		});
-	};
-});
+	})
+);
 
 export default router;
 ```

package/src/cmd/ai/prompt/version.ts

@@ -8,7 +8,7 @@
  * This allows detecting if the source template has changed.
  */
 
-const HASH_REGEX = /\n?<!-- prompt_hash: ([a-f0-9]+) -->$/;
+const HASH_REGEX = /\n?<!-- prompt_hash: ([a-f0-9]+) -->\n?$/;
 
 /**
  * Compute SHA256 hash of content using Bun's built-in hasher.
@@ -37,10 +37,11 @@ export function extractHash(content: string): string | null {
 
 /**
  * Generate content with hash comment appended.
+ * Ensures the output ends with a newline for POSIX compliance and Prettier compatibility.
  */
 export function appendHashComment(content: string): string {
 	const hash = computeHash(content);
-	return `${content}\n<!-- prompt_hash: ${hash} -->`;
+	return `${content}\n<!-- prompt_hash: ${hash} -->\n`;
 }
 
 /**

package/src/cmd/build/ast.ts

@@ -1315,6 +1315,52 @@ export async function parseRoute(
 							case 'delete': {
 								if (action && (action as ASTLiteral).type === 'Literal') {
 									suffix = String((action as ASTLiteral).value);
+
+									// Check if any argument is a middleware function call (websocket, sse, stream, cron)
+									// New pattern: router.get('/ws', websocket((c, ws) => { ... }))
+									for (const arg of statement.expression.arguments) {
+										if ((arg as ASTCallExpression).type === 'CallExpression') {
+											const callExpr = arg as ASTCallExpression;
+											// Only handle simple Identifier callees (e.g., websocket(), sse())
+											// Skip MemberExpression callees (e.g., obj.method())
+											if (callExpr.callee.type !== 'Identifier') {
+												continue;
+											}
+											const calleeName = (callExpr.callee as ASTNodeIdentifier).name;
+											if (
+												calleeName === 'websocket' ||
+												calleeName === 'sse' ||
+												calleeName === 'stream'
+											) {
+												type = calleeName;
+												break;
+											}
+											if (calleeName === 'cron') {
+												type = 'cron';
+												// First argument to cron() is the schedule expression
+												if (callExpr.arguments && callExpr.arguments.length > 0) {
+													const cronArg = callExpr.arguments[0] as ASTLiteral;
+													if (cronArg.type === 'Literal') {
+														const expression = String(cronArg.value);
+														try {
+															parseCronExpression(expression, {
+																hasSeconds: false,
+															});
+														} catch (ex) {
+															throw new InvalidRouterConfigError({
+																filename,
+																cause: ex,
+																line: body.loc?.start?.line,
+																message: `invalid cron expression "${expression}" in ${filename} at line ${body.loc?.start?.line}`,
+															});
+														}
+														config = { expression };
+													}
+												}
+												break;
+											}
+										}
+									}
 								} else {
 									throw new InvalidRouterConfigError({
 										filename,
@@ -1327,6 +1373,8 @@ export async function parseRoute(
 							case 'stream':
 							case 'sse':
 							case 'websocket': {
+								// DEPRECATED: router.stream(), router.sse(), router.websocket()
+								// These methods now throw errors at runtime
 								type = method;
 								method = 'post';
 								const theaction = action as ASTLiteral;
@@ -1336,39 +1384,9 @@ export async function parseRoute(
 								}
 								break;
 							}
-							case 'sms': {
-								type = method;
-								method = 'post';
-								const theaction = action as ASTObjectExpression;
-								if (theaction.type === 'ObjectExpression') {
-									config = {};
-									theaction.properties.forEach((p) => {
-										if (p.value.type === 'Literal') {
-											const literal = p.value as ASTLiteral;
-											config![p.key.name] = literal.value;
-										}
-									});
-									const number = theaction.properties.find((p) => p.key.name === 'number');
-									if (number && number.value.type === 'Literal') {
-										const phoneNumber = number.value as ASTLiteral;
-										suffix = hash(String(phoneNumber.value));
-										break;
-									}
-								}
-								break;
-							}
-							case 'email': {
-								type = method;
-								method = 'post';
-								const theaction = action as ASTLiteral;
-								if (theaction.type === 'Literal') {
-									const email = String(theaction.value);
-									suffix = hash(email);
-									break;
-								}
-								break;
-							}
 							case 'cron': {
+								// DEPRECATED: router.cron()
+								// This method now throws errors at runtime
 								type = method;
 								method = 'post';
 								const theaction = action as ASTLiteral;
@@ -1437,8 +1455,8 @@ export async function parseRoute(
 							}
 						}
 
-						// For WebSocket/SSE routes that don't use validator(), fall back to exported schemas
-						if (!routeConfig.hasValidator && (type === 'websocket' || type === 'sse')) {
+						// For WebSocket/SSE/stream routes that don't use validator(), fall back to exported schemas
+						if (!routeConfig.hasValidator && (type === 'websocket' || type === 'sse' || type === 'stream')) {
 							if (!routeConfig.inputSchemaVariable && exportedInputSchemaName) {
 								routeConfig.inputSchemaVariable = exportedInputSchemaName;
 							}

package/src/cmd/build/entry-generator.ts

@@ -131,10 +131,10 @@ app.route('/', workbenchRouter);
 `
 		: '';
 
-	// Asset proxy routes - generated for dev mode, reads VITE_PORT from env at runtime
-	const assetProxyRoutes =
-		mode === 'dev'
-			? `
+	// Asset proxy routes - Always generated, but only active at runtime when:
+	//   - NODE_ENV !== 'production' (isDevelopment())
+	//   - and process.env.VITE_PORT is set
+	const assetProxyRoutes = `
 // Asset proxy routes - Development mode only (proxies to Vite asset server)
 if (isDevelopment() && process.env.VITE_PORT) {
 	const VITE_ASSET_PORT = parseInt(process.env.VITE_PORT, 10);
@@ -193,8 +193,7 @@ if (isDevelopment() && process.env.VITE_PORT) {
 	app.get('/*.tsx', proxyToVite);
 	app.get('/*.css', proxyToVite);
 }
-`
-			: '';
+`;
 
 	// Runtime mode detection helper (defined at top level for reuse)
 	// Dynamic property access prevents Bun.build from inlining NODE_ENV at build time
@@ -330,13 +329,18 @@ if (isDevelopment()) {
 if (typeof Bun !== 'undefined') {
 	// Enable process exit protection now that we're starting the server
 	enableProcessExitProtection();
-	
+
 	const port = parseInt(process.env.PORT || '3500', 10);
 	const server = Bun.serve({
-		fetch: app.fetch,
+		fetch: (req, server) => {
+			// Get timeout from config on each request (0 = no timeout)
+			server.timeout(req, getAppConfig()?.requestTimeout ?? 0);
+			return app.fetch(req, server);
+		},
 		websocket,
 		port,
 		hostname: '127.0.0.1',
+		development: isDevelopment(),
 	});
 	
 	// Make server available globally for health checks
@@ -428,16 +432,6 @@ if (isDevelopment()) {
 const serverUrl = \`http://127.0.0.1:\${process.env.PORT || '3500'}\`;
 const otel = register({ processors: [], logLevel: (process.env.AGENTUITY_LOG_LEVEL || 'info') as LogLevel });
 
-// Get app state and config for use below
-const appState = getAppState();
-const appConfig = getAppConfig();
-
-createServices(otel.logger, appConfig, serverUrl);
-
-// Make logger and tracer globally available for user's app.ts
-setGlobalLogger(otel.logger);
-setGlobalTracer(otel.tracer);
-
 // Step 2: Create router and set as global
 const app = createRouter();
 setGlobalRouter(app);
@@ -466,6 +460,15 @@ app.use('/api/*', createAgentMiddleware(''));
 await import('../../app.js');
 
 // Step 5: Initialize providers
+const appState = getAppState();
+const appConfig = getAppConfig();
+
+createServices(otel.logger, appConfig, serverUrl);
+
+// Make logger and tracer globally available for user's app.ts
+setGlobalLogger(otel.logger);
+setGlobalTracer(otel.tracer);
+
 const threadProvider = getThreadProvider();
 const sessionProvider = getSessionProvider();
 

package/src/cmd/build/vite/agent-discovery.ts

@@ -397,13 +397,15 @@ function extractEvalsFromSource(
 
 			if (isCreateEvalCall) {
 				const callExpr = n as unknown as ASTCallExpression;
+				let evalName: string | undefined;
+				let description: string | undefined;
+
 				if (callExpr.arguments.length >= 2) {
+					// Format: agent.createEval('name', { config })
 					const nameArg = callExpr.arguments[0] as ASTLiteral;
-					const evalName = String(nameArg.value);
+					evalName = String(nameArg.value);
 
 					const callargexp = callExpr.arguments[1] as ASTObjectExpression;
-					let description: string | undefined;
-
 					if (callargexp.properties) {
 						for (const prop of callargexp.properties) {
 							if (prop.key.name === 'metadata' && prop.value.type === 'ObjectExpression') {
@@ -415,7 +417,47 @@ function extractEvalsFromSource(
 							}
 						}
 					}
+				} else if (callExpr.arguments.length === 1) {
+					// Format: agent.createEval(presetEval({ name: '...', ... }))
+					// or: agent.createEval(presetEval()) - uses preset's default name
+					// or: agent.createEval({ name: '...', ... })
+					const arg = callExpr.arguments[0] as ASTNode;
+
+					// Handle CallExpression: presetEval({ name: '...' }) or presetEval()
+					if (arg.type === 'CallExpression') {
+						const innerCall = arg as unknown as ASTCallExpression;
+
+						// Try to get name from the call arguments first
+						if (innerCall.arguments.length >= 1) {
+							const configArg = innerCall.arguments[0] as ASTObjectExpression;
+							if (configArg.type === 'ObjectExpression' && configArg.properties) {
+								const configMap = parseObjectExpressionToMap(configArg);
+								evalName = configMap.get('name');
+								description = configMap.get('description');
+							}
+						}
+
+						// Fallback: use the callee name as the eval name (e.g., politeness())
+						if (!evalName && innerCall.callee) {
+							const callee = innerCall.callee as ASTNode;
+							if (callee.type === 'Identifier') {
+								evalName = (callee as ASTNodeIdentifier).name;
+							}
+						}
+					}
+
+					// Handle ObjectExpression: { name: '...', handler: ... }
+					if (arg.type === 'ObjectExpression') {
+						const configArg = arg as ASTObjectExpression;
+						if (configArg.properties) {
+							const configMap = parseObjectExpressionToMap(configArg);
+							evalName = configMap.get('name');
+							description = configMap.get('description');
+						}
+					}
+				}
 
+				if (evalName) {
 					const id = getEvalId(projectId, deploymentId, filename, evalName, version);
 					const evalId = generateStableEvalId(projectId, agentId, evalName);
 

package/src/cmd/build/vite/server-bundler.ts

@@ -95,7 +95,7 @@ export async function installExternalsAndBuild(options: ServerBundleOptions): Pr
 				}
 			}
 		} catch (error) {
-			logger.info('Failed to load agentuity.config.ts for externals:', error);
+			logger.debug('Failed to load agentuity.config.ts for externals:', error);
 		}
 	}
 

package/src/cmd/build/vite/vite-asset-server.ts

@@ -49,11 +49,63 @@ export async function startViteAssetServer(
 	// Create Vite server with config
 	const server = await createServer(config);
 
-	// Start listening - Vite will choose alternate port if preferred is taken
-	await server.listen();
+	// Start listening with timeout to prevent hangs
+	// Vite will choose alternate port if preferred is taken
+	const STARTUP_TIMEOUT_MS = 30000; // 30 seconds
 
-	// Get the actual port Vite is using (may differ from preferred if port was taken)
-	const actualPort = server.config.server.port || preferredPort;
+	try {
+		await Promise.race([
+			server.listen(),
+			new Promise<never>((_, reject) => {
+				const timeoutId = setTimeout(() => {
+					reject(
+						new Error(
+							`Vite asset server failed to start within ${STARTUP_TIMEOUT_MS / 1000}s`
+						)
+					);
+				}, STARTUP_TIMEOUT_MS);
+				// Clean up timeout when listen succeeds (via finally in the outer try)
+				server.httpServer?.once('listening', () => clearTimeout(timeoutId));
+			}),
+		]);
+	} catch (error) {
+		// Attempt to close the server on failure
+		try {
+			await server.close();
+		} catch {
+			// Ignore close errors
+		}
+		throw error;
+	}
+
+	// Helper to get port from httpServer
+	const getPortFromHttpServer = (): number | null => {
+		const httpServer = server.httpServer;
+		if (httpServer) {
+			const address = httpServer.address();
+			if (address && typeof address === 'object' && 'port' in address) {
+				return address.port;
+			}
+		}
+		return null;
+	};
+
+	// Get the actual port Vite is using from the httpServer
+	// server.config.server.port is the requested port, not the actual one
+	let actualPort = preferredPort;
+
+	// The resolved URL contains the actual port being used
+	const resolvedUrls = server.resolvedUrls;
+	if (resolvedUrls?.local && resolvedUrls.local.length > 0) {
+		try {
+			const url = new URL(resolvedUrls.local[0]);
+			actualPort = parseInt(url.port, 10) || preferredPort;
+		} catch {
+			actualPort = getPortFromHttpServer() ?? preferredPort;
+		}
+	} else {
+		actualPort = getPortFromHttpServer() ?? preferredPort;
+	}
 
 	logger.debug(`✅ Vite asset server started on port ${actualPort}`);
 	if (actualPort !== preferredPort) {

package/src/cmd/build/vite/vite-builder.ts

@@ -240,6 +240,10 @@ interface BuildResult {
 export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Promise<BuildResult> {
 	const { rootDir, projectId = '', dev = false, logger } = options;
 
+	if (!dev) {
+		rmSync(join(rootDir, '.agentuity'), { force: true, recursive: true });
+	}
+
 	const result: BuildResult = {
 		workbench: { included: false, duration: 0 },
 		client: { included: false, duration: 0 },
@@ -250,7 +254,6 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 	const { loadAgentuityConfig, getWorkbenchConfig } = await import('./config-loader');
 	const config = await loadAgentuityConfig(rootDir, logger);
 	const workbenchConfig = getWorkbenchConfig(config, dev);
-
 	// Generate workbench files BEFORE any builds if enabled (dev mode only)
 	if (workbenchConfig.enabled) {
 		logger.debug('Workbench enabled (dev mode), generating files before build...');