@agentuity/cli 0.0.73 → 0.0.74

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

@@ -26,13 +26,14 @@ Each API folder must contain:
 
 Example structure:
 \`\`\`
-src/web/
+src/api/
+├── index.ts         (optional, mounted at /api)
 ├── status/
-│   └── route.ts
+│   └── route.ts     (mounted at /api/status)
 ├── users/
-│   └── route.ts
+│   └── route.ts     (mounted at /api/users)
 ├── agent-call/
-    └── route.ts
+    └── route.ts     (mounted at /api/agent-call)
 \`\`\`
 
 ## Creating an API

package/src/cmd/auth/ssh/api.ts

@@ -78,10 +78,7 @@ export async function addSSHKey(apiClient: APIClient, publicKey: string): Promis
 const ListSSHKeysError = StructuredError('ListSSHKeysError');
 
 export async function listSSHKeys(apiClient: APIClient): Promise<SSHKey[]> {
-	const resp = await apiClient.get(
-		'/cli/auth/ssh-keys',
-		APIResponseSchema(z.array(SSHKeySchema))
-	);
+	const resp = await apiClient.get('/cli/auth/ssh-keys', APIResponseSchema(z.array(SSHKeySchema)));
 
 	if (!resp.success) {
 		throw new ListSSHKeysError({ message: resp.message });

package/src/cmd/build/ast.ts

@@ -1,5 +1,5 @@
 import * as acornLoose from 'acorn-loose';
-import { basename, dirname, relative } from 'node:path';
+import { dirname, relative } from 'node:path';
 import { parse as parseCronExpression } from '@datasert/cronjs-parser';
 import { generate } from 'astring';
 import type { BuildMetadata } from '../../types';
@@ -910,8 +910,11 @@ export async function parseRoute(
 	projectId: string,
 	deploymentId: string
 ): Promise<BuildMetadata['routes']> {
-	const contents = await Bun.file(filename).text();
-	const version = hash(contents);
+	const rawContents = await Bun.file(filename).text();
+	const version = hash(rawContents);
+	// Transpile TypeScript to JavaScript so acorn-loose can parse it properly
+	const transpiler = new Bun.Transpiler({ loader: 'ts', target: 'bun' });
+	const contents = transpiler.transformSync(rawContents);
 	const ast = acornLoose.parse(contents, {
 		locations: true,
 		ecmaVersion: 'latest',
@@ -992,12 +995,24 @@ export async function parseRoute(
 	}
 
 	const rel = relative(rootDir, filename);
-	const dir = dirname(filename);
-	const name = basename(dir);
 
 	// For src/api/index.ts, we don't want to add the folder name since it's the root API router
 	const isRootApi = filename.includes('src/api/index.ts');
-	const routeName = isRootApi ? '' : name;
+
+	// For nested routes, use the full path from src/api/ instead of just the immediate parent
+	// e.g., src/api/v1/users/route.ts -> routeName = "v1/users"
+	//       src/api/auth/route.ts -> routeName = "auth"
+	//       src/api/test.ts -> routeName = "" (file directly in src/api/)
+	let routeName = '';
+	if (!isRootApi) {
+		const apiMatch = filename.match(/src\/api\/(.+?)\/[^/]+\.ts$/);
+		if (apiMatch) {
+			// File in subdirectory: src/api/auth/route.ts -> "auth"
+			routeName = apiMatch[1];
+		}
+		// For files directly in src/api/ (e.g., test.ts), routeName stays empty
+		// This prevents double /api prefix since these files often define full paths
+	}
 
 	const routes: RouteDefinition = [];
 	const routePrefix = '/api';

package/src/cmd/build/bundler.ts

@@ -4,6 +4,7 @@ import { cpSync, existsSync, mkdirSync, rmSync, readdirSync } from 'node:fs';
 import gitParseUrl from 'git-url-parse';
 import { StructuredError } from '@agentuity/core';
 import * as tui from '../../tui';
+import { pauseStepUI } from '../../steps';
 import AgentuityBundler, { getBuildMetadata } from './plugin';
 import { getFilesRecursively } from './file';
 import { getVersion } from '../../version';
@@ -16,25 +17,38 @@ import { type DeployOptions } from '../../schemas/deploy';
 
 const minBunVersion = '>=1.3.3';
 
-async function checkBunVersion() {
+async function checkBunVersion(): Promise<string[]> {
 	if (semver.satisfies(Bun.version, minBunVersion)) {
-		return;
+		return []; // Version is OK, no output needed
 	}
-	const message = `The current Bun installed is using version ${Bun.version}. This project requires Bun version ${minBunVersion} to build.`;
-	tui.warning(message);
-	if (process.stdin.isTTY) {
-		const ok = await tui.confirm('You would you to upgrade now?');
+
+	const message = `Bun is using version ${Bun.version}. This project requires Bun version ${minBunVersion} to build.`;
+
+	if (process.stdin.isTTY && process.stdout.isTTY) {
+		// Pause the step UI for interactive prompt
+		const resume = pauseStepUI();
+
+		tui.warning(message);
+		const ok = await tui.confirm('Would you like to upgrade now?');
+
+		// Small delay to ensure console.log('') in confirm completes
+		await new Promise((resolve) => setTimeout(resolve, 10));
+
+		resume(); // Resume step UI
+
 		if (ok) {
 			await $`bun upgrade`.quiet();
 			const version = (await $`bun -v`.quiet().text()).trim();
-			tui.success(`Bun upgraded to ${version}`);
-			return;
+			// Return success message to show in output box
+			return [tui.colorSuccess(`Upgraded Bun to ${version}`)];
 		}
 	}
+
+	// Failed to upgrade or user declined
 	throw new InvalidBunVersion({
 		current: Bun.version,
 		required: minBunVersion,
-		message: `Please see https://bun.sh/ for information on how to download the latest version.`,
+		message,
 	});
 }
 
