@agentuity/cli 0.0.55 → 0.0.57

package/src/cmd/build/plugin.ts

@@ -8,8 +8,8 @@ import {
 	parseEvalMetadata,
 	analyzeWorkbench,
 	checkRouteConflicts,
-	type WorkbenchConfig,
 } from './ast';
+import type { WorkbenchConfig } from '@agentuity/core';
 import { applyPatch, generatePatches } from './patch';
 import { detectSubagent } from '../../utils/detectSubagent';
 import { createLogger } from '@agentuity/server';
@@ -35,18 +35,18 @@ async function setupWorkbench(srcDir: string): Promise<WorkbenchConfig | null> {
 	const srcAppFile = join(srcDir, 'app.ts');
 
 	let appFile = '';
-	if (existsSync(rootAppFile)) {
+	if (await Bun.file(rootAppFile).exists()) {
 		appFile = rootAppFile;
-	} else if (existsSync(srcAppFile)) {
+	} else if (await Bun.file(srcAppFile).exists()) {
 		appFile = srcAppFile;
 	}
 
-	if (!appFile || !existsSync(appFile)) {
+	if (!appFile || !(await Bun.file(appFile).exists())) {
 		return null;
 	}
 
 	const appContent = await Bun.file(appFile).text();
-	const analysis = await analyzeWorkbench(appContent);
+	const analysis = analyzeWorkbench(appContent);
 
 	if (!analysis.hasWorkbench) {
 		return null;
@@ -56,7 +56,7 @@ async function setupWorkbench(srcDir: string): Promise<WorkbenchConfig | null> {
 
 	// Check for route conflicts if workbench is being used
 	if (workbenchConfig?.route) {
-		const hasConflict = await checkRouteConflicts(appContent, workbenchConfig.route);
+		const hasConflict = checkRouteConflicts(appContent, workbenchConfig.route);
 		if (hasConflict) {
 			const logger = createLogger((process.env.AGENTUITY_LOG_LEVEL as LogLevel) || 'info');
 			logger.error(`🚨 Route conflict detected!\n`);
@@ -493,7 +493,6 @@ const AgentuityBundler: BunPlugin = {
 						projectId,
 						deploymentId
 					);
-					routeDefinitions = [...routeDefinitions, ...definitions];
 
 					let agentDetail: Record<string, string> = {};
 
@@ -504,6 +503,7 @@ const AgentuityBundler: BunPlugin = {
 						}
 						agentDetail = {
 							name,
+							id: md.get('id')!,
 							path: `.${agent}`,
 							filename: md.get('filename')!,
 							identifier: md.get('identifier')!,
@@ -514,8 +514,14 @@ const AgentuityBundler: BunPlugin = {
 							agentDetail.parent = parentName;
 						}
 						agentInfo.push(agentDetail);
+						for (const def of definitions) {
+							def.agentIds = [agentDetail.agentId, agentDetail.id];
+						}
 					}
 
+					// do this after handling the agent association (if any)
+					routeDefinitions = [...routeDefinitions, ...definitions];
+
 					let buffer = `await (async() => {
     const { createAgentMiddleware, getRouter, registerAgent } = await import('@agentuity/runtime');
     const router = getRouter()!;
@@ -567,8 +573,8 @@ const AgentuityBundler: BunPlugin = {
 		// Use the workbench config determined at build time
 		const route = ${JSON.stringify(workbenchConfig?.route || '/workbench')};
 
-// If using custom route, update HTML to point to absolute /workbench/ paths
-if (route !== '/workbench') {
+		// If using custom route, update HTML to point to absolute /workbench/ paths
+		if (route !== '/workbench') {
 			workbenchIndex = workbenchIndex.replace(new RegExp('src="\\\\.\\\\/workbench\\\\/', 'g'), 'src="/workbench/');
 		}
 		
@@ -657,6 +663,9 @@ if (route !== '/workbench') {
 					if (!v.has('name')) {
 						throw new Error('agent metadata is missing expected name property');
 					}
+					if (!v.has('agentId')) {
+						throw new Error('agent metadata is missing expected agentId property');
+					}
 
 					const parentName = v.get('parent');
 					if (parentName) {

package/src/cmd/build/workbench-templates.ts

@@ -0,0 +1,52 @@
+import type { WorkbenchConfig } from '@agentuity/core';
+
+export function generateWorkbenchMainTsx(config: WorkbenchConfig): string {
+	const configString = JSON.stringify(config);
+
+	return `// Generated workbench entry point
+import React from 'react';
+import { createRoot } from 'react-dom/client';
+import { AgentuityProvider } from '@agentuity/react';
+import { createWorkbench, Workbench } from '@agentuity/workbench';
+import '@agentuity/workbench/styles';
+
+// Root element
+const rootElement = document.getElementById('root');
+if (!rootElement) {
+	throw new Error('Root element not found');
+}
+
+// Create workbench instance with config from bundler
+const workbenchConfig = ${configString};
+const workbench = createWorkbench(workbenchConfig);
+
+function App() {
+	return (
+		<AgentuityProvider baseUrl={window.location.origin}>
+			<div className="min-h-screen bg-background text-foreground">
+				<Workbench workbench={workbench} />
+			</div>
+		</AgentuityProvider>
+	);
+}
+
+// Render the app
+const root = createRoot(rootElement);
+root.render(<App />);
+`;
+}
+
+export function generateWorkbenchIndexHtml(): string {
+	return `<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<title>Agentuity Workbench</title>
+</head>
+<body>
+	<div id="root"></div>
+	<script type="module" src="./main.tsx"></script>
+</body>
+</html>`;
+}

package/src/cmd/cloud/deploy.ts

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 import { join, resolve } from 'node:path';
 import { createPublicKey } from 'node:crypto';
 import { createReadStream, createWriteStream } from 'node:fs';
@@ -26,9 +27,9 @@ import {
 } from '../../env-util';
 import { zipDir } from '../../utils/zip';
 import { encryptFIPSKEMDEMStream } from '../../crypto/box';
-import { checkCustomDomainForDNS } from './domain';
+import { DeployOptionsSchema } from '../build/bundler';
 import { getCommand } from '../../command-prefix';
-import { z } from 'zod';
+import { checkCustomDomainForDNS } from './domain';
 
 const DeployResponseSchema = z.object({
 	success: z.boolean().describe('Whether deployment succeeded'),
@@ -58,17 +59,19 @@ export const deploySubcommand = createSubcommand({
 	examples: [
 		`${getCommand('cloud deploy')}                    # Deploy current project`,
 		`${getCommand('cloud deploy')} --log-level=debug  # Deploy with verbose output`,
+		`${getCommand('cloud deploy')} --tag a --tag b    # Deploy with specific tags`,
 	],
 	toplevel: true,
 	idempotent: false,
 	requires: { auth: true, project: true, apiClient: true },
 	prerequisites: ['auth login'],
 	schema: {
+		options: DeployOptionsSchema,
 		response: DeployResponseSchema,
 	},
 
 	async handler(ctx) {
-		const { project, apiClient, projectDir, config, options } = ctx;
+		const { project, apiClient, projectDir, config, options, opts } = ctx;
 
 		let deployment: Deployment | undefined;
 		let build: BuildMetadata | undefined;
@@ -171,6 +174,11 @@ export const deploySubcommand = createSubcommand({
 									orgId: deployment.orgId,
 									projectId: project.projectId,
 									project,
+									commitUrl: opts?.commitUrl,
+									logsUrl: opts?.logsUrl,
+									provider: opts?.provider,
+									trigger: opts?.trigger,
+									tag: opts?.tag,
 								});
 								build = await loadBuildMetadata(join(projectDir, '.agentuity'));
 								instructions = await projectDeploymentUpdate(

package/src/cmd/cloud/deployment/show.ts

@@ -15,7 +15,39 @@ const DeploymentShowResponseSchema = z.object({
 	tags: z.array(z.string()).describe('Deployment tags'),
 	customDomains: z.array(z.string()).optional().describe('Custom domains'),
 	cloudRegion: z.string().optional().describe('Cloud region'),
-	metadata: z.any().optional().describe('Deployment metadata'),
+	metadata: z
+		.object({
+			git: z
+				.object({
+					repo: z.string().optional(),
+					commit: z.string().optional(),
+					message: z.string().optional(),
+					branch: z.string().optional(),
+					url: z.string().optional(),
+					trigger: z.string().optional(),
+					provider: z.string().optional(),
+					event: z.string().optional(),
+					buildUrl: z.string().optional(),
+					pull_request: z
+						.object({
+							number: z.number(),
+							url: z.string().optional(),
+							commentId: z.string().optional(),
+						})
+						.optional(),
+				})
+				.optional(),
+			build: z
+				.object({
+					agentuity: z.string().optional(),
+					bun: z.string().optional(),
+					platform: z.string().optional(),
+					arch: z.string().optional(),
+				})
+				.optional(),
+		})
+		.optional()
+		.describe('Deployment metadata'),
 });
 
 export const showSubcommand = createSubcommand({
@@ -49,8 +81,6 @@ export const showSubcommand = createSubcommand({
 
 			// Skip TUI output in JSON mode
 			if (!options.json) {
-				tui.banner(`Deployment ${deployment.id}`, `State: ${deployment.state || 'unknown'}`);
-
 				console.log(tui.bold('ID:       ') + deployment.id);
 				console.log(tui.bold('Project:  ') + projectId);
 				console.log(tui.bold('State:    ') + (deployment.state || 'unknown'));
@@ -74,22 +104,35 @@ export const showSubcommand = createSubcommand({
 					console.log(tui.bold('Region:   ') + deployment.cloudRegion);
 				}
 
-				// Metadata
-				const origin = deployment.metadata?.origin;
-				if (origin?.commit) {
+				// Git metadata
+				const git = deployment.metadata?.git;
+				if (git) {
 					tui.newline();
-					tui.info('Origin Information');
-					if (origin.trigger) console.log(`  Trigger:  ${origin.trigger}`);
-					if (origin.provider) console.log(`  Provider: ${origin.provider}`);
-					if (origin.event) console.log(`  Event:    ${origin.event}`);
-					if (origin.branch) console.log(`  Branch:   ${origin.branch}`);
-
-					if (origin.commit) {
-						console.log(`  Commit:   ${origin.commit.hash}`);
-						if (origin.commit.message) console.log(`  Message:  ${origin.commit.message}`);
-						if (origin.commit.author?.name)
-							console.log(`  Author:   ${origin.commit.author.name}`);
+					tui.info('Git Information');
+					if (git.repo) console.log(`  Repo:     ${git.repo}`);
+					if (git.branch) console.log(`  Branch:   ${git.branch}`);
+					if (git.commit) console.log(`  Commit:   ${git.commit}`);
+					if (git.message) console.log(`  Message:  ${git.message}`);
+					if (git.url) console.log(`  URL:      ${git.url}`);
+					if (git.trigger) console.log(`  Trigger:  ${git.trigger}`);
+					if (git.provider) console.log(`  Provider: ${git.provider}`);
+					if (git.event) console.log(`  Event:    ${git.event}`);
+					if (git.pull_request) {
+						console.log(`  PR:       #${git.pull_request.number}`);
+						if (git.pull_request.url) console.log(`  PR URL:   ${git.pull_request.url}`);
 					}
+					if (git.buildUrl) console.log(`  Build:    ${git.buildUrl}`);
+				}
+
+				// Build metadata
+				const build = deployment.metadata?.build;
+				if (build) {
+					tui.newline();
+					tui.info('Build Information');
+					if (build.agentuity) console.log(`  Agentuity: ${build.agentuity}`);
+					if (build.bun) console.log(`  Bun:       ${build.bun}`);
+					if (build.platform) console.log(`  Platform:  ${build.platform}`);
+					if (build.arch) console.log(`  Arch:      ${build.arch}`);
 				}
 			}
 

package/src/cmd/cloud/session/get.ts

@@ -1,11 +1,29 @@
 import { z } from 'zod';
 import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
-import { sessionGet } from '@agentuity/server';
+import { sessionGet, type SpanNode } from '@agentuity/server';
 import { getCommand } from '../../../command-prefix';
 import { ErrorCode } from '../../../errors';
 import { getCatalystAPIClient } from '../../../config';
 
+const SpanNodeSchema: z.ZodType<SpanNode> = z.lazy(() =>
+	z.object({
+		id: z.string().describe('Span ID'),
+		duration: z.number().describe('Duration in milliseconds'),
+		operation: z.string().describe('Operation name'),
+		attributes: z.record(z.string(), z.unknown()).describe('Span attributes'),
+		children: z.array(SpanNodeSchema).optional().describe('Child spans'),
+	})
+);
+
+const RouteInfoSchema = z
+	.object({
+		id: z.string().describe('Route ID'),
+		method: z.string().describe('HTTP method'),
+		path: z.string().describe('Route path'),
+	})
+	.nullable();
+
 const SessionGetResponseSchema = z.object({
 	id: z.string().describe('Session ID'),
 	created_at: z.string().describe('Creation timestamp'),
@@ -26,8 +44,15 @@ const SessionGetResponseSchema = z.object({
 	url: z.string().describe('Request URL'),
 	route_id: z.string().describe('Route ID'),
 	thread_id: z.string().describe('Thread ID'),
-	agentNames: z.array(z.string()).describe('Agent names'),
-	evalRuns: z
+	agents: z
+		.array(
+			z.object({
+				name: z.string(),
+				identifier: z.string(),
+			})
+		)
+		.describe('Agents'),
+	eval_runs: z
 		.array(
 			z.object({
 				id: z.string(),
@@ -40,8 +65,41 @@ const SessionGetResponseSchema = z.object({
 			})
 		)
 		.describe('Eval runs'),
+	timeline: SpanNodeSchema.nullable().optional().describe('Session timeline'),
+	route: RouteInfoSchema.optional().describe('Route information'),
 });
 
+function formatDuration(ms: number): string {
+	if (ms < 1) {
+		return `${(ms * 1000).toFixed(0)}µs`;
+	}
+	if (ms < 1000) {
+		return `${ms.toFixed(1)}ms`;
+	}
+	return `${(ms / 1000).toFixed(2)}s`;
+}
+
+function printTimeline(node: SpanNode, prefix: string, isLast = true): void {
+	const connector = isLast ? '└── ' : '├── ';
+	const duration = tui.muted(`(${formatDuration(node.duration)})`);
+	let extra = '';
+	if (node.operation.startsWith('agentuity.')) {
+		if ('name' in node.attributes && 'key' in node.attributes) {
+			extra = tui.colorSuccess(`${node.attributes.name} ${node.attributes.key}`) + ' ';
+		}
+	}
+	if (node.operation.startsWith('HTTP ') && 'http.url' in node.attributes) {
+		extra = `${tui.colorSuccess(node.attributes['http.url'] as string)} `;
+	}
+	console.log(`${prefix}${connector}${node.operation} ${extra}${duration}`);
+
+	const childPrefix = prefix + (isLast ? '    ' : '│   ');
+	const children = node.children ?? [];
+	children.forEach((child, index) => {
+		printTimeline(child, childPrefix, index === children.length - 1);
+	});
+}
+
 export const getSubcommand = createSubcommand({
 	name: 'get',
 	description: 'Get details about a specific session',
@@ -83,8 +141,8 @@ export const getSubcommand = createSubcommand({
 				url: session.url,
 				route_id: session.route_id,
 				thread_id: session.thread_id,
-				agentNames: enriched.agentNames,
-				evalRuns: enriched.evalRuns.map((run) => ({
+				agents: enriched.agents,
+				eval_runs: enriched.evalRuns.map((run) => ({
 					id: run.id,
 					eval_id: run.eval_id,
 					created_at: run.created_at,
@@ -93,6 +151,8 @@ export const getSubcommand = createSubcommand({
 					error: run.error,
 					result: run.result,
 				})),
+				timeline: enriched.timeline,
+				route: enriched.route,
 			};
 
 			if (options.json) {
@@ -100,17 +160,14 @@ export const getSubcommand = createSubcommand({
 				return result;
 			}
 
-			tui.banner(`Session ${session.id}`, `Status: ${session.success ? 'Success' : 'Failed'}`);
-
 			console.log(tui.bold('ID:          ') + session.id);
 			console.log(tui.bold('Project:     ') + session.project_id);
 			console.log(tui.bold('Deployment:  ') + (session.deployment_id || '-'));
-			console.log(tui.bold('Created:     ') + new Date(session.created_at).toLocaleString());
 			console.log(tui.bold('Start:       ') + new Date(session.start_time).toLocaleString());
 			if (session.end_time) {
 				console.log(tui.bold('End:         ') + new Date(session.end_time).toLocaleString());
 			}
-			if (session.duration) {
+			if (session.duration && session.end_time) {
 				console.log(
 					tui.bold('Duration:    ') + `${(session.duration / 1_000_000).toFixed(0)}ms`
 				);
@@ -118,23 +175,32 @@ export const getSubcommand = createSubcommand({
 			console.log(tui.bold('Method:      ') + session.method);
 			console.log(tui.bold('URL:         ') + tui.link(session.url, session.url));
 			console.log(tui.bold('Trigger:     ') + session.trigger);
-			console.log(tui.bold('Environment: ') + session.env);
+			if (session.env !== 'production') {
+				console.log(tui.bold('Environment: ') + session.env);
+			}
 			console.log(tui.bold('Dev Mode:    ') + (session.devmode ? 'Yes' : 'No'));
-			console.log(tui.bold('Success:     ') + (session.success ? '✓' : '✗'));
+			console.log(
+				tui.bold('Success:     ') +
+					(session.success ? tui.colorSuccess('✓') : tui.colorError('✗'))
+			);
 			console.log(tui.bold('Pending:     ') + (session.pending ? 'Yes' : 'No'));
 			if (session.error) {
 				console.log(tui.bold('Error:       ') + tui.error(session.error));
 			}
-			if (enriched.agentNames.length > 0) {
-				const agentDisplay = enriched.agentNames
-					.map((name, idx) => {
-						const agentId = session.agent_ids[idx];
-						return `${name} ${tui.muted(`(${agentId})`)}`;
-					})
+			if (enriched.agents.length > 0) {
+				const agentDisplay = enriched.agents
+					.map((agent) => `${agent.name} ${tui.muted(`(${agent.identifier})`)}`)
 					.join(', ');
 				console.log(tui.bold('Agents:      ') + agentDisplay);
 			}
-			console.log(tui.bold('Route ID:    ') + session.route_id);
+			if (enriched.route) {
+				console.log(
+					tui.bold('Route:       ') +
+						`${enriched.route.method.toUpperCase()} ${enriched.route.path} ${tui.muted(`(${enriched.route.id})`)}`
+				);
+			} else {
+				console.log(tui.bold('Route ID:    ') + session.route_id);
+			}
 			console.log(tui.bold('Thread ID:   ') + session.thread_id);
 
 			if (enriched.evalRuns.length > 0) {
@@ -143,7 +209,7 @@ export const getSubcommand = createSubcommand({
 				const evalTableData = enriched.evalRuns.map((run) => ({
 					ID: run.id,
 					'Eval ID': run.eval_id,
-					Success: run.success ? '✓' : '✗',
+					Success: run.success ? tui.colorSuccess('✓') : tui.colorError('✗'),
 					Pending: run.pending ? '⏳' : '✓',
 					Error: run.error || 'No',
 					Created: new Date(run.created_at).toLocaleString(),
@@ -159,6 +225,12 @@ export const getSubcommand = createSubcommand({
 				]);
 			}
 
+			if (result.timeline) {
+				console.log('');
+				console.log(tui.bold('Timeline:'));
+				printTimeline(result.timeline, '');
+			}
+
 			return result;
 		} catch (ex) {
 			tui.fatal(

package/src/cmd/index.ts

@@ -38,6 +38,8 @@ export async function discoverCommands(): Promise<CommandDefinition[]> {
 									prerequisites: (subcommand as any).prerequisites,
 									// eslint-disable-next-line @typescript-eslint/no-explicit-any
 									tags: (subcommand as any).tags,
+									// eslint-disable-next-line @typescript-eslint/no-explicit-any
+									examples: (subcommand as any).examples,
 								};
 								commands.push(alias as CommandDefinition);
 							}

package/src/cmd/project/template-flow.ts

@@ -325,6 +325,7 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 					deployment: {
 						resources: resourceConfig,
 					},
+					region: region ?? 'usc',
 				});
 			},
 		});

package/src/config.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { existsSync } from 'node:fs';
+import { existsSync, mkdirSync } from 'node:fs';
 import type { Logger } from '@agentuity/core';
 import {
 	BuildMetadataSchema,
@@ -486,6 +486,7 @@ class ProjectConfigNotFoundExpection extends Error {
 type ProjectConfig = z.infer<typeof ProjectSchema>;
 
 function generateJSON5WithComments(
+	jsonSchema: string,
 	schema: z.ZodObject<z.ZodRawShape>,
 	data: Record<string, unknown>
 ): string {
@@ -493,6 +494,8 @@ function generateJSON5WithComments(
 	const shape = schema.shape;
 	const keys = Object.keys(shape);
 
+	lines.push(`  "$schema": "${jsonSchema}",`);
+
 	for (let i = 0; i < keys.length; i++) {
 		const key = keys[i];
 		const fieldSchema = shape[key] as z.ZodTypeAny;
@@ -551,23 +554,59 @@ export async function loadProjectConfig(
 	return result.data;
 }
 
-type InitialProjectConfig = ProjectConfig & {
-	sdkKey: string;
-};
+export const InitialProjectConfigSchema = z.intersection(
+	ProjectSchema,
+	z.object({
+		sdkKey: z.string().describe('the project specific SDK key'),
+		$schema: z.string().optional(),
+	})
+);
+
+type InitialProjectConfig = z.infer<typeof InitialProjectConfigSchema>;
 
 export async function createProjectConfig(dir: string, config: InitialProjectConfig) {
 	const { sdkKey, ...sanitizedConfig } = config;
 
+	// generate the project config
 	const configPath = join(dir, 'agentuity.json');
-	const json5Content = generateJSON5WithComments(ProjectSchema, sanitizedConfig);
+	const json5Content = generateJSON5WithComments(
+		'https://agentuity.dev/schema/cli/v1/agentuity.json',
+		ProjectSchema,
+		sanitizedConfig
+	);
 	await Bun.write(configPath, json5Content + '\n');
 
+	// generate the .env file with initial secret
 	const envPath = join(dir, '.env');
 	const comment =
 		'# AGENTUITY_SDK_KEY is a sensitive value and should not be committed to version control.';
 	const content = `${comment}\nAGENTUITY_SDK_KEY=${sdkKey}\n`;
 	await Bun.write(envPath, content);
 	await chmod(envPath, 0o600);
+
+	// generate the vscode settings
+	const vscodeDir = join(dir, '.vscode');
+	mkdirSync(vscodeDir);
+
+	const settings = {
+		'files.associations': {
+			'agentuity.json': 'jsonc',
+		},
+		'search.exclude': {
+			'**/.git/**': true,
+			'**/node_modules/**': true,
+			'**/bun.lock': true,
+			'**/.agentuity/**': true,
+		},
+		'json.schemas': [
+			{
+				fileMatch: ['agentuity.json'],
+				url: 'https://agentuity.dev/schema/cli/v1/agentuity.json',
+			},
+		],
+	};
+
+	await Bun.write(join(vscodeDir, 'settings.json'), JSON.stringify(settings, null, 2));
 }
 
 export async function loadBuildMetadata(dir: string): Promise<BuildMetadata> {

package/src/schema-generator.ts

@@ -13,7 +13,7 @@ export interface SchemaArgument {
 
 export interface SchemaOption {
 	name: string;
-	type: 'string' | 'number' | 'boolean';
+	type: 'string' | 'number' | 'boolean' | 'array';
 	required: boolean;
 	default?: unknown;
 	description?: string;

package/src/schema-parser.ts

@@ -13,9 +13,10 @@ export interface ParsedArgs {
 export interface ParsedOption {
 	name: string;
 	description?: string;
-	type: 'string' | 'number' | 'boolean';
+	type: 'string' | 'number' | 'boolean' | 'array';
 	hasDefault?: boolean;
 	defaultValue?: unknown;
+	enumValues?: string[];
 }
 
 interface ZodTypeDef {
@@ -167,11 +168,21 @@ export function parseOptionsSchema(schema: ZodType): ParsedOption[] {
 			? (defaultInfo.defaultValue as () => unknown)()
 			: defaultInfo.defaultValue;
 
-		let type: 'string' | 'number' | 'boolean' = 'string';
+		let type: 'string' | 'number' | 'boolean' | 'array' = 'string';
+		let enumValues: string[] | undefined;
 		if (typeId === 'ZodNumber' || typeId === 'number') {
 			type = 'number';
 		} else if (typeId === 'ZodBoolean' || typeId === 'boolean') {
 			type = 'boolean';
+		} else if (typeId === 'ZodArray' || typeId === 'array') {
+			type = 'array';
+		} else if (typeId === 'ZodEnum' || typeId === 'enum') {
+			// Extract enum values from Zod 4's def.entries
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			const def = (unwrapped as any)?._def;
+			if (def?.entries && typeof def.entries === 'object') {
+				enumValues = Object.values(def.entries as Record<string, string>);
+			}
 		}
 
 		options.push({
@@ -180,6 +191,7 @@ export function parseOptionsSchema(schema: ZodType): ParsedOption[] {
 			description,
 			hasDefault: defaultInfo.hasDefault,
 			defaultValue,
+			enumValues,
 		});
 	}
 
@@ -203,8 +215,11 @@ export function buildValidationInput(
 	if (schemas.options) {
 		const parsed = parseOptionsSchema(schemas.options);
 		for (const opt of parsed) {
-			// Always include the option value (even if undefined) so zod can apply defaults
-			result.options[opt.name] = rawOptions[opt.name];
+			// Only include the option if it has a value - omitting undefined allows Zod to apply defaults
+			const value = rawOptions[opt.name];
+			if (value !== undefined) {
+				result.options[opt.name] = value;
+			}
 		}
 	}