@agentuity/cli 0.0.48 → 0.0.50

package/src/cmd/auth/signup.ts

@@ -3,12 +3,17 @@ import { getAppBaseURL, UpgradeRequiredError } from '@agentuity/server';
 import { saveAuth } from '../../config';
 import { generateSignupOTP, pollForSignupCompletion } from './api';
 import * as tui from '../../tui';
+import { getCommand } from '../../command-prefix';
+import { ErrorCode } from '../../errors';
 
 export const signupCommand = createSubcommand({
 	name: 'signup',
 	description: 'Create a new Agentuity Cloud Platform account',
+	tags: ['mutating', 'creates-resource', 'slow', 'api-intensive'],
 	toplevel: true,
+	idempotent: false,
 	requires: { apiClient: true },
+	examples: [getCommand('auth signup'), getCommand('signup')],
 
 	async handler(ctx) {
 		const { logger, config, apiClient } = ctx;
@@ -46,9 +51,9 @@ export const signupCommand = createSubcommand({
 				tui.banner('CLI Upgrade Required', bannerBody);
 				process.exit(1);
 			} else if (error instanceof Error) {
-				logger.fatal(`Signup failed: ${error.message}`);
+				logger.fatal(`Signup failed: ${error.message}`, ErrorCode.AUTH_FAILED);
 			} else {
-				logger.fatal('Signup failed');
+				logger.fatal('Signup failed', ErrorCode.AUTH_FAILED);
 			}
 		}
 	},

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

@@ -7,11 +7,19 @@ import { readFileSync, readdirSync, statSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import { z } from 'zod';
+import { ErrorCode } from '../../../errors';
 
 const optionsSchema = z.object({
 	file: z.string().optional().describe('File containing the public key'),
 });
 
+const SSHAddResponseSchema = z.object({
+	success: z.boolean().describe('Whether the operation succeeded'),
+	fingerprint: z.string().describe('SSH key fingerprint'),
+	keyType: z.string().describe('SSH key type (e.g., ssh-rsa, ssh-ed25519)'),
+	added: z.number().describe('Number of keys added'),
+});
+
 interface SSHKeyOption {
 	path: string;
 	filename: string;
@@ -107,15 +115,24 @@ export const addCommand = createSubcommand({
 	name: 'add',
 	aliases: ['create'],
 	description: 'Add an SSH public key to your account (reads from file or stdin)',
+	tags: ['mutating', 'creates-resource', 'slow', 'requires-auth'],
+	idempotent: false,
 	requires: { apiClient: true, auth: true },
+	examples: [
+		getCommand('auth ssh add'),
+		getCommand('auth ssh add --file ~/.ssh/id_ed25519.pub'),
+		getCommand('auth ssh add --file ./deploy_key.pub'),
+		'cat ~/.ssh/id_rsa.pub | ' + getCommand('auth ssh add'),
+	],
 	schema: {
 		options: optionsSchema,
+		response: SSHAddResponseSchema,
 	},
 	async handler(ctx) {
 		const { logger, apiClient, opts } = ctx;
 
 		if (!apiClient) {
-			logger.fatal('API client is not available');
+			logger.fatal('API client is not available', ErrorCode.INTERNAL_ERROR);
 		}
 
 		try {
@@ -254,9 +271,9 @@ export const addCommand = createSubcommand({
 		} catch (error) {
 			logger.trace(error);
 			if (error instanceof Error) {
-				logger.fatal(`Failed to add SSH key: ${error.message}`);
+				logger.fatal(`Failed to add SSH key: ${error.message}`, ErrorCode.API_ERROR);
 			} else {
-				logger.fatal('Failed to add SSH key');
+				logger.fatal('Failed to add SSH key', ErrorCode.API_ERROR);
 			}
 		}
 	},

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

@@ -3,12 +3,29 @@ import { removeSSHKey, listSSHKeys } from './api';
 import * as tui from '../../../tui';
 import enquirer from 'enquirer';
 import { z } from 'zod';
+import { isExplainMode, isDryRunMode, outputExplain, outputDryRun } from '../../../explain';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+
+const SSHDeleteResponseSchema = z.object({
+	success: z.boolean().describe('Whether the operation succeeded'),
+	removed: z.number().describe('Number of keys removed'),
+	fingerprints: z.array(z.string()).describe('Fingerprints of removed keys'),
+});
 
 export const deleteCommand = createSubcommand({
 	name: 'delete',
 	aliases: ['rm', 'del', 'remove'],
 	description: 'Delete an SSH key from your account',
+	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth'],
 	requires: { apiClient: true, auth: true },
+	idempotent: false,
+	examples: [
+		getCommand('auth ssh delete'),
+		getCommand('auth ssh delete <fingerprint>'),
+		getCommand('--explain auth ssh delete abc123'),
+		getCommand('--dry-run auth ssh delete abc123'),
+	],
 	schema: {
 		args: z.object({
 			fingerprints: z.array(z.string()).optional().describe('SSH key fingerprint(s) to remove'),
@@ -16,12 +33,13 @@ export const deleteCommand = createSubcommand({
 		options: z.object({
 			confirm: z.boolean().default(true).describe('prompt for confirmation before deletion'),
 		}),
+		response: SSHDeleteResponseSchema,
 	},
 	async handler(ctx) {
-		const { logger, apiClient, args, opts } = ctx;
+		const { logger, apiClient, args, opts, options } = ctx;
 
 		if (!apiClient) {
-			logger.fatal('API client is not available');
+			logger.fatal('API client is not available', ErrorCode.INTERNAL_ERROR);
 		}
 
 		const shouldConfirm = process.stdin.isTTY ? opts.confirm : false;
@@ -67,6 +85,22 @@ export const deleteCommand = createSubcommand({
 				}
 			}
 
+			// If in explain mode, show what would happen
+			if (isExplainMode(options)) {
+				outputExplain(
+					{
+						command: 'auth ssh delete',
+						description: 'Delete SSH keys from your account',
+						steps: fingerprintsToRemove.map((fp) => ({
+							action: `Remove SSH key with fingerprint: ${fp}`,
+						})),
+						warnings: ['This action cannot be undone'],
+					},
+					options
+				);
+				return;
+			}
+
 			if (shouldConfirm) {
 				tui.newline();
 				const confirmed = await tui.confirm(
@@ -80,6 +114,19 @@ export const deleteCommand = createSubcommand({
 				}
 			}
 
+			// Handle dry-run mode
+			if (isDryRunMode(options)) {
+				for (const fingerprint of fingerprintsToRemove) {
+					outputDryRun(`Would remove SSH key: ${fingerprint}`, options);
+				}
+				tui.newline();
+				tui.info(
+					`[DRY RUN] Would remove ${fingerprintsToRemove.length} SSH key${fingerprintsToRemove.length > 1 ? 's' : ''}`
+				);
+				return;
+			}
+
+			// Actually execute the deletion
 			for (const fingerprint of fingerprintsToRemove) {
 				await tui.spinner(`Removing SSH key ${fingerprint}...`, () =>
 					removeSSHKey(apiClient, fingerprint)
@@ -90,12 +137,18 @@ export const deleteCommand = createSubcommand({
 			tui.success(
 				`Removed ${fingerprintsToRemove.length} SSH key${fingerprintsToRemove.length > 1 ? 's' : ''}`
 			);
+
+			return {
+				success: true,
+				removed: fingerprintsToRemove.length,
+				fingerprints: fingerprintsToRemove,
+			};
 		} catch (error) {
 			logger.trace(error);
 			if (error instanceof Error) {
-				logger.fatal(`Failed to remove SSH key: ${error.message}`);
+				logger.fatal(`Failed to remove SSH key: ${error.message}`, ErrorCode.API_ERROR);
 			} else {
-				logger.fatal('Failed to remove SSH key');
+				logger.fatal('Failed to remove SSH key', ErrorCode.API_ERROR);
 			}
 		}
 	},

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

@@ -1,10 +1,11 @@
-import type { SubcommandDefinition } from '../../../types';
+import { createCommand } from '../../../types';
 import { listCommand } from './list';
 import { addCommand } from './add';
 import { deleteCommand } from './delete';
 
-export const sshSubcommand: SubcommandDefinition = {
+export const sshSubcommand = createCommand({
 	name: 'ssh',
 	description: 'Manage SSH keys',
+	tags: ['fast', 'requires-auth'],
 	subcommands: [listCommand, addCommand, deleteCommand],
-};
+});

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

@@ -1,68 +1,79 @@
 import { createSubcommand } from '../../../types';
 import { listSSHKeys } from './api';
 import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
 import { z } from 'zod';
-import { Table } from 'console-table-printer';
+
+const SSHListResponseSchema = z.array(
+	z.object({
+		id: z.string().describe('SSH key ID'),
+		fingerprint: z.string().describe('SSH key fingerprint'),
+		keyType: z.string().describe('SSH key type (e.g., ssh-rsa, ssh-ed25519)'),
+		comment: z.string().optional().describe('SSH key comment'),
+		createdAt: z.string().optional().describe('Creation timestamp'),
+	})
+);
 
 export const listCommand = createSubcommand({
 	name: 'list',
 	aliases: ['ls'],
 	description: 'List all SSH keys on your account',
+	tags: ['read-only', 'fast', 'requires-auth'],
 	requires: { apiClient: true, auth: true },
+	idempotent: true,
+	examples: [
+		getCommand('auth ssh list'),
+		getCommand('auth ssh ls'),
+		getCommand('--json auth ssh list'),
+	],
 	schema: {
-		options: z.object({
-			format: z.enum(['text', 'json']).default('text').describe('output format'),
-		}),
+		response: SSHListResponseSchema,
 	},
 	async handler(ctx) {
-		const { logger, apiClient, opts } = ctx;
-		const format = opts.format;
+		const { logger, apiClient, options } = ctx;
 
 		if (!apiClient) {
-			logger.fatal('API client is not available');
+			logger.fatal('API client is not available', ErrorCode.INTERNAL_ERROR);
 		}
 
 		try {
 			const keys = await tui.spinner('Fetching SSH keys...', () => listSSHKeys(apiClient));
 
-			if (format === 'json') {
+			if (options.json) {
 				console.log(JSON.stringify(keys, null, 2));
-				return;
+				return keys;
 			}
 
 			tui.newline();
 
 			if (keys.length === 0) {
 				console.log('No SSH keys found');
-				return;
+				return [];
 			}
 
 			console.log(tui.bold('SSH Keys:'));
 			tui.newline();
 
-			const table = new Table({
-				columns: [
-					{ name: 'TYPE', alignment: 'left' },
-					{ name: 'FINGERPRINT', alignment: 'left' },
-					{ name: 'COMMENT', alignment: 'left' },
-				],
-			});
+			const tableData = keys.map((key) => ({
+				TYPE: key.keyType,
+				FINGERPRINT: key.fingerprint,
+				COMMENT: key.comment || tui.muted('(no comment)'),
+			}));
 
-			for (const key of keys) {
-				table.addRow({
-					TYPE: key.keyType,
-					FINGERPRINT: key.fingerprint,
-					COMMENT: key.comment || tui.muted('(no comment)'),
-				});
-			}
-			table.printTable();
+			tui.table(tableData, [
+				{ name: 'TYPE', alignment: 'left' },
+				{ name: 'FINGERPRINT', alignment: 'left' },
+				{ name: 'COMMENT', alignment: 'left' },
+			]);
 
+			return keys;
 		} catch (error) {
 			logger.trace(error);
 			if (error instanceof Error) {
-				logger.fatal(`Failed to list SSH keys: ${error.message}`);
+				logger.fatal(`Failed to list SSH keys: ${error.message}`, ErrorCode.API_ERROR);
 			} else {
-				logger.fatal('Failed to list SSH keys');
+				logger.fatal('Failed to list SSH keys', ErrorCode.API_ERROR);
 			}
 		}
 	},

package/src/cmd/auth/whoami.ts

@@ -1,23 +1,36 @@
-import { z } from 'zod';
 import { createSubcommand } from '../../types';
 import * as tui from '../../tui';
 import { whoami } from '@agentuity/server';
+import { getCommand } from '../../command-prefix';
+import { z } from 'zod';
+
+const WhoamiResponseSchema = z.object({
+	userId: z.string().describe('Unique user identifier'),
+	firstName: z.string().describe('User first name'),
+	lastName: z.string().describe('User last name'),
+	organizations: z
+		.array(
+			z.object({
+				id: z.string().describe('Organization ID'),
+				name: z.string().describe('Organization name'),
+			})
+		)
+		.describe('Organizations the user belongs to'),
+});
 
 export const whoamiCommand = createSubcommand({
 	name: 'whoami',
 	description: 'Display information about the currently authenticated user',
+	tags: ['read-only', 'fast', 'requires-auth'],
 	requires: { auth: true, apiClient: true },
+	idempotent: true,
 	schema: {
-		options: z.object({
-			format: z
-				.enum(['json', 'table'])
-				.optional()
-				.describe('the output format: json, table (default)'),
-		}),
+		response: WhoamiResponseSchema,
 	},
+	examples: [getCommand('auth whoami'), getCommand('--json auth whoami')],
 
 	async handler(ctx) {
-		const { apiClient, opts, auth } = ctx;
+		const { apiClient, auth, options } = ctx;
 
 		if (!apiClient) {
 			throw new Error(
@@ -33,19 +46,15 @@ export const whoamiCommand = createSubcommand({
 			},
 		});
 
-		if (opts?.format === 'json') {
-			console.log(
-				JSON.stringify(
-					{
-						userId: auth?.userId,
-						firstName: user.firstName,
-						lastName: user.lastName,
-						organizations: user.organizations,
-					},
-					null,
-					2
-				)
-			);
+		const result = {
+			userId: auth?.userId || '',
+			firstName: user.firstName,
+			lastName: user.lastName,
+			organizations: user.organizations,
+		};
+
+		if (options.json) {
+			console.log(JSON.stringify(result, null, 2));
 		} else {
 			const fullName = `${user.firstName} ${user.lastName}`;
 
@@ -65,5 +74,7 @@ export const whoamiCommand = createSubcommand({
 			}
 			tui.newline();
 		}
+
+		return result;
 	},
 });

package/src/cmd/bundle/ast.test.ts

@@ -278,8 +278,8 @@ describe('parseEvalMetadata', () => {
 				TEST_DEPLOYMENT_ID
 			);
 
-			expect(result).toHaveLength(1);
-			expect(result[0].name).toBe('non-exported-eval');
+			// Non-exported evals should not be included in metadata
+			expect(result).toHaveLength(0);
 		});
 	});
 

package/src/cmd/bundle/ast.ts

@@ -116,6 +116,10 @@ function hashSHA1(...val: string[]): string {
 	return hasher.digest().toHex();
 }
 
+export function getDevmodeDeploymentId(projectId: string, endpointId: string): string {
+	return `devmode_${hashSHA1(projectId, endpointId)}`;
+}
+
 function getAgentId(
 	projectId: string,
 	deploymentId: string,
@@ -147,31 +151,55 @@ function generateRouteId(
 	return `route_${hashSHA1(projectId, deploymentId, type, method, filename, path, version)}`;
 }
 
+function generateStableAgentId(projectId: string, name: string): string {
+	return `agentid_${hashSHA1(projectId, name)}`.substring(0, 64);
+}
+
+function generateStableEvalId(projectId: string, agentId: string, name: string): string {
+	return `evalid_${hashSHA1(projectId, agentId, name)}`.substring(0, 64);
+}
+
 type AcornParseResultType = ReturnType<typeof acornLoose.parse>;
 
 function augmentAgentMetadataNode(
+	projectId: string,
 	id: string,
 	name: string,
 	rel: string,
 	version: string,
 	ast: AcornParseResultType,
 	propvalue: ASTObjectExpression,
-	_filename: string
+	filename: string
 ): [string, Map<string, string>] {
 	const metadata = parseObjectExpressionToMap(propvalue);
 	if (!metadata.has('name')) {
-		metadata.set('name', name);
-		propvalue.properties.push(createObjectPropertyNode('name', name));
+		const location = ast.loc?.start ? ` on line ${ast.loc.start}` : '';
+		throw new Error(
+			`missing required metadata.name in ${filename}${location}. This Agent should have a unique and human readable name for this project.`
+		);
 	}
+	if (metadata.has('identifier') && name !== metadata.get('identifier')) {
+		const location = ast.loc?.start ? ` on line ${ast.loc.start}` : '';
+		throw new Error(
+			`metadata.identifier (${metadata.get('identifier')}) in ${filename}${location} is mismatched (${name}). This is an internal error.`
+		);
+	}
+	const descriptionNode = propvalue.properties.find((x) => x.key.name === 'description')?.value;
+	const description = descriptionNode ? (descriptionNode as ASTLiteral).value : '';
+	const agentId = generateStableAgentId(projectId, name);
 	metadata.set('version', version);
 	metadata.set('identifier', name);
 	metadata.set('filename', rel);
 	metadata.set('id', id);
+	metadata.set('agentId', agentId);
+	metadata.set('description', description);
 	propvalue.properties.push(
 		createObjectPropertyNode('id', id),
+		createObjectPropertyNode('agentId', agentId),
 		createObjectPropertyNode('version', version),
 		createObjectPropertyNode('identifier', name),
-		createObjectPropertyNode('filename', rel)
+		createObjectPropertyNode('filename', rel),
+		createObjectPropertyNode('description', description)
 	);
 
 	const newsource = generate(ast);
@@ -222,14 +250,29 @@ function setLiteralValue(literal: ASTLiteral, value: string) {
 }
 
 function augmentEvalMetadataNode(
+	projectId: string,
+	agentId: string,
 	id: string,
 	name: string,
 	rel: string,
 	version: string,
-	identifier: string,
-	metadataObj: ASTObjectExpression
+	_ast: AcornParseResultType,
+	metadataObj: ASTObjectExpression,
+	_filename: string
 ): void {
-	// Check if id, version, identifier, filename already exist
+	const metadata = parseObjectExpressionToMap(metadataObj);
+	// Name can come from metadata.name or variable name (already resolved in caller)
+	// If metadata doesn't have name, we'll add it from the resolved name
+	if (!metadata.has('name')) {
+		metadataObj.properties.push(createObjectPropertyNode('name', name));
+	}
+	const descriptionNode = metadataObj.properties.find((x) => x.key.name === 'description')?.value;
+	const description = descriptionNode ? (descriptionNode as ASTLiteral).value : '';
+	const effectiveAgentId = agentId || '';
+	const _evalId = getEvalId(projectId, effectiveAgentId, rel, name, version); // Deployment-specific ID (not used, kept for potential future use)
+	const stableEvalId = generateStableEvalId(projectId, effectiveAgentId, name);
+
+	// Check if id, version, identifier, filename, evalId already exist
 	const existingKeys = new Set<string>();
 	for (const prop of metadataObj.properties) {
 		if (prop.key.type === 'Identifier') {
@@ -266,12 +309,12 @@ function augmentEvalMetadataNode(
 	}
 
 	if (!existingKeys.has('identifier')) {
-		metadataObj.properties.push(createObjectPropertyNode('identifier', identifier));
+		metadataObj.properties.push(createObjectPropertyNode('identifier', name));
 	} else {
 		for (const prop of metadataObj.properties) {
 			if (prop.key.type === 'Identifier' && prop.key.name === 'identifier') {
 				if (prop.value.type === 'Literal') {
-					setLiteralValue(prop.value as ASTLiteral, identifier);
+					setLiteralValue(prop.value as ASTLiteral, name);
 				}
 				break;
 			}
@@ -290,6 +333,32 @@ function augmentEvalMetadataNode(
 			}
 		}
 	}
+
+	if (!existingKeys.has('evalId')) {
+		metadataObj.properties.push(createObjectPropertyNode('evalId', stableEvalId));
+	} else {
+		for (const prop of metadataObj.properties) {
+			if (prop.key.type === 'Identifier' && prop.key.name === 'evalId') {
+				if (prop.value.type === 'Literal') {
+					setLiteralValue(prop.value as ASTLiteral, stableEvalId);
+				}
+				break;
+			}
+		}
+	}
+
+	if (!existingKeys.has('description')) {
+		metadataObj.properties.push(createObjectPropertyNode('description', description));
+	} else {
+		for (const prop of metadataObj.properties) {
+			if (prop.key.type === 'Identifier' && prop.key.name === 'description') {
+				if (prop.value.type === 'Literal') {
+					setLiteralValue(prop.value as ASTLiteral, description);
+				}
+				break;
+			}
+		}
+	}
 }
 
 export function parseEvalMetadata(
@@ -297,7 +366,8 @@ export function parseEvalMetadata(
 	filename: string,
 	contents: string,
 	projectId: string,
-	deploymentId: string
+	deploymentId: string,
+	agentId?: string
 ): [
 	string,
 	Array<{
@@ -306,6 +376,7 @@ export function parseEvalMetadata(
 		version: string;
 		identifier: string;
 		name: string;
+		evalId: string;
 		description?: string;
 	}>,
 ] {
@@ -319,8 +390,6 @@ export function parseEvalMetadata(
 	logger.trace(`Parsing evals from ${filename}`);
 	const ast = acornLoose.parse(contents, { ecmaVersion: 'latest', sourceType: 'module' });
 	const rel = relative(rootDir, filename);
-	const dir = dirname(filename);
-	const identifier = basename(dir);
 	const version = hash(contents);
 	const evals: Array<{
 		filename: string;
@@ -328,17 +397,16 @@ export function parseEvalMetadata(
 		version: string;
 		identifier: string;
 		name: string;
+		evalId: string;
 		description?: string;
 	}> = [];
 
-	// Find all agent.createEval() calls
+	// Find all exported agent.createEval() calls
 	for (const body of ast.body) {
 		let variableDeclaration: { declarations: Array<ASTVariableDeclarator> } | undefined;
 
-		// Handle both direct VariableDeclaration and ExportNamedDeclaration
-		if (body.type === 'VariableDeclaration') {
-			variableDeclaration = body as { declarations: Array<ASTVariableDeclarator> };
-		} else if (body.type === 'ExportNamedDeclaration') {
+		// Only process exported VariableDeclarations
+		if (body.type === 'ExportNamedDeclaration') {
 			const exportDecl = body as {
 				declaration?: { type: string; declarations?: Array<ASTVariableDeclarator> };
 			};
@@ -427,14 +495,31 @@ export function parseEvalMetadata(
 									);
 
 									// Inject metadata into AST if metadata object exists
+									let stableEvalId: string;
+									const effectiveAgentId = agentId || '';
 									if (metadataObj) {
 										augmentEvalMetadataNode(
+											projectId,
+											effectiveAgentId,
 											evalId,
 											finalName,
 											rel,
 											version,
-											identifier,
-											metadataObj
+											ast,
+											metadataObj,
+											filename
+										);
+										// Extract evalId from metadata after augmentation
+										const metadata = parseObjectExpressionToMap(metadataObj);
+										stableEvalId =
+											metadata.get('evalId') ||
+											generateStableEvalId(projectId, effectiveAgentId, finalName);
+									} else {
+										// If no metadata object, generate stable evalId
+										stableEvalId = generateStableEvalId(
+											projectId,
+											effectiveAgentId,
+											finalName
 										);
 									}
 
@@ -442,8 +527,9 @@ export function parseEvalMetadata(
 										filename: rel,
 										id: evalId,
 										version,
-										identifier,
+										identifier: finalName,
 										name: finalName,
+										evalId: stableEvalId,
 										description: evalDescription,
 									});
 								}
@@ -508,6 +594,7 @@ export async function parseAgentMetadata(
 						for (const prop of callargexp.properties) {
 							if (prop.key.type === 'Identifier' && prop.key.name === 'metadata') {
 								result = augmentAgentMetadataNode(
+									projectId,
 									id,
 									name,
 									rel,
@@ -562,6 +649,7 @@ export async function parseAgentMetadata(
 												prop.key.name === 'metadata'
 											) {
 												result = augmentAgentMetadataNode(
+													projectId,
 													id,
 													name,
 													rel,
@@ -615,14 +703,16 @@ export async function parseAgentMetadata(
 	if (await evalsFile.exists()) {
 		logger.trace(`Found evals file at ${evalsPath}, parsing...`);
 		const evalsSource = await evalsFile.text();
-		const transpiler = new Bun.Transpiler({ loader: 'ts' });
+		const transpiler = new Bun.Transpiler({ loader: 'ts', target: 'bun' });
 		const evalsContents = transpiler.transformSync(evalsSource);
+		const agentId = result[1].get('agentId') || '';
 		const [, evals] = parseEvalMetadata(
 			rootDir,
 			evalsPath,
 			evalsContents,
 			projectId,
-			deploymentId
+			deploymentId,
+			agentId
 		);
 		if (evals.length > 0) {
 			logger.trace(`Adding ${evals.length} eval(s) to agent metadata for ${name}`);