@@ -102,7 +116,9 @@ export async function bundle({
 	env,
 	region,
 	logger,
-}: BundleOptions) {
+}: BundleOptions): Promise<{ output: string[] }> {
+	const output: string[] = [];
+
 	const appFile = join(rootDir, 'app.ts');
 	if (!existsSync(appFile)) {
 		throw new AppFileNotFoundError({
@@ -110,7 +126,8 @@ export async function bundle({
 		});
 	}
 
-	await checkBunVersion();
+	const versionOutput = await checkBunVersion();
+	output.push(...versionOutput);
 
 	const outDir = customOutDir ?? join(rootDir, '.agentuity');
 	const srcDir = join(rootDir, 'src');
@@ -715,4 +732,6 @@ export async function bundle({
 		`${outDir}/.routemapping.json`,
 		dev ? JSON.stringify(routeMapping, null, 2) : JSON.stringify(routeMapping)
 	);
+
+	return { output };
 }

package/src/cmd/build/plugin.ts

@@ -16,6 +16,7 @@ import { createLogger } from '@agentuity/server';
 import type { LogLevel } from '../../types';
 import { toCamelCase, toPascalCase } from '../../utils/string';
 import { generateRouteRegistry, type RouteInfo } from './route-registry';
+import { discoverRouteFiles } from './route-discovery';
 
 /**
  * Setup lifecycle types by analyzing app.ts for setup() function
@@ -461,96 +462,116 @@ import { readFileSync, existsSync } from 'node:fs';
 				const apiRoutesMetadata: BuildMetadata['routes'] = [];
 				const routeInfoList: RouteInfo[] = [];
 				const apiDir = join(srcDir, 'api');
+				// Track subdirectory routes for auto-mounting
+				const subRouteInserts: string[] = [];
 				if (existsSync(apiDir)) {
-					const { readdirSync, statSync } = await import('node:fs');
-					const apiFiles = readdirSync(apiDir)
-						.filter((name) => name.endsWith('.ts') && !name.endsWith('.generated.ts'))
-						.map((name) => join(apiDir, name));
+					// Use recursive route discovery to find all route files in subdirectories
+					const discoveredRoutes = discoverRouteFiles(apiDir);
+
+					// Collect all API files: index.ts and discovered subdirectory routes
+					const apiFiles: string[] = [];
+
+					// Check for root index.ts
+					const indexFile = join(apiDir, 'index.ts');
+					if (existsSync(indexFile)) {
+						apiFiles.push(indexFile);
+					}
+
+					// Add all discovered route files
+					for (const route of discoveredRoutes) {
+						apiFiles.push(route.filepath);
+
+						// Generate auto-mount code for this subdirectory route
+						subRouteInserts.push(`await (async() => {
+						const { getRouter } = await import('@agentuity/runtime');
+						const router = getRouter()!;
+						const ${route.variableName} = (await import('${route.importPath}')).default;
+						router.route('${route.mountPath}', ${route.variableName});
+						})();`);
+					}
 
 					for (const apiFile of apiFiles) {
-						if (statSync(apiFile).isFile()) {
-							try {
-								const routes = await parseRoute(rootDir, apiFile, projectId, deploymentId);
-
-								// Extract schemas from agents for routes that use validators
-								for (const route of routes) {
-									// Check if route has custom schema overrides from validator({ input, output })
-									const hasCustomInput = route.config?.inputSchemaVariable;
-									const hasCustomOutput = route.config?.outputSchemaVariable;
-
-									// If route uses agent.validator(), get schemas from the agent (unless overridden)
-									if (
-										route.config?.agentImportPath &&
-										(!hasCustomInput || !hasCustomOutput)
-									) {
-										const agentImportPath = route.config.agentImportPath as string;
-										// Match by import path: @agent/zod-test -> src/agent/zod-test/agent.ts
-										// Normalize import path by removing leading '@' -> agent/zod-test
-										const importPattern = agentImportPath.replace(/^@/, '');
-										// Escape regex special characters for safe pattern matching
-										const escapedPattern = importPattern.replace(
-											/[.*+?^${}()|[\]\\]/g,
-											'\\$&'
-										);
-										// Match as complete path segment to avoid false positives (e.g., "agent/hello" matching "agent/hello-world")
-										const segmentPattern = new RegExp(`(^|/)${escapedPattern}(/|$)`);
-
-										for (const [, agentMd] of agentMetadata) {
-											const agentFilename = agentMd.get('filename');
-											if (agentFilename && segmentPattern.test(agentFilename)) {
-												// Use agent schemas unless overridden
-												const inputSchemaCode = hasCustomInput
-													? undefined
-													: agentMd.get('inputSchemaCode');
-												const outputSchemaCode = hasCustomOutput
-													? undefined
-													: agentMd.get('outputSchemaCode');
-
-												if (inputSchemaCode || outputSchemaCode) {
-													route.schema = {
-														input: inputSchemaCode,
-														output: outputSchemaCode,
-													};
-												}
-												break;
-											}
-										}
-									}
+						try {
+							const routes = await parseRoute(rootDir, apiFile, projectId, deploymentId);
 
-									// TODO: Extract inline schema code from custom validator({ input: z.string(), output: ... })
-									// For now, custom schema overrides with inline code are not extracted (would require parsing the validator call's object expression)
-								}
+							// Extract schemas from agents for routes that use validators
+							for (const route of routes) {
+								// Check if route has custom schema overrides from validator({ input, output })
+								const hasCustomInput = route.config?.inputSchemaVariable;
+								const hasCustomOutput = route.config?.outputSchemaVariable;
 
-								apiRoutesMetadata.push(...routes);
-
-								// Collect route info for RouteRegistry generation
-								for (const route of routes) {
-									routeInfoList.push({
-										method: route.method.toUpperCase(),
-										path: route.path,
-										filename: route.filename,
-										hasValidator: route.config?.hasValidator === true,
-										routeType: route.type || 'api',
-										agentVariable: route.config?.agentVariable as string | undefined,
-										agentImportPath: route.config?.agentImportPath as string | undefined,
-										inputSchemaVariable: route.config?.inputSchemaVariable as
-											| string
-											| undefined,
-										outputSchemaVariable: route.config?.outputSchemaVariable as
-											| string
-											| undefined,
-									});
-								}
-							} catch (error) {
-								// Skip files that don't have createRouter (they might be utilities)
+								// If route uses agent.validator(), get schemas from the agent (unless overridden)
 								if (
-									error instanceof Error &&
-									error.message.includes('could not find an proper createRouter')
+									route.config?.agentImportPath &&
+									(!hasCustomInput || !hasCustomOutput)
 								) {
-									logger.trace(`Skipping ${apiFile}: no createRouter found`);
-								} else {
-									throw error;
+									const agentImportPath = route.config.agentImportPath as string;
+									// Match by import path: @agent/zod-test -> src/agent/zod-test/agent.ts
+									// Normalize import path by removing leading '@' -> agent/zod-test
+									const importPattern = agentImportPath.replace(/^@/, '');
+									// Escape regex special characters for safe pattern matching
+									const escapedPattern = importPattern.replace(
+										/[.*+?^${}()|[\]\\]/g,
+										'\\$&'
+									);
+									// Match as complete path segment to avoid false positives (e.g., "agent/hello" matching "agent/hello-world")
+									const segmentPattern = new RegExp(`(^|/)${escapedPattern}(/|$)`);
+
+									for (const [, agentMd] of agentMetadata) {
+										const agentFilename = agentMd.get('filename');
+										if (agentFilename && segmentPattern.test(agentFilename)) {
+											// Use agent schemas unless overridden
+											const inputSchemaCode = hasCustomInput
+												? undefined
+												: agentMd.get('inputSchemaCode');
+											const outputSchemaCode = hasCustomOutput
+												? undefined
+												: agentMd.get('outputSchemaCode');
+
+											if (inputSchemaCode || outputSchemaCode) {
+												route.schema = {
+													input: inputSchemaCode,
+													output: outputSchemaCode,
+												};
+											}
+											break;
+										}
+									}
 								}
+
+								// TODO: Extract inline schema code from custom validator({ input: z.string(), output: ... })
+								// For now, custom schema overrides with inline code are not extracted (would require parsing the validator call's object expression)
+							}
+
+							apiRoutesMetadata.push(...routes);
+
+							// Collect route info for RouteRegistry generation
+							for (const route of routes) {
+								routeInfoList.push({
+									method: route.method.toUpperCase(),
+									path: route.path,
+									filename: route.filename,
+									hasValidator: route.config?.hasValidator === true,
+									routeType: route.type || 'api',
+									agentVariable: route.config?.agentVariable as string | undefined,
+									agentImportPath: route.config?.agentImportPath as string | undefined,
+									inputSchemaVariable: route.config?.inputSchemaVariable as
+										| string
+										| undefined,
+									outputSchemaVariable: route.config?.outputSchemaVariable as
+										| string
+										| undefined,
+								});
+							}
+						} catch (error) {
+							// Skip files that don't have createRouter (they might be utilities)
+							if (
+								error instanceof Error &&
+								error.message.includes('could not find an proper createRouter')
+							) {
+								logger.trace(`Skipping ${apiFile}: no createRouter found`);
+							} else {
+								throw error;
 							}
 						}
 					}
@@ -573,6 +594,11 @@ import { readFileSync, existsSync } from 'node:fs';
 })();`);
 				}
 
+				// Auto-mount subdirectory routes (src/api/foo/route.ts -> /api/foo)
+				for (const subRouteInsert of subRouteInserts) {
+					inserts.push(subRouteInsert);
+				}
+
 				// Only create the workbench routes if workbench is actually configured
 				if (workbenchConfig) {
 					inserts.push(`await (async() => {

package/src/cmd/build/route-discovery.ts

@@ -0,0 +1,197 @@
+import { existsSync, readdirSync, lstatSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { toCamelCase } from '../../utils/string';
+
+/**
+ * Information about a discovered route file
+ */
+export interface DiscoveredRouteFile {
+	/** Full path to the route file */
+	filepath: string;
+	/** Relative path from apiDir (e.g., 'auth/route.ts', 'v1/users/route.ts') */
+	relativePath: string;
+	/** Mount path for the route (e.g., '/api/auth', '/api/v1/users') */
+	mountPath: string;
+	/** Safe variable name for importing (e.g., 'authRoute', 'v1UsersRoute') */
+	variableName: string;
+	/** Import path relative to build output (e.g., './src/api/auth/route') */
+	importPath: string;
+}
+
+/**
+ * Recursively discover all TypeScript route files in an API directory
+ * Supports nested structures like:
+ * - src/api/index.ts (root API router)
+ * - src/api/auth/route.ts -> mounted at /api/auth
+ * - src/api/v1/users/route.ts -> mounted at /api/v1/users
+ * - src/api/admin/users/login.ts -> mounted at /api/admin/users (any .ts file works)
+ *
+ * @param apiDir - Absolute path to the src/api directory
+ * @param currentDir - Current directory being scanned (used for recursion)
+ * @param results - Accumulated results (used for recursion)
+ * @returns Array of discovered route files with mount information
+ */
+export function discoverRouteFiles(
+	apiDir: string,
+	currentDir: string = apiDir,
+	results: DiscoveredRouteFile[] = []
+): DiscoveredRouteFile[] {
+	if (!existsSync(currentDir)) {
+		return results;
+	}
+
+	const entries = readdirSync(currentDir);
+
+	for (const entry of entries) {
+		const entryPath = join(currentDir, entry);
+		const stat = lstatSync(entryPath);
+
+		// Skip symlinks to prevent infinite recursion
+		if (stat.isSymbolicLink()) {
+			continue;
+		}
+
+		if (stat.isFile() && entry.endsWith('.ts') && !entry.endsWith('.generated.ts')) {
+			// Found a TypeScript file
+			const relativePath = relative(apiDir, entryPath);
+			const isRootIndex = relativePath === 'index.ts';
+
+			// Skip root index.ts - it's handled separately
+			if (isRootIndex) {
+				continue;
+			}
+
+			// For subdirectory files, determine mount path
+			// src/api/auth/route.ts -> /api/auth
+			// src/api/v1/users/route.ts -> /api/v1/users
+			// src/api/admin/login.ts -> /api/admin
+			const pathParts = relativePath.split('/');
+			pathParts.pop(); // Remove filename
+
+			// Skip files directly in src/api/ to avoid mount path conflicts with root index.ts
+			if (pathParts.length === 0) {
+				continue;
+			}
+
+			const mountPath = `/api/${pathParts.join('/')}`;
+
+			// Generate safe variable name
+			// auth/route.ts -> authRoute
+			// v1/users/route.ts -> v1UsersRoute
+			// admin/login.ts -> adminLoginRoute
+			const variableParts = pathParts.map((p, idx) => {
+				const camel = toCamelCase(p);
+				// Capitalize first letter of all parts except the first
+				return idx === 0 ? camel : camel.charAt(0).toUpperCase() + camel.slice(1);
+			});
+			const baseName = entry.replace('.ts', '');
+			if (baseName !== 'route' && baseName !== 'index') {
+				const camelBase = toCamelCase(baseName);
+				// Always capitalize the base name since it's not the first part
+				variableParts.push(camelBase.charAt(0).toUpperCase() + camelBase.slice(1));
+			}
+			const variableName = variableParts.join('') + 'Route';
+
+			// Generate import path relative to build output
+			// src/api/auth/route.ts -> ./src/api/auth/route
+			const importPath = './src/api/' + relativePath.replace('.ts', '');
+
+			results.push({
+				filepath: entryPath,
+				relativePath,
+				mountPath,
+				variableName,
+				importPath,
+			});
+		} else if (stat.isDirectory()) {
+			// Recursively scan subdirectories
+			discoverRouteFiles(apiDir, entryPath, results);
+		}
+	}
+
+	return results;
+}
+
+/**
+ * Detect potential route path conflicts
+ *
+ * @param routes - Array of route metadata with method and path
+ * @returns Array of conflict descriptions
+ */
+export interface RouteConflict {
+	type: 'duplicate' | 'ambiguous-param' | 'wildcard-overlap';
+	routes: Array<{ method: string; path: string; filename: string }>;
+	message: string;
+}
+
+export function detectRouteConflicts(
+	routes: Array<{ method: string; path: string; filename: string }>
+): RouteConflict[] {
+	const conflicts: RouteConflict[] = [];
+
+	// Group routes by method+path
+	const methodPathMap = new Map<string, Array<{ path: string; filename: string }>>();
+
+	for (const route of routes) {
+		const key = `${route.method.toUpperCase()} ${route.path}`;
+		if (!methodPathMap.has(key)) {
+			methodPathMap.set(key, []);
+		}
+		methodPathMap.get(key)!.push({ path: route.path, filename: route.filename });
+	}
+
+	// Check for exact duplicates
+	for (const [methodPath, routeList] of methodPathMap.entries()) {
+		if (routeList.length > 1) {
+			const [method] = methodPath.split(' ', 2);
+			conflicts.push({
+				type: 'duplicate',
+				routes: routeList.map((r) => ({ method, path: r.path, filename: r.filename })),
+				message: `Duplicate route: ${methodPath} defined in ${routeList.length} files`,
+			});
+		}
+	}
+
+	// Check for ambiguous parameter routes (same method, different param names)
+	// e.g., GET /users/:id and GET /users/:userId
+	const methodGroups = new Map<string, Array<{ path: string; filename: string }>>();
+	for (const route of routes) {
+		const method = route.method.toUpperCase();
+		if (!methodGroups.has(method)) {
+			methodGroups.set(method, []);
+		}
+		methodGroups.get(method)!.push({ path: route.path, filename: route.filename });
+	}
+
+	for (const [method, routeList] of methodGroups.entries()) {
+		// Normalize params to check for conflicts
+		const normalized = routeList.map((r) => ({
+			...r,
+			normalizedPath: r.path.replace(/:[^/]+/g, ':param'),
+		}));
+
+		const pathMap = new Map<string, Array<{ path: string; filename: string }>>();
+		for (const route of normalized) {
+			if (!pathMap.has(route.normalizedPath)) {
+				pathMap.set(route.normalizedPath, []);
+			}
+			pathMap.get(route.normalizedPath)!.push({ path: route.path, filename: route.filename });
+		}
+
+		for (const [normalizedPath, paths] of pathMap.entries()) {
+			if (paths.length > 1 && normalizedPath.includes(':param')) {
+				// Check if the actual param names differ
+				const uniquePaths = new Set(paths.map((p) => p.path));
+				if (uniquePaths.size > 1) {
+					conflicts.push({
+						type: 'ambiguous-param',
+						routes: paths.map(({ path, filename }) => ({ method, path, filename })),
+						message: `Ambiguous param routes: ${method} ${Array.from(uniquePaths).join(', ')}`,
+					});
+				}
+			}
+		}
+	}
+
+	return conflicts;
+}

package/src/cmd/build/route-registry.ts

@@ -37,13 +37,13 @@ export interface RouteInfo {
  * @param routes - Array of route information
  */
 export function generateRouteRegistry(srcDir: string, routes: RouteInfo[]): void {
-	// Filter routes by type and validator presence
-	const apiRoutes = routes.filter((r) => r.hasValidator && r.routeType === 'api');
-	const websocketRoutes = routes.filter((r) => r.hasValidator && r.routeType === 'websocket');
-	const sseRoutes = routes.filter((r) => r.hasValidator && r.routeType === 'sse');
+	// Filter routes by type (include ALL routes, not just those with validators)
+	const apiRoutes = routes.filter((r) => r.routeType === 'api');
+	const websocketRoutes = routes.filter((r) => r.routeType === 'websocket');
+	const sseRoutes = routes.filter((r) => r.routeType === 'sse');
 
 	if (apiRoutes.length === 0 && websocketRoutes.length === 0 && sseRoutes.length === 0) {
-		// No typed routes, skip generation
+		// No routes, skip generation
 		return;
 	}
 
@@ -52,11 +52,15 @@ export function generateRouteRegistry(srcDir: string, routes: RouteInfo[]): void
 	const agentImports = new Map<string, string>(); // Maps agent variable to unique import name
 	const schemaImports = new Set<string>(); // Track which schema variables we've seen
 
-	// Combine all typed routes for import collection
-	const allTypedRoutes = [...apiRoutes, ...websocketRoutes, ...sseRoutes];
+	// Combine all routes for import collection
+	const allRoutes = [...apiRoutes, ...websocketRoutes, ...sseRoutes];
 
-	// First pass: collect all unique agents and schema variables
-	allTypedRoutes.forEach((route) => {
+	// First pass: collect all unique agents and schema variables (only for routes with validators)
+	allRoutes.forEach((route) => {
+		// Skip routes without validators - they won't need imports
+		if (!route.hasValidator) {
+			return;
+		}
 		// If this route uses an agent, import it directly
 		if (route.agentVariable && route.agentImportPath && !agentImports.has(route.agentVariable)) {
 			// Resolve the import path (could be @agent/hello, ../shared, etc.)
@@ -90,7 +94,11 @@ export function generateRouteRegistry(srcDir: string, routes: RouteInfo[]): void
 
 	// Import schema variables from route files
 	const routeFileImports = new Map<string, Set<string>>(); // Maps route file to schema variables
-	allTypedRoutes.forEach((route) => {
+	allRoutes.forEach((route) => {
+		// Only import schemas for routes with validators
+		if (!route.hasValidator) {
+			return;
+		}
 		if (route.inputSchemaVariable || route.outputSchemaVariable) {
 			const filename = route.filename.replace(/\\/g, '/');
 			const importPath = `../${filename.replace(/\.ts$/, '')}`;
@@ -120,6 +128,14 @@ export function generateRouteRegistry(srcDir: string, routes: RouteInfo[]): void
 	const generateRouteEntry = (route: RouteInfo): string => {
 		const routeKey = route.path; // Use path only for websocket/sse, or METHOD path for API
 
+		// If route doesn't have a validator, use never for schemas
+		if (!route.hasValidator) {
+			return `  '${routeKey}': {
+    inputSchema: never;
+    outputSchema: never;
+  };`;
+		}
+
 		// If we have an agent variable, we can infer types from it
 		if (route.agentVariable) {
 			const importName = agentImports.get(route.agentVariable)!;