@vibescope/mcp-server 0.2.0 → 0.2.2

package/src/handlers/deployment.ts

@@ -17,34 +17,134 @@
 import type { Handler, HandlerRegistry } from './types.js';
 import {
 	ValidationError,
-	validateRequired,
-	validateUUID,
-	validateEnvironment,
+	parseArgs,
+	uuidValidator,
+	createEnumValidator,
 } from '../validators.js';
 import { getApiClient } from '../api-client.js';
 
-export const requestDeployment: Handler = async (args, ctx) => {
-	const { project_id, environment = 'production', version_bump = 'patch', notes, git_ref } = args as {
-		project_id: string;
-		environment?: string;
-		version_bump?: 'patch' | 'minor' | 'major';
-		notes?: string;
-		git_ref?: string;
-	};
+const ENVIRONMENTS = ['development', 'staging', 'production'] as const;
+const VERSION_BUMPS = ['patch', 'minor', 'major'] as const;
+const REQUIREMENT_TYPES = ['migration', 'env_var', 'config', 'manual', 'breaking_change', 'agent_task'] as const;
+const REQUIREMENT_STAGES = ['preparation', 'deployment', 'verification'] as const;
+const REQUIREMENT_STATUSES = ['pending', 'completed', 'converted_to_task', 'all'] as const;
+const SCHEDULE_TYPES = ['once', 'hourly', 'daily', 'weekly', 'monthly'] as const;
 
-	const { session } = ctx;
+type Environment = typeof ENVIRONMENTS[number];
+type VersionBump = typeof VERSION_BUMPS[number];
+type RequirementType = typeof REQUIREMENT_TYPES[number];
+type RequirementStage = typeof REQUIREMENT_STAGES[number];
+type RequirementStatus = typeof REQUIREMENT_STATUSES[number];
+type ScheduleType = typeof SCHEDULE_TYPES[number];
+
+// ============================================================================
+// Argument Schemas
+// ============================================================================
 
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-	validateEnvironment(environment);
+const requestDeploymentSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	environment: { type: 'string' as const, default: 'production', validate: createEnumValidator(ENVIRONMENTS) },
+	version_bump: { type: 'string' as const, default: 'patch', validate: createEnumValidator(VERSION_BUMPS) },
+	notes: { type: 'string' as const },
+	git_ref: { type: 'string' as const },
+};
 
