@vibescope/mcp-server 0.2.0 → 0.2.1

package/src/handlers/organizations.ts

@@ -18,22 +18,91 @@
  */
 
 import type { Handler, HandlerRegistry } from './types.js';
-import { validateRequired, validateUUID } from '../validators.js';
+import { parseArgs, uuidValidator, createEnumValidator, ValidationError } from '../validators.js';
 import { getApiClient } from '../api-client.js';
 
 // Valid roles in order of permission level
 const ROLE_ORDER = ['viewer', 'member', 'admin', 'owner'] as const;
+const ASSIGNABLE_ROLES = ['viewer', 'member', 'admin'] as const;
 type Role = (typeof ROLE_ORDER)[number];
+type AssignableRole = (typeof ASSIGNABLE_ROLES)[number];
 
 // Valid share permissions
 const PERMISSION_ORDER = ['read', 'write', 'admin'] as const;
 type Permission = (typeof PERMISSION_ORDER)[number];
 
+// ============================================================================
+// Argument Schemas
+// ============================================================================
+
+const createOrganizationSchema = {
+	name: { type: 'string' as const, required: true as const },
+	description: { type: 'string' as const },
+	slug: { type: 'string' as const },
+};
+
+const updateOrganizationSchema = {
+	organization_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	name: { type: 'string' as const },
+	description: { type: 'string' as const },
+	logo_url: { type: 'string' as const },
+};
+
+const deleteOrganizationSchema = {
+	organization_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const listOrgMembersSchema = {
+	organization_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const inviteMemberSchema = {
+	organization_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	email: { type: 'string' as const, required: true as const },
+	role: { type: 'string' as const, default: 'member', validate: createEnumValidator(ASSIGNABLE_ROLES) },
+};
+
+const updateMemberRoleSchema = {
+	organization_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	user_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	role: { type: 'string' as const, required: true as const, validate: createEnumValidator(ROLE_ORDER) },
+};
+
+const removeMemberSchema = {
+	organization_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	user_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const leaveOrganizationSchema = {
+	organization_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const shareProjectWithOrgSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	organization_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	permission: { type: 'string' as const, default: 'read', validate: createEnumValidator(PERMISSION_ORDER) },
+};
+
+const updateProjectShareSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	organization_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	permission: { type: 'string' as const, required: true as const, validate: createEnumValidator(PERMISSION_ORDER) },
+};
+
+const unshareProjectSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	organization_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const listProjectSharesSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
 // ============================================================================
 // Organization Management
 // ============================================================================
 
-export const listOrganizations: Handler = async (_args, ctx) => {
+export const listOrganizations: Handler = async (_args, _ctx) => {
 	const apiClient = getApiClient();
 	const response = await apiClient.listOrganizations();
 
@@ -44,14 +113,8 @@ export const listOrganizations: Handler = async (_args, ctx) => {
 	return { result: response.data };
 };
 
-export const createOrganization: Handler = async (args, ctx) => {
-	const { name, description, slug } = args as {
-		name: string;
-		description?: string;
-		slug?: string;
-	};
-
-	validateRequired(name, 'name');
+export const createOrganization: Handler = async (args, _ctx) => {
+	const { name, description, slug } = parseArgs(args, createOrganizationSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.createOrganization({
@@ -67,26 +130,19 @@ export const createOrganization: Handler = async (args, ctx) => {
 	return { result: response.data };
 };
 
-export const updateOrganization: Handler = async (args, ctx) => {
-	const { organization_id, name, description, logo_url } = args as {
-		organization_id: string;
-		name?: string;
-		description?: string;
-		logo_url?: string;
-	};
+export const updateOrganization: Handler = async (args, _ctx) => {
+	const { organization_id, name, description, logo_url } = parseArgs(args, updateOrganizationSchema);
 
-	validateRequired(organization_id, 'organization_id');
-	validateUUID(organization_id, 'organization_id');
+	// Check that at least one update is provided
+	if (name === undefined && description === undefined && logo_url === undefined) {
+		throw new ValidationError('No updates provided');
+	}
 
 	const updates: Record<string, unknown> = {};
 	if (name !== undefined) updates.name = name;
 	if (description !== undefined) updates.description = description;
 	if (logo_url !== undefined) updates.logo_url = logo_url;
 
-	if (Object.keys(updates).length === 0) {
-		throw new Error('No updates provided');
-	}
-
 	const apiClient = getApiClient();
 	const response = await apiClient.updateOrganization(organization_id, updates);
 
@@ -97,11 +153,8 @@ export const updateOrganization: Handler = async (args, ctx) => {
 	return { result: response.data };
 };
 
-export const deleteOrganization: Handler = async (args, ctx) => {
-	const { organization_id } = args as { organization_id: string };
-
-	validateRequired(organization_id, 'organization_id');
-	validateUUID(organization_id, 'organization_id');
+export const deleteOrganization: Handler = async (args, _ctx) => {
+	const { organization_id } = parseArgs(args, deleteOrganizationSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.deleteOrganization(organization_id);
@@ -117,11 +170,8 @@ export const deleteOrganization: Handler = async (args, ctx) => {
 // Member Management
 // ============================================================================
 
-export const listOrgMembers: Handler = async (args, ctx) => {
-	const { organization_id } = args as { organization_id: string };
-
-	validateRequired(organization_id, 'organization_id');
-	validateUUID(organization_id, 'organization_id');
+export const listOrgMembers: Handler = async (args, _ctx) => {
+	const { organization_id } = parseArgs(args, listOrgMembersSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.listOrgMembers(organization_id);
@@ -133,23 +183,11 @@ export const listOrgMembers: Handler = async (args, ctx) => {
 	return { result: response.data };
 };
 
-export const inviteMember: Handler = async (args, ctx) => {
-	const { organization_id, email, role = 'member' } = args as {
-		organization_id: string;
-		email: string;
-		role?: 'admin' | 'member' | 'viewer';
-	};
-
-	validateRequired(organization_id, 'organization_id');
-	validateRequired(email, 'email');
-	validateUUID(organization_id, 'organization_id');
-
-	if (!['admin', 'member', 'viewer'].includes(role)) {
-		throw new Error('Invalid role. Must be admin, member, or viewer.');
-	}
+export const inviteMember: Handler = async (args, _ctx) => {
+	const { organization_id, email, role } = parseArgs(args, inviteMemberSchema);
 
 	const apiClient = getApiClient();
-	const response = await apiClient.inviteMember(organization_id, email, role);
+	const response = await apiClient.inviteMember(organization_id, email, role as AssignableRole);
 
 	if (!response.ok) {
 		throw new Error(response.error || 'Failed to create invite');
@@ -158,29 +196,15 @@ export const inviteMember: Handler = async (args, ctx) => {
 	return { result: response.data };
 };
 
-export const updateMemberRole: Handler = async (args, ctx) => {
-	const { organization_id, user_id, role } = args as {
-		organization_id: string;
-		user_id: string;
-		role: Role;
-	};
-
-	validateRequired(organization_id, 'organization_id');
-	validateRequired(user_id, 'user_id');
-	validateRequired(role, 'role');
-	validateUUID(organization_id, 'organization_id');
-	validateUUID(user_id, 'user_id');
-
-	if (!ROLE_ORDER.includes(role)) {
-		throw new Error(`Invalid role. Must be one of: ${ROLE_ORDER.join(', ')}`);
-	}
+export const updateMemberRole: Handler = async (args, _ctx) => {
+	const { organization_id, user_id, role } = parseArgs(args, updateMemberRoleSchema);
 
 	if (role === 'owner') {
-		throw new Error('Cannot assign owner role. Use transfer ownership instead.');
+		throw new ValidationError('Cannot assign owner role. Use transfer ownership instead.');
 	}
 
 	const apiClient = getApiClient();
-	const response = await apiClient.updateMemberRole(organization_id, user_id, role);
+	const response = await apiClient.updateMemberRole(organization_id, user_id, role as Role);
 
 	if (!response.ok) {
 		throw new Error(response.error || 'Failed to update member role');
@@ -189,16 +213,8 @@ export const updateMemberRole: Handler = async (args, ctx) => {
 	return { result: response.data };
 };
 
-export const removeMember: Handler = async (args, ctx) => {
-	const { organization_id, user_id } = args as {
-		organization_id: string;
-		user_id: string;
-	};
-
-	validateRequired(organization_id, 'organization_id');
-	validateRequired(user_id, 'user_id');
-	validateUUID(organization_id, 'organization_id');
-	validateUUID(user_id, 'user_id');
+export const removeMember: Handler = async (args, _ctx) => {
+	const { organization_id, user_id } = parseArgs(args, removeMemberSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.removeMember(organization_id, user_id);
@@ -210,11 +226,8 @@ export const removeMember: Handler = async (args, ctx) => {
 	return { result: response.data };
 };
 
-export const leaveOrganization: Handler = async (args, ctx) => {
-	const { organization_id } = args as { organization_id: string };
-
-	validateRequired(organization_id, 'organization_id');
-	validateUUID(organization_id, 'organization_id');
+export const leaveOrganization: Handler = async (args, _ctx) => {
+	const { organization_id } = parseArgs(args, leaveOrganizationSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.leaveOrganization(organization_id);
@@ -230,24 +243,11 @@ export const leaveOrganization: Handler = async (args, ctx) => {
 // Project Sharing
 // ============================================================================
 
-export const shareProjectWithOrg: Handler = async (args, ctx) => {
-	const { project_id, organization_id, permission = 'read' } = args as {
-		project_id: string;
-		organization_id: string;
-		permission?: Permission;
-	};
-
-	validateRequired(project_id, 'project_id');
-	validateRequired(organization_id, 'organization_id');
-	validateUUID(project_id, 'project_id');
-	validateUUID(organization_id, 'organization_id');
-
-	if (!PERMISSION_ORDER.includes(permission)) {
-		throw new Error(`Invalid permission. Must be one of: ${PERMISSION_ORDER.join(', ')}`);
-	}
+export const shareProjectWithOrg: Handler = async (args, _ctx) => {
+	const { project_id, organization_id, permission } = parseArgs(args, shareProjectWithOrgSchema);
 
 	const apiClient = getApiClient();
-	const response = await apiClient.shareProjectWithOrg(project_id, organization_id, permission);
+	const response = await apiClient.shareProjectWithOrg(project_id, organization_id, permission as Permission);
 
 	if (!response.ok) {
 		throw new Error(response.error || 'Failed to share project');
@@ -256,25 +256,11 @@ export const shareProjectWithOrg: Handler = async (args, ctx) => {
 	return { result: response.data };
 };
 
-export const updateProjectShare: Handler = async (args, ctx) => {
-	const { project_id, organization_id, permission } = args as {
-		project_id: string;
-		organization_id: string;
-		permission: Permission;
-	};
-
-	validateRequired(project_id, 'project_id');
-	validateRequired(organization_id, 'organization_id');
-	validateRequired(permission, 'permission');
-	validateUUID(project_id, 'project_id');
-	validateUUID(organization_id, 'organization_id');
-
-	if (!PERMISSION_ORDER.includes(permission)) {
-		throw new Error(`Invalid permission. Must be one of: ${PERMISSION_ORDER.join(', ')}`);
-	}
+export const updateProjectShare: Handler = async (args, _ctx) => {
+	const { project_id, organization_id, permission } = parseArgs(args, updateProjectShareSchema);
 
 	const apiClient = getApiClient();
-	const response = await apiClient.updateProjectShare(project_id, organization_id, permission);
+	const response = await apiClient.updateProjectShare(project_id, organization_id, permission as Permission);
 
 	if (!response.ok) {
 		throw new Error(response.error || 'Failed to update share');
@@ -283,16 +269,8 @@ export const updateProjectShare: Handler = async (args, ctx) => {
 	return { result: response.data };
 };
 
-export const unshareProject: Handler = async (args, ctx) => {
-	const { project_id, organization_id } = args as {
-		project_id: string;
-		organization_id: string;
-	};
-
-	validateRequired(project_id, 'project_id');
-	validateRequired(organization_id, 'organization_id');
-	validateUUID(project_id, 'project_id');
-	validateUUID(organization_id, 'organization_id');
+export const unshareProject: Handler = async (args, _ctx) => {
+	const { project_id, organization_id } = parseArgs(args, unshareProjectSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.unshareProject(project_id, organization_id);
@@ -304,11 +282,8 @@ export const unshareProject: Handler = async (args, ctx) => {
 	return { result: response.data };
 };
 
-export const listProjectShares: Handler = async (args, ctx) => {
-	const { project_id } = args as { project_id: string };
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
+export const listProjectShares: Handler = async (args, _ctx) => {
+	const { project_id } = parseArgs(args, listProjectSharesSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.listProjectShares(project_id);

package/src/handlers/progress.ts

@@ -9,20 +9,27 @@
  */
 
 import type { Handler, HandlerRegistry } from './types.js';
-import { validateRequired, validateUUID } from '../validators.js';
+import { parseArgs, uuidValidator } from '../validators.js';
 import { getApiClient } from '../api-client.js';
 
-export const logProgress: Handler = async (args, ctx) => {
-	const { project_id, task_id, summary, details } = args as {
-		project_id: string;
-		task_id?: string;
-		summary: string;
-		details?: string;
-	};
+// Argument schemas for type-safe parsing
+const logProgressSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	task_id: { type: 'string' as const, validate: uuidValidator },
+	summary: { type: 'string' as const, required: true as const },
+	details: { type: 'string' as const },
+};
+
+const getActivityFeedSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	limit: { type: 'number' as const, default: 50 },
+	since: { type: 'string' as const },
+	types: { type: 'array' as const },
+	created_by: { type: 'string' as const },
+};
 
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-	validateRequired(summary, 'summary');
+export const logProgress: Handler = async (args, ctx) => {
+	const { project_id, task_id, summary, details } = parseArgs(args, logProgressSchema);
 
 	const { session } = ctx;
 	const apiClient = getApiClient();
@@ -41,22 +48,17 @@ export const logProgress: Handler = async (args, ctx) => {
 	return { result: { success: true, progress_id: response.data?.progress_id } };
 };
 
-export const getActivityFeed: Handler = async (args, ctx) => {
-	const { project_id, limit = 50, since } = args as {
-		project_id: string;
-		limit?: number;
-		since?: string;
-	};
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
+export const getActivityFeed: Handler = async (args, _ctx) => {
+	const { project_id, limit, since, types, created_by } = parseArgs(args, getActivityFeedSchema);
 
 	const apiClient = getApiClient();
-	const effectiveLimit = Math.min(limit, 200);
+	const effectiveLimit = Math.min(limit ?? 50, 200);
 
 	const response = await apiClient.getActivityFeed(project_id, {
 		limit: effectiveLimit,
-		since
+		since,
+		types: types as string[] | undefined,
+		created_by
 	});
 
 	if (!response.ok) {

package/src/handlers/project.ts

@@ -10,14 +10,60 @@
  */
 
 import type { Handler, HandlerRegistry } from './types.js';
-import { validateRequired, validateUUID, validateProjectStatus } from '../validators.js';
+import {
+	parseArgs,
+	uuidValidator,
+	projectStatusValidator,
+	createEnumValidator,
+	VALID_PROJECT_STATUSES,
+} from '../validators.js';
 import { getApiClient } from '../api-client.js';
 
-export const getProjectContext: Handler = async (args, ctx) => {
-	const { project_id, git_url } = args as {
-		project_id?: string;
-		git_url?: string;
-	};
+const VALID_GIT_WORKFLOWS = ['none', 'trunk-based', 'github-flow', 'git-flow'] as const;
+type GitWorkflow = typeof VALID_GIT_WORKFLOWS[number];
+
+// Argument schemas for type-safe parsing
+const getProjectContextSchema = {
+	project_id: { type: 'string' as const, validate: uuidValidator },
+	git_url: { type: 'string' as const },
+};
+
+const getGitWorkflowSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	task_id: { type: 'string' as const, validate: uuidValidator },
+};
+
+const createProjectSchema = {
+	name: { type: 'string' as const, required: true as const },
+	description: { type: 'string' as const },
+	goal: { type: 'string' as const },
+	git_url: { type: 'string' as const },
+	tech_stack: { type: 'array' as const },
+};
+
+const updateProjectSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	name: { type: 'string' as const },
+	description: { type: 'string' as const },
+	goal: { type: 'string' as const },
+	git_url: { type: 'string' as const },
+	tech_stack: { type: 'array' as const },
+	status: { type: 'string' as const, validate: projectStatusValidator },
+	git_workflow: { type: 'string' as const, validate: createEnumValidator(VALID_GIT_WORKFLOWS) },
+	git_main_branch: { type: 'string' as const },
+	git_develop_branch: { type: 'string' as const },
+	git_auto_branch: { type: 'boolean' as const },
+	git_auto_tag: { type: 'boolean' as const },
+	deployment_instructions: { type: 'string' as const },
+};
+
+const updateProjectReadmeSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	readme_content: { type: 'string' as const, required: true as const },
+};
+
+export const getProjectContext: Handler = async (args, _ctx) => {
+	const { project_id, git_url } = parseArgs(args, getProjectContextSchema);
 
 	const apiClient = getApiClient();
 
@@ -51,14 +97,8 @@ export const getProjectContext: Handler = async (args, ctx) => {
 	return { result: response.data };
 };
 
-export const getGitWorkflow: Handler = async (args, ctx) => {
-	const { project_id, task_id } = args as {
-		project_id: string;
-		task_id?: string;
-	};
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
+export const getGitWorkflow: Handler = async (args, _ctx) => {
+	const { project_id, task_id } = parseArgs(args, getGitWorkflowSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.getGitWorkflow(project_id, task_id);
@@ -70,16 +110,8 @@ export const getGitWorkflow: Handler = async (args, ctx) => {
 	return { result: response.data };
 };
 
-export const createProject: Handler = async (args, ctx) => {
-	const { name, description, goal, git_url, tech_stack } = args as {
-		name: string;
-		description?: string;
-		goal?: string;
-		git_url?: string;
-		tech_stack?: string[];
-	};
-
-	validateRequired(name, 'name');
+export const createProject: Handler = async (args, _ctx) => {
+	const { name, description, goal, git_url, tech_stack } = parseArgs(args, createProjectSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.createProject({
@@ -87,7 +119,7 @@ export const createProject: Handler = async (args, ctx) => {
 		description,
 		goal,
 		git_url,
-		tech_stack
+		tech_stack: tech_stack as string[] | undefined
 	});
 
 	if (!response.ok) {
@@ -97,31 +129,38 @@ export const createProject: Handler = async (args, ctx) => {
 	return { result: response.data };
 };
 
-export const updateProject: Handler = async (args, ctx) => {
-	const { project_id, ...updates } = args as {
-		project_id: string;
-		name?: string;
-		description?: string;
-		goal?: string;
-		git_url?: string;
-		tech_stack?: string[];
-		status?: string;
-		git_workflow?: 'none' | 'trunk-based' | 'github-flow' | 'git-flow';
-		git_main_branch?: string;
-		git_develop_branch?: string;
-		git_auto_branch?: boolean;
-		git_auto_tag?: boolean;
-		git_auto_commit_on_complete?: boolean;
-		git_auto_pr_on_complete?: boolean;
-		deployment_instructions?: string;
-	};
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-	validateProjectStatus(updates.status);
+export const updateProject: Handler = async (args, _ctx) => {
+	const {
+		project_id,
+		name,
+		description,
+		goal,
+		git_url,
+		tech_stack,
+		status,
+		git_workflow,
+		git_main_branch,
+		git_develop_branch,
+		git_auto_branch,
+		git_auto_tag,
+		deployment_instructions
+	} = parseArgs(args, updateProjectSchema);
 
 	const apiClient = getApiClient();
-	const response = await apiClient.updateProject(project_id, updates);
+	const response = await apiClient.updateProject(project_id, {
+		name,
+		description,
+		goal,
+		git_url,
+		tech_stack: tech_stack as string[] | undefined,
+		status: status as typeof VALID_PROJECT_STATUSES[number] | undefined,
+		git_workflow: git_workflow as GitWorkflow | undefined,
+		git_main_branch,
+		git_develop_branch,
+		git_auto_branch,
+		git_auto_tag,
+		deployment_instructions
+	});
 
 	if (!response.ok) {
 		throw new Error(response.error || 'Failed to update project');
@@ -130,15 +169,8 @@ export const updateProject: Handler = async (args, ctx) => {
 	return { result: response.data };
 };
 
-export const updateProjectReadme: Handler = async (args, ctx) => {
-	const { project_id, readme_content } = args as {
-		project_id: string;
-		readme_content: string;
-	};
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-	validateRequired(readme_content, 'readme_content');
+export const updateProjectReadme: Handler = async (args, _ctx) => {
+	const { project_id, readme_content } = parseArgs(args, updateProjectReadmeSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.updateProjectReadme(project_id, readme_content);

package/src/handlers/requests.ts

@@ -10,14 +10,25 @@
  */
 
 import type { Handler, HandlerRegistry } from './types.js';
-import { validateRequired, validateUUID } from '../validators.js';
+import { parseArgs, uuidValidator } from '../validators.js';
 import { getApiClient } from '../api-client.js';
 
-export const getPendingRequests: Handler = async (args, ctx) => {
-	const { project_id } = args as { project_id: string };
+// Argument schemas for type-safe parsing
+const getPendingRequestsSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
 
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
+const acknowledgeRequestSchema = {
+	request_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const answerQuestionSchema = {
+	request_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	answer: { type: 'string' as const, required: true as const },
+};
+
+export const getPendingRequests: Handler = async (args, ctx) => {
+	const { project_id } = parseArgs(args, getPendingRequestsSchema);
 
 	const { session } = ctx;
 	const apiClient = getApiClient();
@@ -37,10 +48,7 @@ export const getPendingRequests: Handler = async (args, ctx) => {
 };
 
 export const acknowledgeRequest: Handler = async (args, ctx) => {
-	const { request_id } = args as { request_id: string };
-
-	validateRequired(request_id, 'request_id');
-	validateUUID(request_id, 'request_id');
+	const { request_id } = parseArgs(args, acknowledgeRequestSchema);
 
 	const { session } = ctx;
 	const apiClient = getApiClient();
@@ -59,11 +67,7 @@ export const acknowledgeRequest: Handler = async (args, ctx) => {
 };
 
 export const answerQuestion: Handler = async (args, ctx) => {
-	const { request_id, answer } = args as { request_id: string; answer: string };
-
-	validateRequired(request_id, 'request_id');
-	validateRequired(answer, 'answer');
-	validateUUID(request_id, 'request_id');
+	const { request_id, answer } = parseArgs(args, answerQuestionSchema);
 
 	const { session } = ctx;
 	const apiClient = getApiClient();