@vibescope/mcp-server 0.2.9 → 0.3.0

package/src/handlers/cost.test.ts

@@ -1,462 +1,462 @@
-/**
- * Cost Handlers Unit Tests
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import {
-	getCostSummary,
-	getCostAlerts,
-	addCostAlert,
-	updateCostAlert,
-	deleteCostAlert,
-	getTaskCosts,
-} from './cost.js';
-import { createMockContext } from './__test-utils__.js';
-import { mockApiClient } from './__test-setup__.js';
-import { ValidationError } from '../validators.js';
-
-const VALID_UUID = '123e4567-e89b-12d3-a456-426614174000';
-
-describe('Cost Handlers', () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
-	});
-
-	// ============================================================================
-	// getCostSummary
-	// ============================================================================
-
-	describe('getCostSummary', () => {
-		it('should throw ValidationError when project_id is missing', async () => {
-			const ctx = createMockContext();
-
-			await expect(getCostSummary({}, ctx)).rejects.toThrow(ValidationError);
-			await expect(getCostSummary({}, ctx)).rejects.toThrow('Missing required field: project_id');
-		});
-
-		it('should return daily cost summary with totals', async () => {
-			const mockData = [
-				{
-					date: '2025-01-14',
-					session_count: 5,
-					total_tokens: 10000,
-					total_calls: 50,
-					estimated_cost_usd: '0.50',
-				},
-				{
-					date: '2025-01-13',
-					session_count: 3,
-					total_tokens: 6000,
-					total_calls: 30,
-					estimated_cost_usd: '0.30',
-				},
-			];
-			mockApiClient.getCostSummary.mockResolvedValue({
-				ok: true,
-				data: {
-					period: 'daily',
-					summary: mockData,
-					totals: {
-						sessions: 8,
-						tokens: 16000,
-						calls: 80,
-						cost: 0.8,
-					},
-				},
-			});
-			const ctx = createMockContext();
-
-			const result = await getCostSummary({ project_id: VALID_UUID }, ctx);
-
-			expect(result.isError).toBeUndefined();
-			expect(result.result.period).toBe('daily');
-			expect(result.result.summary).toEqual(mockData);
-			expect(result.result.totals).toEqual({
-				sessions: 8,
-				tokens: 16000,
-				calls: 80,
-				cost: 0.8,
-			});
-		});
-
-		it('should handle weekly period', async () => {
-			mockApiClient.getCostSummary.mockResolvedValue({
-				ok: true,
-				data: { period: 'weekly', summary: [], totals: { sessions: 0, tokens: 0, calls: 0, cost: 0 } },
-			});
-			const ctx = createMockContext();
-
-			const result = await getCostSummary(
-				{ project_id: VALID_UUID, period: 'weekly' },
-				ctx
-			);
-
-			expect(result.result.period).toBe('weekly');
-			expect(mockApiClient.getCostSummary).toHaveBeenCalledWith(
-				VALID_UUID,
-				expect.objectContaining({ period: 'weekly' })
-			);
-		});
-
-		it('should handle monthly period', async () => {
-			mockApiClient.getCostSummary.mockResolvedValue({
-				ok: true,
-				data: { period: 'monthly', summary: [], totals: { sessions: 0, tokens: 0, calls: 0, cost: 0 } },
-			});
-			const ctx = createMockContext();
-
-			const result = await getCostSummary(
-				{ project_id: VALID_UUID, period: 'monthly' },
-				ctx
-			);
-
-			expect(result.result.period).toBe('monthly');
-			expect(mockApiClient.getCostSummary).toHaveBeenCalledWith(
-				VALID_UUID,
-				expect.objectContaining({ period: 'monthly' })
-			);
-		});
-
-		it('should return error on API failure', async () => {
-			mockApiClient.getCostSummary.mockResolvedValue({
-				ok: false,
-				error: 'Database error',
-			});
-			const ctx = createMockContext();
-
-			const result = await getCostSummary({ project_id: VALID_UUID }, ctx);
-
-			expect(result.isError).toBe(true);
-			expect(result.result.error).toBe('Database error');
-		});
-	});
-
-	// ============================================================================
-	// getCostAlerts
-	// ============================================================================
-
-	describe('getCostAlerts', () => {
-		it('should return all alerts for user', async () => {
-			const mockAlerts = [
-				{ id: 'alert-1', threshold_amount: 10, threshold_period: 'daily' },
-				{ id: 'alert-2', threshold_amount: 50, threshold_period: 'weekly' },
-			];
-			mockApiClient.getCostAlerts.mockResolvedValue({
-				ok: true,
-				data: { alerts: mockAlerts, count: 2 },
-			});
-			const ctx = createMockContext();
-
-			const result = await getCostAlerts({}, ctx);
-
-			expect(result.result.alerts).toEqual(mockAlerts);
-			expect(result.result.count).toBe(2);
-		});
-
-		it('should call getCostAlerts with no args (project filtering done server-side)', async () => {
-			mockApiClient.getCostAlerts.mockResolvedValue({
-				ok: true,
-				data: { alerts: [], count: 0 },
-			});
-			const ctx = createMockContext();
-
-			await getCostAlerts({ project_id: VALID_UUID }, ctx);
-
-			expect(mockApiClient.getCostAlerts).toHaveBeenCalledWith();
-		});
-
-		it('should return error on API failure', async () => {
-			mockApiClient.getCostAlerts.mockResolvedValue({
-				ok: false,
-				error: 'Query failed',
-			});
-			const ctx = createMockContext();
-
-			const result = await getCostAlerts({}, ctx);
-
-			expect(result.isError).toBe(true);
-			expect(result.result.error).toBe('Query failed');
-		});
-	});
-
-	// ============================================================================
-	// addCostAlert
-	// ============================================================================
-
-	describe('addCostAlert', () => {
-		it('should throw ValidationError when threshold_amount is missing', async () => {
-			const ctx = createMockContext();
-
-			await expect(
-				addCostAlert({ threshold_period: 'daily' }, ctx)
-			).rejects.toThrow(ValidationError);
-			await expect(
-				addCostAlert({ threshold_period: 'daily' }, ctx)
-			).rejects.toThrow('Missing required field: threshold_amount');
-		});
-
-		it('should throw ValidationError when threshold_amount is not positive', async () => {
-			const ctx = createMockContext();
-
-			await expect(
-				addCostAlert({ threshold_amount: -5, threshold_period: 'daily' }, ctx)
-			).rejects.toThrow(ValidationError);
-			await expect(
-				addCostAlert({ threshold_amount: -5, threshold_period: 'daily' }, ctx)
-			).rejects.toThrow('threshold_amount must be a positive number');
-		});
-
-		it('should throw ValidationError when threshold_period is invalid', async () => {
-			const ctx = createMockContext();
-
-			await expect(
-				addCostAlert({ threshold_amount: 10, threshold_period: 'yearly' }, ctx)
-			).rejects.toThrow(ValidationError);
-			await expect(
-				addCostAlert({ threshold_amount: 10, threshold_period: 'yearly' }, ctx)
-			).rejects.toThrow('Invalid threshold_period');
-		});
-
-		it('should create alert successfully', async () => {
-			const mockAlert = {
-				id: 'new-alert',
-				threshold_amount: 10,
-				threshold_period: 'daily',
-				alert_type: 'warning',
-			};
-			mockApiClient.addCostAlert.mockResolvedValue({
-				ok: true,
-				data: { success: true, alert: mockAlert, message: 'Alert created' },
-			});
-			const ctx = createMockContext();
-
-			const result = await addCostAlert(
-				{ threshold_amount: 10, threshold_period: 'daily' },
-				ctx
-			);
-
-			expect(result.result.success).toBe(true);
-			expect(result.result.alert).toEqual(mockAlert);
-			expect(result.result.message).toContain('Alert created');
-		});
-
-		it('should create alert with project_id', async () => {
-			mockApiClient.addCostAlert.mockResolvedValue({
-				ok: true,
-				data: { success: true, alert: { id: 'new-alert' } },
-			});
-			const ctx = createMockContext();
-
-			await addCostAlert(
-				{
-					project_id: VALID_UUID,
-					threshold_amount: 10,
-					threshold_period: 'daily',
-				},
-				ctx
-			);
-
-			expect(mockApiClient.addCostAlert).toHaveBeenCalledWith(
-				expect.objectContaining({
-					project_id: VALID_UUID,
-					threshold_amount: 10,
-					threshold_period: 'daily',
-				})
-			);
-		});
-
-		it('should return error on API failure', async () => {
-			mockApiClient.addCostAlert.mockResolvedValue({
-				ok: false,
-				error: 'Insert failed',
-			});
-			const ctx = createMockContext();
-
-			const result = await addCostAlert(
-				{ threshold_amount: 10, threshold_period: 'daily' },
-				ctx
-			);
-
-			expect(result.isError).toBe(true);
-			expect(result.result.error).toBe('Insert failed');
-		});
-	});
-
-	// ============================================================================
-	// updateCostAlert
-	// ============================================================================
-
-	describe('updateCostAlert', () => {
-		it('should throw ValidationError when alert_id is missing', async () => {
-			const ctx = createMockContext();
-
-			await expect(updateCostAlert({}, ctx)).rejects.toThrow(ValidationError);
-			await expect(updateCostAlert({}, ctx)).rejects.toThrow('Missing required field: alert_id');
-		});
-
-		it('should return error when no updates provided', async () => {
-			const ctx = createMockContext();
-
-			const result = await updateCostAlert({ alert_id: VALID_UUID }, ctx);
-
-			expect(result.isError).toBe(true);
-			expect(result.result.error).toBe('No updates provided');
-		});
-
-		it('should update alert successfully', async () => {
-			const mockUpdatedAlert = {
-				id: VALID_UUID,
-				threshold_amount: 20,
-				threshold_period: 'weekly',
-			};
-			mockApiClient.updateCostAlert.mockResolvedValue({
-				ok: true,
-				data: { success: true, alert: mockUpdatedAlert },
-			});
-			const ctx = createMockContext();
-
-			const result = await updateCostAlert(
-				{ alert_id: VALID_UUID, threshold_amount: 20 },
-				ctx
-			);
-
-			expect(result.result.success).toBe(true);
-			expect(result.result.alert).toEqual(mockUpdatedAlert);
-		});
-
-		it('should update enabled status', async () => {
-			mockApiClient.updateCostAlert.mockResolvedValue({
-				ok: true,
-				data: { success: true, alert: { id: VALID_UUID, enabled: false } },
-			});
-			const ctx = createMockContext();
-
-			await updateCostAlert({ alert_id: VALID_UUID, enabled: false }, ctx);
-
-			expect(mockApiClient.updateCostAlert).toHaveBeenCalledWith(
-				VALID_UUID,
-				expect.objectContaining({ enabled: false })
-			);
-		});
-
-		it('should return error on API failure', async () => {
-			mockApiClient.updateCostAlert.mockResolvedValue({
-				ok: false,
-				error: 'Update failed',
-			});
-			const ctx = createMockContext();
-
-			const result = await updateCostAlert(
-				{ alert_id: VALID_UUID, threshold_amount: 20 },
-				ctx
-			);
-
-			expect(result.isError).toBe(true);
-			expect(result.result.error).toBe('Update failed');
-		});
-	});
-
-	// ============================================================================
-	// deleteCostAlert
-	// ============================================================================
-
-	describe('deleteCostAlert', () => {
-		it('should throw ValidationError when alert_id is missing', async () => {
-			const ctx = createMockContext();
-
-			await expect(deleteCostAlert({}, ctx)).rejects.toThrow(ValidationError);
-			await expect(deleteCostAlert({}, ctx)).rejects.toThrow('Missing required field: alert_id');
-		});
-
-		it('should delete alert successfully', async () => {
-			mockApiClient.deleteCostAlert.mockResolvedValue({
-				ok: true,
-				data: { success: true, deleted_alert_id: VALID_UUID },
-			});
-			const ctx = createMockContext();
-
-			const result = await deleteCostAlert({ alert_id: VALID_UUID }, ctx);
-
-			expect(result.result.success).toBe(true);
-			expect(result.result.deleted_alert_id).toBe(VALID_UUID);
-		});
-
-		it('should return error on API failure', async () => {
-			mockApiClient.deleteCostAlert.mockResolvedValue({
-				ok: false,
-				error: 'Delete failed',
-			});
-			const ctx = createMockContext();
-
-			const result = await deleteCostAlert({ alert_id: VALID_UUID }, ctx);
-
-			expect(result.isError).toBe(true);
-			expect(result.result.error).toBe('Delete failed');
-		});
-	});
-
-	// ============================================================================
-	// getTaskCosts
-	// ============================================================================
-
-	describe('getTaskCosts', () => {
-		it('should throw ValidationError when project_id is missing', async () => {
-			const ctx = createMockContext();
-
-			await expect(getTaskCosts({}, ctx)).rejects.toThrow(ValidationError);
-			await expect(getTaskCosts({}, ctx)).rejects.toThrow('Missing required field: project_id');
-		});
-
-		it('should return task costs with total', async () => {
-			const mockTasks = [
-				{ id: 'task-1', title: 'Task 1', estimated_cost_usd: '0.50' },
-				{ id: 'task-2', title: 'Task 2', estimated_cost_usd: '0.30' },
-			];
-			mockApiClient.getTaskCosts.mockResolvedValue({
-				ok: true,
-				data: {
-					project_id: VALID_UUID,
-					tasks: mockTasks,
-					total_cost_usd: 0.8,
-				},
-			});
-			const ctx = createMockContext();
-
-			const result = await getTaskCosts({ project_id: VALID_UUID }, ctx);
-
-			expect(result.result.project_id).toBe(VALID_UUID);
-			expect(result.result.tasks).toEqual(mockTasks);
-			expect(result.result.total_cost_usd).toBe(0.8);
-		});
-
-		it('should handle empty task list', async () => {
-			mockApiClient.getTaskCosts.mockResolvedValue({
-				ok: true,
-				data: {
-					project_id: VALID_UUID,
-					tasks: [],
-					total_cost_usd: 0,
-				},
-			});
-			const ctx = createMockContext();
-
-			const result = await getTaskCosts({ project_id: VALID_UUID }, ctx);
-
-			expect(result.result.tasks).toEqual([]);
-			expect(result.result.total_cost_usd).toBe(0);
-		});
-
-		it('should return error on API failure', async () => {
-			mockApiClient.getTaskCosts.mockResolvedValue({
-				ok: false,
-				error: 'Query failed',
-			});
-			const ctx = createMockContext();
-
-			const result = await getTaskCosts({ project_id: VALID_UUID }, ctx);
-
-			expect(result.isError).toBe(true);
-			expect(result.result.error).toBe('Query failed');
-		});
-	});
-});
+/**
+ * Cost Handlers Unit Tests
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+	getCostSummary,
+	getCostAlerts,
+	addCostAlert,
+	updateCostAlert,
+	deleteCostAlert,
+	getTaskCosts,
+} from './cost.js';
+import { createMockContext } from './__test-utils__.js';
+import { mockApiClient } from './__test-setup__.js';
+import { ValidationError } from '../validators.js';
+
+const VALID_UUID = '123e4567-e89b-12d3-a456-426614174000';
+
+describe('Cost Handlers', () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	// ============================================================================
+	// getCostSummary
+	// ============================================================================
+
+	describe('getCostSummary', () => {
+		it('should throw ValidationError when project_id is missing', async () => {
+			const ctx = createMockContext();
+
+			await expect(getCostSummary({}, ctx)).rejects.toThrow(ValidationError);
+			await expect(getCostSummary({}, ctx)).rejects.toThrow('Missing required field: project_id');
+		});
+
+		it('should return daily cost summary with totals', async () => {
+			const mockData = [
+				{
+					date: '2025-01-14',
+					session_count: 5,
+					total_tokens: 10000,
+					total_calls: 50,
+					estimated_cost_usd: '0.50',
+				},
+				{
+					date: '2025-01-13',
+					session_count: 3,
+					total_tokens: 6000,
+					total_calls: 30,
+					estimated_cost_usd: '0.30',
+				},
+			];
+			mockApiClient.getCostSummary.mockResolvedValue({
+				ok: true,
+				data: {
+					period: 'daily',
+					summary: mockData,
+					totals: {
+						sessions: 8,
+						tokens: 16000,
+						calls: 80,
+						cost: 0.8,
+					},
+				},
+			});
+			const ctx = createMockContext();
+
+			const result = await getCostSummary({ project_id: VALID_UUID }, ctx);
+
+			expect(result.isError).toBeUndefined();
+			expect(result.result.period).toBe('daily');
+			expect(result.result.summary).toEqual(mockData);
+			expect(result.result.totals).toEqual({
+				sessions: 8,
+				tokens: 16000,
+				calls: 80,
+				cost: 0.8,
+			});
+		});
+
+		it('should handle weekly period', async () => {
+			mockApiClient.getCostSummary.mockResolvedValue({
+				ok: true,
+				data: { period: 'weekly', summary: [], totals: { sessions: 0, tokens: 0, calls: 0, cost: 0 } },
+			});
+			const ctx = createMockContext();
+
+			const result = await getCostSummary(
+				{ project_id: VALID_UUID, period: 'weekly' },
+				ctx
+			);
+
+			expect(result.result.period).toBe('weekly');
+			expect(mockApiClient.getCostSummary).toHaveBeenCalledWith(
+				VALID_UUID,
+				expect.objectContaining({ period: 'weekly' })
+			);
+		});
+
+		it('should handle monthly period', async () => {
+			mockApiClient.getCostSummary.mockResolvedValue({
+				ok: true,
+				data: { period: 'monthly', summary: [], totals: { sessions: 0, tokens: 0, calls: 0, cost: 0 } },
+			});
+			const ctx = createMockContext();
+
+			const result = await getCostSummary(
+				{ project_id: VALID_UUID, period: 'monthly' },
+				ctx
+			);
+
+			expect(result.result.period).toBe('monthly');
+			expect(mockApiClient.getCostSummary).toHaveBeenCalledWith(
+				VALID_UUID,
+				expect.objectContaining({ period: 'monthly' })
+			);
+		});
+
+		it('should return error on API failure', async () => {
+			mockApiClient.getCostSummary.mockResolvedValue({
+				ok: false,
+				error: 'Database error',
+			});
+			const ctx = createMockContext();
+
+			const result = await getCostSummary({ project_id: VALID_UUID }, ctx);
+
+			expect(result.isError).toBe(true);
+			expect(result.result.error).toBe('Database error');
+		});
+	});
+
+	// ============================================================================
+	// getCostAlerts
+	// ============================================================================
+
+	describe('getCostAlerts', () => {
+		it('should return all alerts for user', async () => {
+			const mockAlerts = [
+				{ id: 'alert-1', threshold_amount: 10, threshold_period: 'daily' },
+				{ id: 'alert-2', threshold_amount: 50, threshold_period: 'weekly' },
+			];
+			mockApiClient.getCostAlerts.mockResolvedValue({
+				ok: true,
+				data: { alerts: mockAlerts, count: 2 },
+			});
+			const ctx = createMockContext();
+
+			const result = await getCostAlerts({}, ctx);
+
+			expect(result.result.alerts).toEqual(mockAlerts);
+			expect(result.result.count).toBe(2);
+		});
+
+		it('should call getCostAlerts with no args (project filtering done server-side)', async () => {
+			mockApiClient.getCostAlerts.mockResolvedValue({
+				ok: true,
+				data: { alerts: [], count: 0 },
+			});
+			const ctx = createMockContext();
+
+			await getCostAlerts({ project_id: VALID_UUID }, ctx);
+
+			expect(mockApiClient.getCostAlerts).toHaveBeenCalledWith();
+		});
+
+		it('should return error on API failure', async () => {
+			mockApiClient.getCostAlerts.mockResolvedValue({
+				ok: false,
+				error: 'Query failed',
+			});
+			const ctx = createMockContext();
+
+			const result = await getCostAlerts({}, ctx);
+
+			expect(result.isError).toBe(true);
+			expect(result.result.error).toBe('Query failed');
+		});
+	});
+
+	// ============================================================================
+	// addCostAlert
+	// ============================================================================
+
+	describe('addCostAlert', () => {
+		it('should throw ValidationError when threshold_amount is missing', async () => {
+			const ctx = createMockContext();
+
+			await expect(
+				addCostAlert({ threshold_period: 'daily' }, ctx)
+			).rejects.toThrow(ValidationError);
+			await expect(
+				addCostAlert({ threshold_period: 'daily' }, ctx)
+			).rejects.toThrow('Missing required field: threshold_amount');
+		});
+
+		it('should throw ValidationError when threshold_amount is not positive', async () => {
+			const ctx = createMockContext();
+
+			await expect(
+				addCostAlert({ threshold_amount: -5, threshold_period: 'daily' }, ctx)
+			).rejects.toThrow(ValidationError);
+			await expect(
+				addCostAlert({ threshold_amount: -5, threshold_period: 'daily' }, ctx)
+			).rejects.toThrow('threshold_amount must be a positive number');
+		});
+
+		it('should throw ValidationError when threshold_period is invalid', async () => {
+			const ctx = createMockContext();
+
+			await expect(
+				addCostAlert({ threshold_amount: 10, threshold_period: 'yearly' }, ctx)
+			).rejects.toThrow(ValidationError);
+			await expect(
+				addCostAlert({ threshold_amount: 10, threshold_period: 'yearly' }, ctx)
+			).rejects.toThrow('Invalid threshold_period');
+		});
+
+		it('should create alert successfully', async () => {
+			const mockAlert = {
+				id: 'new-alert',
+				threshold_amount: 10,
+				threshold_period: 'daily',
+				alert_type: 'warning',
+			};
+			mockApiClient.addCostAlert.mockResolvedValue({
+				ok: true,
+				data: { success: true, alert: mockAlert, message: 'Alert created' },
+			});
+			const ctx = createMockContext();
+
+			const result = await addCostAlert(
+				{ threshold_amount: 10, threshold_period: 'daily' },
+				ctx
+			);
+
+			expect(result.result.success).toBe(true);
+			expect(result.result.alert).toEqual(mockAlert);
+			expect(result.result.message).toContain('Alert created');
+		});
+
+		it('should create alert with project_id', async () => {
+			mockApiClient.addCostAlert.mockResolvedValue({
+				ok: true,
+				data: { success: true, alert: { id: 'new-alert' } },
+			});
+			const ctx = createMockContext();
+
+			await addCostAlert(
+				{
+					project_id: VALID_UUID,
+					threshold_amount: 10,
+					threshold_period: 'daily',
+				},
+				ctx
+			);
+
+			expect(mockApiClient.addCostAlert).toHaveBeenCalledWith(
+				expect.objectContaining({
+					project_id: VALID_UUID,
+					threshold_amount: 10,
+					threshold_period: 'daily',
+				})
+			);
+		});
+
+		it('should return error on API failure', async () => {
+			mockApiClient.addCostAlert.mockResolvedValue({
+				ok: false,
+				error: 'Insert failed',
+			});
+			const ctx = createMockContext();
+
+			const result = await addCostAlert(
+				{ threshold_amount: 10, threshold_period: 'daily' },
+				ctx
+			);
+
+			expect(result.isError).toBe(true);
+			expect(result.result.error).toBe('Insert failed');
+		});
+	});
+
+	// ============================================================================
+	// updateCostAlert
+	// ============================================================================
+
+	describe('updateCostAlert', () => {
+		it('should throw ValidationError when alert_id is missing', async () => {
+			const ctx = createMockContext();
+
+			await expect(updateCostAlert({}, ctx)).rejects.toThrow(ValidationError);
+			await expect(updateCostAlert({}, ctx)).rejects.toThrow('Missing required field: alert_id');
+		});
+
+		it('should return error when no updates provided', async () => {
+			const ctx = createMockContext();
+
+			const result = await updateCostAlert({ alert_id: VALID_UUID }, ctx);
+
+			expect(result.isError).toBe(true);
+			expect(result.result.error).toBe('No updates provided');
+		});
+
+		it('should update alert successfully', async () => {
+			const mockUpdatedAlert = {
+				id: VALID_UUID,
+				threshold_amount: 20,
+				threshold_period: 'weekly',
+			};
+			mockApiClient.updateCostAlert.mockResolvedValue({
+				ok: true,
+				data: { success: true, alert: mockUpdatedAlert },
+			});
+			const ctx = createMockContext();
+
+			const result = await updateCostAlert(
+				{ alert_id: VALID_UUID, threshold_amount: 20 },
+				ctx
+			);
+
+			expect(result.result.success).toBe(true);
+			expect(result.result.alert).toEqual(mockUpdatedAlert);
+		});
+
+		it('should update enabled status', async () => {
+			mockApiClient.updateCostAlert.mockResolvedValue({
+				ok: true,
+				data: { success: true, alert: { id: VALID_UUID, enabled: false } },
+			});
+			const ctx = createMockContext();
+
+			await updateCostAlert({ alert_id: VALID_UUID, enabled: false }, ctx);
+
+			expect(mockApiClient.updateCostAlert).toHaveBeenCalledWith(
+				VALID_UUID,
+				expect.objectContaining({ enabled: false })
+			);
+		});
+
+		it('should return error on API failure', async () => {
+			mockApiClient.updateCostAlert.mockResolvedValue({
+				ok: false,
+				error: 'Update failed',
+			});
+			const ctx = createMockContext();
+
+			const result = await updateCostAlert(
+				{ alert_id: VALID_UUID, threshold_amount: 20 },
+				ctx
+			);
+
+			expect(result.isError).toBe(true);
+			expect(result.result.error).toBe('Update failed');
+		});
+	});
+
+	// ============================================================================
+	// deleteCostAlert
+	// ============================================================================
+
+	describe('deleteCostAlert', () => {
+		it('should throw ValidationError when alert_id is missing', async () => {
+			const ctx = createMockContext();
+
+			await expect(deleteCostAlert({}, ctx)).rejects.toThrow(ValidationError);
+			await expect(deleteCostAlert({}, ctx)).rejects.toThrow('Missing required field: alert_id');
+		});
+
+		it('should delete alert successfully', async () => {
+			mockApiClient.deleteCostAlert.mockResolvedValue({
+				ok: true,
+				data: { success: true, deleted_alert_id: VALID_UUID },
+			});
+			const ctx = createMockContext();
+
+			const result = await deleteCostAlert({ alert_id: VALID_UUID }, ctx);
+
+			expect(result.result.success).toBe(true);
+			expect(result.result.deleted_alert_id).toBe(VALID_UUID);
+		});
+
+		it('should return error on API failure', async () => {
+			mockApiClient.deleteCostAlert.mockResolvedValue({
+				ok: false,
+				error: 'Delete failed',
+			});
+			const ctx = createMockContext();
+
+			const result = await deleteCostAlert({ alert_id: VALID_UUID }, ctx);
+
+			expect(result.isError).toBe(true);
+			expect(result.result.error).toBe('Delete failed');
+		});
+	});
+
+	// ============================================================================
+	// getTaskCosts
+	// ============================================================================
+
+	describe('getTaskCosts', () => {
+		it('should throw ValidationError when project_id is missing', async () => {
+			const ctx = createMockContext();
+
+			await expect(getTaskCosts({}, ctx)).rejects.toThrow(ValidationError);
+			await expect(getTaskCosts({}, ctx)).rejects.toThrow('Missing required field: project_id');
+		});
+
+		it('should return task costs with total', async () => {
+			const mockTasks = [
+				{ id: 'task-1', title: 'Task 1', estimated_cost_usd: '0.50' },
+				{ id: 'task-2', title: 'Task 2', estimated_cost_usd: '0.30' },
+			];
+			mockApiClient.getTaskCosts.mockResolvedValue({
+				ok: true,
+				data: {
+					project_id: VALID_UUID,
+					tasks: mockTasks,
+					total_cost_usd: 0.8,
+				},
+			});
+			const ctx = createMockContext();
+
+			const result = await getTaskCosts({ project_id: VALID_UUID }, ctx);
+
+			expect(result.result.project_id).toBe(VALID_UUID);
+			expect(result.result.tasks).toEqual(mockTasks);
+			expect(result.result.total_cost_usd).toBe(0.8);
+		});
+
+		it('should handle empty task list', async () => {
+			mockApiClient.getTaskCosts.mockResolvedValue({
+				ok: true,
+				data: {
+					project_id: VALID_UUID,
+					tasks: [],
+					total_cost_usd: 0,
+				},
+			});
+			const ctx = createMockContext();
+
+			const result = await getTaskCosts({ project_id: VALID_UUID }, ctx);
+
+			expect(result.result.tasks).toEqual([]);
+			expect(result.result.total_cost_usd).toBe(0);
+		});
+
+		it('should return error on API failure', async () => {
+			mockApiClient.getTaskCosts.mockResolvedValue({
+				ok: false,
+				error: 'Query failed',
+			});
+			const ctx = createMockContext();
+
+			const result = await getTaskCosts({ project_id: VALID_UUID }, ctx);
+
+			expect(result.isError).toBe(true);
+			expect(result.result.error).toBe('Query failed');
+		});
+	});
+});