-	if (version_bump && !['patch', 'minor', 'major'].includes(version_bump)) {
-		throw new ValidationError('Invalid version_bump value', {
-			field: 'version_bump',
-			validValues: ['patch', 'minor', 'major'],
-			hint: 'Must be one of: patch, minor, major',
-		});
-	}
+const claimDeploymentValidationSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const reportValidationSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	build_passed: { type: 'boolean' as const, required: true as const },
+	tests_passed: { type: 'boolean' as const },
+	error_message: { type: 'string' as const },
+};
+
+const checkDeploymentStatusSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const startDeploymentSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const completeDeploymentSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	success: { type: 'boolean' as const, required: true as const },
+	summary: { type: 'string' as const },
+};
+
+const cancelDeploymentSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	reason: { type: 'string' as const },
+};
+
+const addDeploymentRequirementSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	type: { type: 'string' as const, required: true as const, validate: createEnumValidator(REQUIREMENT_TYPES) },
+	title: { type: 'string' as const, required: true as const },
+	description: { type: 'string' as const },
+	file_path: { type: 'string' as const },
+	stage: { type: 'string' as const, default: 'preparation', validate: createEnumValidator(REQUIREMENT_STAGES) },
+	blocking: { type: 'boolean' as const, default: false },
+	recurring: { type: 'boolean' as const, default: false },
+};
+
+const completeDeploymentRequirementSchema = {
+	requirement_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const getDeploymentRequirementsSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	status: { type: 'string' as const, default: 'pending', validate: createEnumValidator(REQUIREMENT_STATUSES) },
+	stage: { type: 'string' as const, validate: createEnumValidator([...REQUIREMENT_STAGES, 'all'] as const) },
+};
+
+const scheduleDeploymentSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	environment: { type: 'string' as const, default: 'production', validate: createEnumValidator(ENVIRONMENTS) },
+	version_bump: { type: 'string' as const, default: 'patch', validate: createEnumValidator(VERSION_BUMPS) },
+	schedule_type: { type: 'string' as const, default: 'once', validate: createEnumValidator(SCHEDULE_TYPES) },
+	scheduled_at: { type: 'string' as const, required: true as const },
+	auto_trigger: { type: 'boolean' as const, default: true },
+	hours_interval: { type: 'number' as const, default: 1 },
+	notes: { type: 'string' as const },
+	git_ref: { type: 'string' as const },
+};
+
+const getScheduledDeploymentsSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	include_disabled: { type: 'boolean' as const, default: false },
+};
+
+const updateScheduledDeploymentSchema = {
+	schedule_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	environment: { type: 'string' as const, validate: createEnumValidator(ENVIRONMENTS) },
+	version_bump: { type: 'string' as const, validate: createEnumValidator(VERSION_BUMPS) },
+	schedule_type: { type: 'string' as const, validate: createEnumValidator(SCHEDULE_TYPES) },
+	scheduled_at: { type: 'string' as const },
+	auto_trigger: { type: 'boolean' as const },
+	hours_interval: { type: 'number' as const },
+	enabled: { type: 'boolean' as const },
+	notes: { type: 'string' as const },
+	git_ref: { type: 'string' as const },
+};
+
+const deleteScheduledDeploymentSchema = {
+	schedule_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const triggerScheduledDeploymentSchema = {
+	schedule_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const checkDueDeploymentsSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+export const requestDeployment: Handler = async (args, ctx) => {
+	const { project_id, environment, version_bump, notes, git_ref } = parseArgs(args, requestDeploymentSchema);
+	const { session } = ctx;
 
 	const apiClient = getApiClient();
 	const response = await apiClient.requestDeployment(project_id, {
@@ -55,19 +155,16 @@ export const requestDeployment: Handler = async (args, ctx) => {
 	});
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to request deployment');
+		return { result: { error: response.error || 'Failed to request deployment' }, isError: true };
 	}
 
 	return { result: response.data };
 };
 
 export const claimDeploymentValidation: Handler = async (args, ctx) => {
-	const { project_id } = args as { project_id: string };
+	const { project_id } = parseArgs(args, claimDeploymentValidationSchema);
 	const { session } = ctx;
 
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-
 	const apiClient = getApiClient();
 	const response = await apiClient.claimDeploymentValidation(
 		project_id,
@@ -75,31 +172,16 @@ export const claimDeploymentValidation: Handler = async (args, ctx) => {
 	);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to claim deployment validation');
+		return { result: { error: response.error || 'Failed to claim deployment validation' }, isError: true };
 	}
 
 	return { result: response.data };
 };
 
 export const reportValidation: Handler = async (args, ctx) => {
-	const { project_id, build_passed, tests_passed, error_message } = args as {
-		project_id: string;
-		build_passed: boolean;
-		tests_passed?: boolean;
-		error_message?: string;
-	};
-
+	const { project_id, build_passed, tests_passed, error_message } = parseArgs(args, reportValidationSchema);
 	const { session } = ctx;
 
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-	if (build_passed === undefined) {
-		throw new ValidationError('build_passed is required', {
-			field: 'build_passed',
-			hint: 'Set to true if the build succeeded, false otherwise',
-		});
-	}
-
 	const apiClient = getApiClient();
 	const response = await apiClient.reportValidation(project_id, {
 		build_passed,
@@ -108,35 +190,29 @@ export const reportValidation: Handler = async (args, ctx) => {
 	});
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to report validation');
+		return { result: { error: response.error || 'Failed to report validation' }, isError: true };
 	}
 
 	return { result: response.data };
 };
 
 export const checkDeploymentStatus: Handler = async (args, ctx) => {
-	const { project_id } = args as { project_id: string };
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
+	const { project_id } = parseArgs(args, checkDeploymentStatusSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.checkDeploymentStatus(project_id);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to check deployment status');
+		return { result: { error: response.error || 'Failed to check deployment status' }, isError: true };
 	}
 
 	return { result: response.data };
 };
 
 export const startDeployment: Handler = async (args, ctx) => {
-	const { project_id } = args as { project_id: string };
+	const { project_id } = parseArgs(args, startDeploymentSchema);
 	const { session } = ctx;
 
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-
 	const apiClient = getApiClient();
 	const response = await apiClient.startDeployment(
 		project_id,
@@ -144,30 +220,16 @@ export const startDeployment: Handler = async (args, ctx) => {
 	);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to start deployment');
+		return { result: { error: response.error || 'Failed to start deployment' }, isError: true };
 	}
 
 	return { result: response.data };
 };
 
 export const completeDeployment: Handler = async (args, ctx) => {
-	const { project_id, success, summary } = args as {
-		project_id: string;
-		success: boolean;
-		summary?: string;
-	};
-
+	const { project_id, success, summary } = parseArgs(args, completeDeploymentSchema);
 	const { session } = ctx;
 
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-	if (success === undefined) {
-		throw new ValidationError('success is required', {
-			field: 'success',
-			hint: 'Set to true if deployment succeeded, false otherwise',
-		});
-	}
-
 	const apiClient = getApiClient();
 	const response = await apiClient.completeDeployment(project_id, {
 		success,
@@ -175,54 +237,27 @@ export const completeDeployment: Handler = async (args, ctx) => {
 	});
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to complete deployment');
+		return { result: { error: response.error || 'Failed to complete deployment' }, isError: true };
 	}
 
 	return { result: response.data };
 };
 
 export const cancelDeployment: Handler = async (args, ctx) => {
-	const { project_id, reason } = args as { project_id: string; reason?: string };
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
+	const { project_id, reason } = parseArgs(args, cancelDeploymentSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.cancelDeployment(project_id, reason);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to cancel deployment');
+		return { result: { error: response.error || 'Failed to cancel deployment' }, isError: true };
 	}
 
 	return { result: response.data };
 };
 
 export const addDeploymentRequirement: Handler = async (args, ctx) => {
-	const { project_id, type, title, description, file_path, stage = 'preparation', blocking = false, recurring = false } = args as {
-		project_id: string;
-		type: string;
-		title: string;
-		description?: string;
-		file_path?: string;
-		stage?: string;
-		blocking?: boolean;
-		recurring?: boolean;
-	};
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-	validateRequired(type, 'type');
-	validateRequired(title, 'title');
-
-	const validTypes = ['migration', 'env_var', 'config', 'manual', 'breaking_change', 'agent_task'];
-	if (!validTypes.includes(type)) {
-		throw new ValidationError(`type must be one of: ${validTypes.join(', ')}`);
-	}
-
-	const validStages = ['preparation', 'deployment', 'verification'];
-	if (!validStages.includes(stage)) {
-		throw new ValidationError(`stage must be one of: ${validStages.join(', ')}`);
-	}
+	const { project_id, type, title, description, file_path, stage, blocking, recurring } = parseArgs(args, addDeploymentRequirementSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.addDeploymentRequirement(project_id, {
@@ -236,37 +271,27 @@ export const addDeploymentRequirement: Handler = async (args, ctx) => {
 	});
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to add deployment requirement');
+		return { result: { error: response.error || 'Failed to add deployment requirement' }, isError: true };
 	}
 
 	return { result: response.data };
 };
 
 export const completeDeploymentRequirement: Handler = async (args, ctx) => {
-	const { requirement_id } = args as { requirement_id: string };
-
-	validateRequired(requirement_id, 'requirement_id');
-	validateUUID(requirement_id, 'requirement_id');
+	const { requirement_id } = parseArgs(args, completeDeploymentRequirementSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.completeDeploymentRequirement(requirement_id);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to complete deployment requirement');
+		return { result: { error: response.error || 'Failed to complete deployment requirement' }, isError: true };
 	}
 
 	return { result: response.data };
 };
 
 export const getDeploymentRequirements: Handler = async (args, ctx) => {
-	const { project_id, status = 'pending', stage } = args as {
-		project_id: string;
-		status?: string;
-		stage?: string;
-	};
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
+	const { project_id, status, stage } = parseArgs(args, getDeploymentRequirementsSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.getDeploymentRequirements(project_id, {
@@ -275,7 +300,7 @@ export const getDeploymentRequirements: Handler = async (args, ctx) => {
 	});
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to get deployment requirements');
+		return { result: { error: response.error || 'Failed to get deployment requirements' }, isError: true };
 	}
 
 	return { result: response.data };
@@ -288,42 +313,15 @@ export const getDeploymentRequirements: Handler = async (args, ctx) => {
 export const scheduleDeployment: Handler = async (args, ctx) => {
 	const {
 		project_id,
-		environment = 'production',
-		version_bump = 'patch',
-		schedule_type = 'once',
+		environment,
+		version_bump,
+		schedule_type,
 		scheduled_at,
-		auto_trigger = true,
+		auto_trigger,
+		hours_interval,
 		notes,
 		git_ref,
-	} = args as {
-		project_id: string;
-		environment?: string;
-		version_bump?: string;
-		schedule_type?: string;
-		scheduled_at: string;
-		auto_trigger?: boolean;
-		notes?: string;
-		git_ref?: string;
-	};
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-	validateRequired(scheduled_at, 'scheduled_at');
-	validateEnvironment(environment);
-
-	if (!['patch', 'minor', 'major'].includes(version_bump)) {
-		throw new ValidationError('Invalid version_bump value', {
-			field: 'version_bump',
-			validValues: ['patch', 'minor', 'major'],
-		});
-	}
-
-	if (!['once', 'daily', 'weekly', 'monthly'].includes(schedule_type)) {
-		throw new ValidationError('Invalid schedule_type value', {
-			field: 'schedule_type',
-			validValues: ['once', 'daily', 'weekly', 'monthly'],
-		});
-	}
+	} = parseArgs(args, scheduleDeploymentSchema);
 
 	// Parse and validate scheduled_at
 	const scheduledDate = new Date(scheduled_at);
@@ -340,38 +338,41 @@ export const scheduleDeployment: Handler = async (args, ctx) => {
 		});
 	}
 
+	// Validate hours_interval for hourly schedule type (default is 1)
+	const hoursInterval = hours_interval ?? 1;
+	if (schedule_type === 'hourly' && (hoursInterval < 1 || hoursInterval > 24)) {
+		throw new ValidationError('hours_interval must be between 1 and 24', {
+			field: 'hours_interval',
+		});
+	}
+
 	const apiClient = getApiClient();
 	const response = await apiClient.scheduleDeployment(project_id, {
 		environment: environment as 'development' | 'staging' | 'production',
 		version_bump: version_bump as 'patch' | 'minor' | 'major',
-		schedule_type: schedule_type as 'once' | 'daily' | 'weekly' | 'monthly',
+		schedule_type: schedule_type as 'once' | 'hourly' | 'daily' | 'weekly' | 'monthly',
 		scheduled_at: scheduledDate.toISOString(),
 		auto_trigger,
+		hours_interval: hoursInterval,
 		notes,
 		git_ref
 	});
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to schedule deployment');
+		return { result: { error: response.error || 'Failed to schedule deployment' }, isError: true };
 	}
 
 	return { result: response.data };
 };
 
 export const getScheduledDeployments: Handler = async (args, ctx) => {
-	const { project_id, include_disabled = false } = args as {
-		project_id: string;
-		include_disabled?: boolean;
-	};
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
+	const { project_id, include_disabled } = parseArgs(args, getScheduledDeploymentsSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.getScheduledDeployments(project_id, include_disabled);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to get scheduled deployments');
+		return { result: { error: response.error || 'Failed to get scheduled deployments' }, isError: true };
 	}
 
 	return { result: response.data };
@@ -385,44 +386,17 @@ export const updateScheduledDeployment: Handler = async (args, ctx) => {
 		schedule_type,
 		scheduled_at,
 		auto_trigger,
+		hours_interval,
 		enabled,
 		notes,
 		git_ref,
-	} = args as {
-		schedule_id: string;
-		environment?: string;
-		version_bump?: string;
-		schedule_type?: string;
-		scheduled_at?: string;
-		auto_trigger?: boolean;
-		enabled?: boolean;
-		notes?: string;
-		git_ref?: string;
-	};
-
-	validateRequired(schedule_id, 'schedule_id');
-	validateUUID(schedule_id, 'schedule_id');
+	} = parseArgs(args, updateScheduledDeploymentSchema);
 
 	const updates: Record<string, unknown> = {};
 
-	if (environment !== undefined) {
-		validateEnvironment(environment);
-		updates.environment = environment;
-	}
-
-	if (version_bump !== undefined) {
-		if (!['patch', 'minor', 'major'].includes(version_bump)) {
-			throw new ValidationError('Invalid version_bump value');
-		}
-		updates.version_bump = version_bump;
-	}
-
-	if (schedule_type !== undefined) {
-		if (!['once', 'daily', 'weekly', 'monthly'].includes(schedule_type)) {
-			throw new ValidationError('Invalid schedule_type value');
-		}
-		updates.schedule_type = schedule_type;
-	}
+	if (environment !== undefined) updates.environment = environment;
+	if (version_bump !== undefined) updates.version_bump = version_bump;
+	if (schedule_type !== undefined) updates.schedule_type = schedule_type;
 
 	if (scheduled_at !== undefined) {
 		const scheduledDate = new Date(scheduled_at);
@@ -433,6 +407,12 @@ export const updateScheduledDeployment: Handler = async (args, ctx) => {
 	}
 
 	if (auto_trigger !== undefined) updates.auto_trigger = auto_trigger;
+	if (hours_interval !== undefined) {
+		if (hours_interval < 1 || hours_interval > 24) {
+			throw new ValidationError('hours_interval must be between 1 and 24');
+		}
+		updates.hours_interval = hours_interval;
+	}
 	if (enabled !== undefined) updates.enabled = enabled;
 	if (notes !== undefined) updates.notes = notes;
 	if (git_ref !== undefined) updates.git_ref = git_ref;
@@ -445,44 +425,39 @@ export const updateScheduledDeployment: Handler = async (args, ctx) => {
 	const response = await apiClient.updateScheduledDeployment(schedule_id, updates as {
 		environment?: 'development' | 'staging' | 'production';
 		version_bump?: 'patch' | 'minor' | 'major';
-		schedule_type?: 'once' | 'daily' | 'weekly' | 'monthly';
+		schedule_type?: 'once' | 'hourly' | 'daily' | 'weekly' | 'monthly';
 		scheduled_at?: string;
 		auto_trigger?: boolean;
+		hours_interval?: number;
 		enabled?: boolean;
 		notes?: string;
 		git_ref?: string;
 	});
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to update scheduled deployment');
+		return { result: { error: response.error || 'Failed to update scheduled deployment' }, isError: true };
 	}
 
 	return { result: response.data };
 };
 
 export const deleteScheduledDeployment: Handler = async (args, ctx) => {
-	const { schedule_id } = args as { schedule_id: string };
-
-	validateRequired(schedule_id, 'schedule_id');
-	validateUUID(schedule_id, 'schedule_id');
+	const { schedule_id } = parseArgs(args, deleteScheduledDeploymentSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.deleteScheduledDeployment(schedule_id);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to delete scheduled deployment');
+		return { result: { error: response.error || 'Failed to delete scheduled deployment' }, isError: true };
 	}
 
 	return { result: response.data };
 };
 
 export const triggerScheduledDeployment: Handler = async (args, ctx) => {
-	const { schedule_id } = args as { schedule_id: string };
+	const { schedule_id } = parseArgs(args, triggerScheduledDeploymentSchema);
 	const { session } = ctx;
 
-	validateRequired(schedule_id, 'schedule_id');
-	validateUUID(schedule_id, 'schedule_id');
-
 	const apiClient = getApiClient();
 	const response = await apiClient.triggerScheduledDeployment(
 		schedule_id,
@@ -490,23 +465,20 @@ export const triggerScheduledDeployment: Handler = async (args, ctx) => {
 	);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to trigger scheduled deployment');
+		return { result: { error: response.error || 'Failed to trigger scheduled deployment' }, isError: true };
 	}
 
 	return { result: response.data };
 };
 
 export const checkDueDeployments: Handler = async (args, ctx) => {
-	const { project_id } = args as { project_id: string };
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
+	const { project_id } = parseArgs(args, checkDueDeploymentsSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.checkDueDeployments(project_id);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to check due deployments');
+		return { result: { error: response.error || 'Failed to check due deployments' }, isError: true };
 	}
 
 	return { result: response.data };

package/src/handlers/discovery.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect } from 'vitest';
 import { discoverTools, getToolInfo } from './discovery.js';
 import { createMockContext } from './__test-utils__.js';
+import { ValidationError } from '../validators.js';
 
 // ============================================================================
 // discoverTools Tests
@@ -113,13 +114,11 @@ describe('discoverTools', () => {
 // ============================================================================
 
 describe('getToolInfo', () => {
-	it('should return error for missing tool_name', async () => {
+	it('should throw ValidationError for missing tool_name', async () => {
 		const ctx = createMockContext();
 
-		const result = await getToolInfo({}, ctx);
-		const res = result.result as { error: string };
-
-		expect(res.error).toBe('tool_name is required');
+		await expect(getToolInfo({}, ctx)).rejects.toThrow(ValidationError);
+		await expect(getToolInfo({}, ctx)).rejects.toThrow('Missing required field: tool_name');
 	});
 
 	it('should return error for unknown tool', async () => {