@transcend-io/mcp-server-assessment 0.1.0

package/dist/graphql-BVBi59RV.mjs

@@ -0,0 +1,1017 @@
+import { PaginationSchema, TranscendGraphQLBase, createListResult, createToolResult, defineTool, z } from "@transcend-io/mcp-server-base";
+import { AssessmentFormStatus, AssessmentFormTemplateStatus } from "@transcend-io/privacy-types";
+//#region src/tools/assessments_add_section.ts
+const AddSectionSchema = z.object({
+	template_id: z.string().describe("ID of the assessment form template to add the section to"),
+	title: z.string().describe("Title of the new section"),
+	questions: z.array(z.record(z.string(), z.unknown())).optional().describe("Array of question objects: [{title, type, subType?, description?, placeholder?, isRequired?, referenceId?, answerOptions?: [{value}], allowSelectOther?, requireRiskEvaluation?}]")
+});
+function createAssessmentsAddSectionTool(clients) {
+	const graphql = clients.graphql;
+	return defineTool({
+		name: "assessments_add_section",
+		description: "Add a new section (with optional inline questions) to an existing assessment form template. Useful for building templates incrementally or adding sections to imported templates. Same auto-corrections as assessments_create_template apply to questions.",
+		category: "Assessments",
+		readOnly: false,
+		confirmationHint: "Adds a section to the assessment template",
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: false
+		},
+		zodSchema: AddSectionSchema,
+		handler: async ({ template_id, title, questions }) => {
+			return createToolResult(true, {
+				section: await graphql.createAssessmentSection({
+					assessmentFormTemplateId: template_id,
+					title,
+					questions
+				}),
+				message: `Section "${title}" added to template successfully`
+			});
+		}
+	});
+}
+//#endregion
+//#region src/tools/assessments_answer_question.ts
+const AnswerQuestionValueSchema = z.object({
+	value: z.string(),
+	isUserCreated: z.boolean()
+});
+const AnswerQuestionSchema = z.object({
+	assessment_question_id: z.string().describe("ID of the assessment question to answer"),
+	assessment_answer_ids: z.array(z.string()).optional().describe("IDs of existing answer options to select (for SINGLE_SELECT/MULTI_SELECT questions)"),
+	assessment_answer_values: z.array(AnswerQuestionValueSchema).optional().describe("Free-text answer values to create and select (for text questions). Each item: {value: string, isUserCreated: boolean}")
+});
+function createAssessmentsAnswerQuestionTool(clients) {
+	const graphql = clients.graphql;
+	return defineTool({
+		name: "assessments_answer_question",
+		description: "Answer an assessment question by selecting existing answer options or providing free-text values. For SINGLE_SELECT/MULTI_SELECT questions, provide assessmentAnswerIds from the answerOptions. For SHORT_ANSWER_TEXT/LONG_ANSWER_TEXT, provide assessmentAnswerValues with {value, isUserCreated: true}.",
+		category: "Assessments",
+		readOnly: false,
+		confirmationHint: "Records answer to the assessment question",
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: true
+		},
+		zodSchema: AnswerQuestionSchema,
+		handler: async ({ assessment_question_id, assessment_answer_ids, assessment_answer_values }) => {
+			const input = { assessmentQuestionId: assessment_question_id };
+			if (assessment_answer_ids) input.assessmentAnswerIds = assessment_answer_ids;
+			if (assessment_answer_values) input.assessmentAnswerValues = assessment_answer_values;
+			return createToolResult(true, {
+				selectedAnswers: await graphql.selectAssessmentQuestionAnswers(input),
+				message: "Assessment question answered successfully"
+			});
+		}
+	});
+}
+//#endregion
+//#region src/tools/_helpers.ts
+/**
+* Resolves a template_id to an assessment group ID by searching through all groups.
+* Returns either the group ID or an error result.
+*/
+async function resolveTemplateToGroupId(graphql, templateId) {
+	const matchingGroups = (await graphql.listAssessmentGroups({ first: 100 })).nodes.filter((g) => g.assessmentFormTemplate?.id === templateId);
+	if (matchingGroups.length === 0) return { error: createToolResult(false, void 0, `No assessment group found for template_id "${templateId}". Use assessments_list_groups to see available groups.`) };
+	if (matchingGroups.length > 1) return { error: createToolResult(false, void 0, `Multiple assessment groups found for template_id "${templateId}" (group IDs: ${matchingGroups.map((g) => g.id).join(", ")}). Please specify assessment_group_id explicitly. Use assessments_list_groups to find available groups.`) };
+	return { groupId: matchingGroups[0].id };
+}
+//#endregion
+//#region src/tools/assessments_create.ts
+const CreateAssessmentSchema = z.object({
+	title: z.string().describe("Title of the assessment"),
+	assessment_group_id: z.string().optional().describe("ID of the assessment group to create the assessment in (preferred). Use assessments_list_groups to find available groups."),
+	template_id: z.string().optional().describe("ID of the assessment template. If assessment_group_id is not provided, the first group using this template will be used."),
+	assignee_ids: z.array(z.string()).optional().describe("Array of user IDs to assign the assessment to")
+});
+function createAssessmentsCreateTool(clients) {
+	const graphql = clients.graphql;
+	return defineTool({
+		name: "assessments_create",
+		description: "Create a new privacy assessment within an assessment group. Assessment groups are linked to templates. You can provide either an assessment_group_id directly, or a template_id to auto-resolve the first matching group. Use assessments_list_groups to find available groups.",
+		category: "Assessments",
+		readOnly: false,
+		confirmationHint: "Creates a new privacy assessment",
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: false
+		},
+		zodSchema: CreateAssessmentSchema,
+		handler: async ({ title, assessment_group_id, template_id, assignee_ids }) => {
+			let assessmentGroupId = assessment_group_id;
+			if (!assessmentGroupId && template_id) {
+				const resolved = await resolveTemplateToGroupId(graphql, template_id);
+				if ("error" in resolved) return resolved.error;
+				assessmentGroupId = resolved.groupId;
+			}
+			if (!assessmentGroupId) return createToolResult(false, void 0, "Either assessment_group_id or template_id must be provided. Use assessments_list_groups to find available groups.");
+			return createToolResult(true, {
+				assessment: await graphql.createAssessment({
+					title,
+					assessmentGroupId,
+					assigneeIds: assignee_ids
+				}),
+				message: `Assessment "${title}" created successfully`
+			});
+		}
+	});
+}
+//#endregion
+//#region src/tools/assessments_create_group.ts
+const CreateGroupSchema = z.object({
+	title: z.string().describe("Title of the assessment group"),
+	template_id: z.string().describe("ID of the assessment template to link this group to"),
+	description: z.string().optional().describe("Description of the assessment group (optional)"),
+	reviewer_ids: z.array(z.string()).optional().describe("IDs of users assigned to review new assessments in this group (optional)")
+});
+function createAssessmentsCreateGroupTool(clients) {
+	const graphql = clients.graphql;
+	return defineTool({
+		name: "assessments_create_group",
+		description: "Create a new assessment group linked to a template. Assessment groups are containers for assessments.",
+		category: "Assessments",
+		readOnly: false,
+		confirmationHint: "Creates a new assessment group",
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: false
+		},
+		zodSchema: CreateGroupSchema,
+		handler: async ({ title, template_id, description, reviewer_ids }) => {
+			return createToolResult(true, {
+				assessmentGroup: await graphql.createAssessmentGroup({
+					title,
+					assessmentFormTemplateId: template_id,
+					description,
+					reviewerIds: reviewer_ids
+				}),
+				message: `Assessment group "${title}" created successfully`
+			});
+		}
+	});
+}
+//#endregion
+//#region src/tools/assessments_create_template.ts
+const CreateTemplateSchema = z.object({
+	title: z.string().describe("Title of the assessment form template"),
+	description: z.string().optional().describe("Description of the template"),
+	status: z.nativeEnum(AssessmentFormTemplateStatus).optional().describe("Template status: DRAFT or PUBLISHED (default: DRAFT)"),
+	sections: z.array(z.record(z.string(), z.unknown())).optional().describe("Array of section objects with title and optional questions array")
+});
+function createAssessmentsCreateTemplateTool(clients) {
+	const graphql = clients.graphql;
+	return defineTool({
+		name: "assessments_create_template",
+		description: "Create a new assessment form template with sections and questions inline. This is the \"import\" side of the JSON import/export workflow. You can provide the full template structure (sections with questions and answer options) in a single call. Question types: LONG_ANSWER_TEXT, SHORT_ANSWER_TEXT, SINGLE_SELECT, MULTI_SELECT, FILE. SubTypes: NONE, CUSTOM, USER, TEAM, DATA_SUB_CATEGORY, HAS_PERSONAL_DATA, ATTRIBUTE_KEY, SENSITIVE_CATEGORY. Auto-corrections: referenceId is auto-generated as UUID if missing or not UUID format; subType is auto-set to CUSTOM when allowSelectOther is true; requireRiskEvaluation is ignored when no riskFrameworkId is provided.",
+		category: "Assessments",
+		readOnly: false,
+		confirmationHint: "Creates a new assessment form template",
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: false
+		},
+		zodSchema: CreateTemplateSchema,
+		handler: async ({ title, description, status, sections }) => {
+			const input = {
+				title,
+				description,
+				status: status ?? "DRAFT",
+				sections
+			};
+			return createToolResult(true, {
+				template: await graphql.createAssessmentFormTemplate(input),
+				message: `Assessment template "${title}" created successfully`
+			});
+		}
+	});
+}
+//#endregion
+//#region src/tools/assessments_export_template.ts
+const ExportTemplateSchema = z.object({ template_id: z.string().describe("ID of the assessment form template to export") });
+function createAssessmentsExportTemplateTool(clients) {
+	const graphql = clients.graphql;
+	return defineTool({
+		name: "assessments_export_template",
+		description: "Export a full assessment form template as JSON, including all sections, questions, answer options, and configuration. This is the \"export\" side of the JSON import/export workflow. The output can be used as input for assessments_create_template to recreate the template elsewhere.",
+		category: "Assessments",
+		readOnly: true,
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true
+		},
+		zodSchema: ExportTemplateSchema,
+		handler: async ({ template_id }) => {
+			const template = await graphql.getAssessmentFormTemplate(template_id);
+			return createToolResult(true, {
+				_exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				_format: "transcend-assessment-template-v1",
+				template: {
+					title: template.title,
+					description: template.description,
+					status: template.status,
+					sections: template.sections.map((section) => ({
+						title: section.title,
+						questions: section.questions.map((q) => ({
+							title: q.title,
+							type: q.type,
+							subType: q.subType,
+							description: q.description,
+							placeholder: q.placeholder,
+							isRequired: q.isRequired,
+							referenceId: q.referenceId,
+							allowSelectOther: q.allowSelectOther,
+							requireRiskEvaluation: q.requireRiskEvaluation,
+							answerOptions: q.answerOptions.map((opt) => ({ value: opt.value }))
+						}))
+					}))
+				},
+				_raw: template
+			});
+		}
+	});
+}
+//#endregion
+//#region src/tools/assessments_get.ts
+const GetAssessmentSchema = z.object({ assessment_id: z.string().describe("ID of the assessment to retrieve") });
+function createAssessmentsGetTool(clients) {
+	const graphql = clients.graphql;
+	return defineTool({
+		name: "assessments_get",
+		description: "Get detailed information about a specific assessment including questions and responses",
+		category: "Assessments",
+		readOnly: true,
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true
+		},
+		zodSchema: GetAssessmentSchema,
+		handler: async ({ assessment_id }) => {
+			return createToolResult(true, await graphql.getAssessment(assessment_id));
+		}
+	});
+}
+//#endregion
+//#region src/tools/assessments_list.ts
+const AssessmentStatusEnum = z.nativeEnum(AssessmentFormStatus);
+const ListAssessmentsSchema = z.object({ status: AssessmentStatusEnum.optional().describe("Filter by assessment status") }).merge(PaginationSchema);
+function createAssessmentsListTool(clients) {
+	const graphql = clients.graphql;
+	return defineTool({
+		name: "assessments_list",
+		description: "List all privacy assessments in your organization. Supports filtering by status. Note: Cursor pagination is not supported (max 100 results).",
+		category: "Assessments",
+		readOnly: true,
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true
+		},
+		zodSchema: ListAssessmentsSchema,
+		handler: async ({ status, limit, cursor }) => {
+			const result = await graphql.listAssessments({
+				first: limit,
+				after: cursor,
+				filterBy: status ? { statuses: [status] } : void 0
+			});
+			return createListResult(result.nodes, {
+				totalCount: result.totalCount,
+				hasNextPage: result.pageInfo?.hasNextPage
+			});
+		}
+	});
+}
+//#endregion
+//#region src/tools/assessments_list_groups.ts
+const ListGroupsSchema = PaginationSchema;
+function createAssessmentsListGroupsTool(clients) {
+	const graphql = clients.graphql;
+	return defineTool({
+		name: "assessments_list_groups",
+		description: "List all assessment groups. Groups are containers for assessments and are linked to templates. Use this to find the right group ID for creating assessments.",
+		category: "Assessments",
+		readOnly: true,
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true
+		},
+		zodSchema: ListGroupsSchema,
+		handler: async ({ limit, cursor }) => {
+			const result = await graphql.listAssessmentGroups({
+				first: limit,
+				after: cursor
+			});
+			return createListResult(result.nodes, {
+				totalCount: result.totalCount,
+				hasNextPage: result.pageInfo?.hasNextPage
+			});
+		}
+	});
+}
+//#endregion
+//#region src/tools/assessments_list_templates.ts
+const ListTemplatesSchema = PaginationSchema;
+function createAssessmentsListTemplatesTool(clients) {
+	const graphql = clients.graphql;
+	return defineTool({
+		name: "assessments_list_templates",
+		description: "List all available assessment templates. Note: Cursor pagination is not supported by the Transcend API for templates - use limit to control results (max 100).",
+		category: "Assessments",
+		readOnly: true,
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true
+		},
+		zodSchema: ListTemplatesSchema,
+		handler: async ({ limit, cursor }) => {
+			const result = await graphql.listAssessmentTemplates({
+				first: limit,
+				after: cursor
+			});
+			return createListResult(result.nodes, {
+				totalCount: result.totalCount,
+				hasNextPage: result.pageInfo?.hasNextPage
+			});
+		}
+	});
+}
+//#endregion
+//#region src/tools/assessments_prefill.ts
+const PrefillSchema = z.object({
+	title: z.string().describe("Title for the new assessment form"),
+	template_id: z.string().optional().describe("Template ID to create the form from. Will auto-resolve to the first matching assessment group."),
+	assessment_group_id: z.string().optional().describe("Assessment group ID (alternative to template_id)"),
+	answers: z.record(z.string(), z.union([z.string(), z.array(z.string())])).describe("Map of answers keyed by question title or referenceId. Values should be strings for text/single-select, or arrays of strings for multi-select."),
+	assignee_ids: z.array(z.string()).optional().describe("Internal user IDs to assign the form to (optional)"),
+	assignee_emails: z.array(z.string()).optional().describe("External email addresses to assign the form to (optional)"),
+	reviewer_ids: z.array(z.string()).optional().describe("User IDs to set as reviewers (optional)"),
+	submit_for_review: z.boolean().optional().describe("Whether to automatically submit the form for review after prefilling (default: false)")
+});
+function createAssessmentsPrefillTool(clients) {
+	const graphql = clients.graphql;
+	return defineTool({
+		name: "assessments_prefill",
+		description: "Convenience tool: Create a new assessment form, AI-prefill all the answers, and assign it to a reviewer. Combines: create form → get questions → answer each question → assign reviewers → optionally submit for review. Provide answers as a map of {questionTitle: answer} or {referenceId: answer}. For SINGLE_SELECT/MULTI_SELECT, the answer should match the exact text of the answer option(s). For text questions, provide the free-text answer string. For multi-select, provide an array of answer option values.",
+		category: "Assessments",
+		readOnly: false,
+		confirmationHint: "Creates assessment, prefills answers, assigns reviewers",
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: false
+		},
+		zodSchema: PrefillSchema,
+		handler: async ({ answers, title, assessment_group_id, template_id, assignee_ids, assignee_emails, reviewer_ids, submit_for_review }) => {
+			let assessmentGroupId = assessment_group_id;
+			if (!assessmentGroupId && template_id) {
+				const resolved = await resolveTemplateToGroupId(graphql, template_id);
+				if ("error" in resolved) return resolved.error;
+				assessmentGroupId = resolved.groupId;
+			}
+			if (!assessmentGroupId) return createToolResult(false, void 0, "Either template_id or assessment_group_id is required.");
+			const assessmentId = (await graphql.createAssessment({
+				title,
+				assessmentGroupId
+			})).id;
+			const fullForm = await graphql.getAssessment(assessmentId);
+			if (!fullForm.sections || fullForm.sections.length === 0) return createToolResult(true, {
+				assessment: fullForm,
+				message: "Assessment created but has no sections/questions to prefill.",
+				answersApplied: 0
+			});
+			const results = [];
+			let answersApplied = 0;
+			let answersSkipped = 0;
+			for (const section of fullForm.sections) {
+				if (!section.questions) continue;
+				for (const question of section.questions) {
+					const answerKey = Object.keys(answers).find((key) => key === question.referenceId || key.toLowerCase() === (question.title || "").toLowerCase() || key === question.id);
+					if (!answerKey) {
+						results.push({
+							question: question.title || question.id,
+							status: "skipped"
+						});
+						answersSkipped++;
+						continue;
+					}
+					const answerValue = answers[answerKey];
+					if (answerValue === void 0) {
+						results.push({
+							question: question.title || question.id,
+							status: "skipped"
+						});
+						answersSkipped++;
+						continue;
+					}
+					try {
+						const qType = (question.type || "").toUpperCase();
+						if (qType === "SINGLE_SELECT" || qType === "MULTI_SELECT") {
+							const answerValues = Array.isArray(answerValue) ? answerValue : [answerValue];
+							const matchedIds = [];
+							for (const val of answerValues) {
+								const matchedOption = (question.answerOptions || []).find((opt) => opt.value.toLowerCase() === val.toLowerCase());
+								if (matchedOption) matchedIds.push(matchedOption.id);
+							}
+							if (matchedIds.length > 0) {
+								await graphql.selectAssessmentQuestionAnswers({
+									assessmentQuestionId: question.id,
+									assessmentAnswerIds: matchedIds
+								});
+								answersApplied++;
+								results.push({
+									question: question.title || question.id,
+									status: "answered",
+									answer: answerValues.join(", ")
+								});
+							} else {
+								await graphql.selectAssessmentQuestionAnswers({
+									assessmentQuestionId: question.id,
+									assessmentAnswerValues: answerValues.map((v) => ({
+										value: v,
+										isUserCreated: true
+									}))
+								});
+								answersApplied++;
+								results.push({
+									question: question.title || question.id,
+									status: "answered (custom value)",
+									answer: answerValues.join(", ")
+								});
+							}
+						} else {
+							const textValue = Array.isArray(answerValue) ? answerValue.join("\n") : answerValue;
+							await graphql.selectAssessmentQuestionAnswers({
+								assessmentQuestionId: question.id,
+								assessmentAnswerValues: [{
+									value: textValue,
+									isUserCreated: true
+								}]
+							});
+							answersApplied++;
+							results.push({
+								question: question.title || question.id,
+								status: "answered",
+								answer: textValue.length > 100 ? textValue.substring(0, 100) + "..." : textValue
+							});
+						}
+					} catch (err) {
+						results.push({
+							question: question.title || question.id,
+							status: `error: ${err instanceof Error ? err.message : String(err)}`
+						});
+					}
+				}
+			}
+			let assignmentResult = null;
+			if (assignee_ids || assignee_emails) assignmentResult = await graphql.updateAssessmentFormAssignees({
+				id: assessmentId,
+				assigneeIds: assignee_ids,
+				externalAssigneeEmails: assignee_emails
+			});
+			if (reviewer_ids) await graphql.updateAssessment({
+				id: assessmentId,
+				reviewerIds: reviewer_ids
+			});
+			let submitResult = null;
+			if (submit_for_review) {
+				const sectionIds = fullForm.sections.map((s) => s.id);
+				if (sectionIds.length > 0) submitResult = await graphql.submitAssessmentForReview({
+					id: assessmentId,
+					assessmentSectionIds: sectionIds
+				});
+			}
+			return createToolResult(true, {
+				assessmentId,
+				title,
+				answersApplied,
+				answersSkipped,
+				totalQuestions: results.length,
+				results,
+				assignment: assignmentResult ? {
+					status: assignmentResult.status,
+					message: "Assignees updated"
+				} : null,
+				submittedForReview: !!submitResult,
+				message: `Assessment "${title}" created and prefilled with ${answersApplied}/${results.length} answers. ` + (assignmentResult ? `Assigned to reviewers. ` : "") + (submitResult ? "Submitted for review." : "Ready for manual submission.")
+			});
+		}
+	});
+}
+//#endregion
+//#region src/tools/assessments_submit_response.ts
+const SubmitResponseSchema = z.object({
+	assessment_id: z.string().describe("ID of the assessment to submit for review"),
+	assessment_section_ids: z.array(z.string()).describe("Array of section IDs to submit for review. Required by the API.")
+});
+function createAssessmentsSubmitResponseTool(clients) {
+	const graphql = clients.graphql;
+	return defineTool({
+		name: "assessments_submit_response",
+		description: "Submit an assessment form for review. Optionally specify which sections to submit. This transitions the assessment toward the IN_REVIEW status.",
+		category: "Assessments",
+		readOnly: false,
+		confirmationHint: "Submits assessment for review — cannot be undone",
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: true,
+			idempotentHint: false
+		},
+		zodSchema: SubmitResponseSchema,
+		handler: async ({ assessment_id, assessment_section_ids }) => {
+			return createToolResult(true, {
+				assessment: await graphql.submitAssessmentForReview({
+					id: assessment_id,
+					assessmentSectionIds: assessment_section_ids
+				}),
+				message: "Assessment submitted for review successfully"
+			});
+		}
+	});
+}
+//#endregion
+//#region src/tools/assessments_update.ts
+const UpdateAssessmentSchema = z.object({
+	assessment_id: z.string().describe("ID of the assessment to update"),
+	title: z.string().optional().describe("New title for the assessment"),
+	description: z.string().optional().describe("New description"),
+	reviewer_ids: z.array(z.string()).optional().describe("IDs of users assigned to review this assessment"),
+	due_date: z.string().optional().describe("New due date (ISO format)"),
+	status: AssessmentStatusEnum.optional().describe("New status")
+});
+function createAssessmentsUpdateTool(clients) {
+	const graphql = clients.graphql;
+	return defineTool({
+		name: "assessments_update",
+		description: "Update an existing assessment",
+		category: "Assessments",
+		readOnly: false,
+		confirmationHint: "Updates the assessment",
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: true
+		},
+		zodSchema: UpdateAssessmentSchema,
+		handler: async ({ assessment_id, title, description, reviewer_ids, due_date, status }) => {
+			return createToolResult(true, {
+				assessment: await graphql.updateAssessment({
+					id: assessment_id,
+					title,
+					description,
+					reviewerIds: reviewer_ids,
+					dueDate: due_date,
+					status
+				}),
+				message: "Assessment updated successfully"
+			});
+		}
+	});
+}
+//#endregion
+//#region src/tools/assessments_update_assignees.ts
+const UpdateAssigneesSchema = z.object({
+	assessment_id: z.string().describe("ID of the assessment form to update assignees for"),
+	assignee_ids: z.array(z.string()).optional().describe("Array of internal user IDs to assign to the assessment"),
+	external_assignee_emails: z.array(z.string()).optional().describe("Array of external email addresses to assign to the assessment")
+});
+function createAssessmentsUpdateAssigneesTool(clients) {
+	const graphql = clients.graphql;
+	return defineTool({
+		name: "assessments_update_assignees",
+		description: "Assign internal users (by ID) or external users (by email) to an assessment form. This also transitions DRAFT assessments to SHARED status.",
+		category: "Assessments",
+		readOnly: false,
+		confirmationHint: "Assigns users to the assessment form",
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: true
+		},
+		zodSchema: UpdateAssigneesSchema,
+		handler: async ({ assessment_id, assignee_ids, external_assignee_emails }) => {
+			const result = await graphql.updateAssessmentFormAssignees({
+				id: assessment_id,
+				assigneeIds: assignee_ids,
+				externalAssigneeEmails: external_assignee_emails
+			});
+			return createToolResult(true, {
+				assessment: result,
+				message: `Assessment assignees updated successfully. Status: ${result.status}`
+			});
+		}
+	});
+}
+//#endregion
+//#region src/tools/index.ts
+function getAssessmentTools(clients) {
+	return [
+		createAssessmentsListTool(clients),
+		createAssessmentsGetTool(clients),
+		createAssessmentsCreateTool(clients),
+		createAssessmentsCreateGroupTool(clients),
+		createAssessmentsListGroupsTool(clients),
+		createAssessmentsUpdateTool(clients),
+		createAssessmentsListTemplatesTool(clients),
+		createAssessmentsUpdateAssigneesTool(clients),
+		createAssessmentsAnswerQuestionTool(clients),
+		createAssessmentsSubmitResponseTool(clients),
+		createAssessmentsCreateTemplateTool(clients),
+		createAssessmentsAddSectionTool(clients),
+		createAssessmentsExportTemplateTool(clients),
+		createAssessmentsPrefillTool(clients)
+	];
+}
+//#endregion
+//#region src/graphql.ts
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function generateUUID() {
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+		const r = Math.random() * 16 | 0;
+		return (c === "x" ? r : r & 3 | 8).toString(16);
+	});
+}
+function normalizeQuestion(q) {
+	let { referenceId, subType, allowSelectOther, requireRiskEvaluation } = q;
+	if (!referenceId || !UUID_RE.test(referenceId)) referenceId = generateUUID();
+	if (allowSelectOther && (!subType || subType === "NONE")) subType = "CUSTOM";
+	if (requireRiskEvaluation && !q.riskFrameworkId) requireRiskEvaluation = false;
+	return {
+		title: q.title,
+		type: q.type,
+		subType: subType || "NONE",
+		placeholder: q.placeholder || "",
+		description: q.description || "",
+		isRequired: q.isRequired ?? false,
+		referenceId,
+		answerOptions: q.answerOptions || [],
+		allowSelectOther: allowSelectOther ?? false,
+		requireRiskEvaluation: requireRiskEvaluation ?? false,
+		...q.riskLogic && { riskLogic: q.riskLogic },
+		...q.riskCategoryIds && { riskCategoryIds: q.riskCategoryIds },
+		...q.riskFrameworkId && { riskFrameworkId: q.riskFrameworkId },
+		...q.displayLogic && { displayLogic: q.displayLogic }
+	};
+}
+var AssessmentsMixin = class extends TranscendGraphQLBase {
+	async listAssessments(options) {
+		const data = await this.makeRequest(`
+      query ListAssessments($first: Int, $filterBy: AssessmentFormFiltersInput) {
+        assessmentForms(first: $first, filterBy: $filterBy) {
+          nodes {
+            id
+            title
+            status
+            createdAt
+          }
+          totalCount
+        }
+      }
+    `, {
+			first: Math.min(options?.first || 50, 100),
+			filterBy: options?.filterBy?.statuses ? { statuses: options.filterBy.statuses } : void 0
+		});
+		return {
+			nodes: data.assessmentForms.nodes,
+			pageInfo: {
+				hasNextPage: data.assessmentForms.nodes.length < data.assessmentForms.totalCount,
+				hasPreviousPage: false
+			},
+			totalCount: data.assessmentForms.totalCount
+		};
+	}
+	async getAssessment(id) {
+		const node = (await this.makeRequest(`
+      query GetAssessment($ids: [ID!]!) {
+        assessmentForms(first: 1, filterBy: { ids: $ids }) {
+          nodes {
+            id
+            title
+            status
+            dueDate
+            submittedAt
+            createdAt
+            updatedAt
+            sections {
+              id
+              title
+              index
+              status
+              questions {
+                id
+                title
+                index
+                type
+                subType
+                description
+                isRequired
+                placeholder
+                answerOptions {
+                  id
+                  index
+                  value
+                }
+                selectedAnswers {
+                  id
+                  index
+                  value
+                }
+              }
+            }
+          }
+        }
+      }
+    `, { ids: [id] })).assessmentForms.nodes[0];
+		if (!node) throw new Error(`Assessment with id ${id} not found`);
+		return node;
+	}
+	async selectAssessmentQuestionAnswers(input) {
+		return (await this.makeRequest(`
+      mutation SelectAssessmentQuestionAnswers($input: SelectAssessmentQuestionAnswerInput!) {
+        selectAssessmentQuestionAnswers(input: $input) {
+          selectedAnswers {
+            id
+            index
+            value
+          }
+        }
+      }
+    `, { input })).selectAssessmentQuestionAnswers.selectedAnswers;
+	}
+	async updateAssessmentFormAssignees(input) {
+		return (await this.makeRequest(`
+      mutation UpdateAssessmentFormAssignees($input: UpdateAssessmentFormAssigneesInput!) {
+        updateAssessmentFormAssignees(input: $input) {
+          assessmentForm {
+            id
+            title
+            status
+          }
+        }
+      }
+    `, { input })).updateAssessmentFormAssignees.assessmentForm;
+	}
+	async listAssessmentGroups(options) {
+		const data = await this.makeRequest(`
+      query ListAssessmentGroups($first: Int) {
+        assessmentGroups(first: $first) {
+          nodes {
+            id
+            title
+            assessmentFormTemplate {
+              id
+              title
+            }
+          }
+          totalCount
+        }
+      }
+    `, { first: Math.min(options?.first || 50, 100) });
+		return {
+			nodes: data.assessmentGroups.nodes,
+			pageInfo: {
+				hasNextPage: data.assessmentGroups.nodes.length < data.assessmentGroups.totalCount,
+				hasPreviousPage: false
+			},
+			totalCount: data.assessmentGroups.totalCount
+		};
+	}
+	async createAssessmentGroup(input) {
+		return (await this.makeRequest(`
+      mutation CreateAssessmentGroup($input: CreateAssessmentGroupInput!) {
+        createAssessmentGroup(input: $input) {
+          assessmentGroup {
+            id
+            title
+          }
+        }
+      }
+    `, { input })).createAssessmentGroup.assessmentGroup;
+	}
+	async createAssessment(input) {
+		const mutation = `
+      mutation CreateAssessmentForms($input: CreateAssessmentFormsInput!) {
+        createAssessmentForms(input: $input) {
+          assessmentForms {
+            id
+            title
+            status
+            createdAt
+          }
+        }
+      }
+    `;
+		const batchInput = { assessmentForms: [{
+			title: input.title,
+			assessmentGroupId: input.assessmentGroupId,
+			...input.assigneeIds && { assigneeIds: input.assigneeIds }
+		}] };
+		const created = (await this.makeRequest(mutation, { input: batchInput })).createAssessmentForms.assessmentForms[0];
+		if (!created) throw new Error("createAssessmentForms returned an empty array");
+		return created;
+	}
+	async updateAssessment(input) {
+		return (await this.makeRequest(`
+      mutation UpdateAssessmentForm($input: UpdateAssessmentFormInput!) {
+        updateAssessmentForm(input: $input) {
+          assessmentForm {
+            id
+            title
+            description
+            status
+            dueDate
+            updatedAt
+          }
+        }
+      }
+    `, { input })).updateAssessmentForm.assessmentForm;
+	}
+	async listAssessmentTemplates(options) {
+		const data = await this.makeRequest(`
+      query ListAssessmentTemplates($first: Int) {
+        assessmentFormTemplates(first: $first) {
+          nodes {
+            id
+            title
+            description
+          }
+          totalCount
+        }
+      }
+    `, { first: Math.min(options?.first || 50, 100) });
+		return {
+			nodes: data.assessmentFormTemplates.nodes.map((t) => ({
+				id: t.id,
+				title: t.title,
+				description: t.description || void 0,
+				version: "1.0.0",
+				isActive: true,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString()
+			})),
+			pageInfo: {
+				hasNextPage: data.assessmentFormTemplates.nodes.length < data.assessmentFormTemplates.totalCount,
+				hasPreviousPage: false
+			},
+			totalCount: data.assessmentFormTemplates.totalCount
+		};
+	}
+	async submitAssessmentForReview(input) {
+		await this.makeRequest(`
+      mutation SubmitAssessmentFormForReview($input: SubmitAssessmentFormForReviewInput!) {
+        submitAssessmentFormForReview(input: $input) {
+          clientMutationId
+        }
+      }
+    `, { input });
+		return this.getAssessment(input.id);
+	}
+	async createAssessmentFormTemplate(input) {
+		const mutation = `
+      mutation CreateAssessmentFormTemplate($input: CreateAssessmentFormTemplateInput!) {
+        createAssessmentFormTemplate(input: $input) {
+          assessmentFormTemplate {
+            id
+            title
+            status
+            sections {
+              id
+              title
+              index
+              questions {
+                id
+                title
+                index
+                type
+                subType
+                referenceId
+              }
+            }
+          }
+        }
+      }
+    `;
+		const gqlInput = {
+			title: input.title,
+			description: input.description || "",
+			status: input.status || "DRAFT",
+			source: input.source || "MANUAL"
+		};
+		if (input.sections) gqlInput.sections = input.sections.map((s) => ({
+			title: s.title,
+			questions: s.questions?.map(normalizeQuestion) || []
+		}));
+		return (await this.makeRequest(mutation, { input: gqlInput })).createAssessmentFormTemplate.assessmentFormTemplate;
+	}
+	async createAssessmentSection(input) {
+		const mutation = `
+      mutation CreateAssessmentSection($input: CreateAssessmentSectionInput!) {
+        createAssessmentSection(input: $input) {
+          assessmentSection {
+            id
+            title
+            index
+            questions {
+              id
+              title
+              index
+              type
+              subType
+              referenceId
+            }
+          }
+        }
+      }
+    `;
+		const gqlInput = {
+			assessmentFormTemplateId: input.assessmentFormTemplateId,
+			title: input.title
+		};
+		if (input.questions) gqlInput.questions = input.questions.map(normalizeQuestion);
+		return (await this.makeRequest(mutation, { input: gqlInput })).createAssessmentSection.assessmentSection;
+	}
+	async createAssessmentQuestions(assessmentSectionId, questions) {
+		const mutation = `
+      mutation CreateAssessmentQuestions($input: [CreateAssessmentQuestionInput!]!) {
+        createAssessmentQuestions(input: $input) {
+          assessmentQuestions {
+            id
+            title
+            index
+            type
+            subType
+            referenceId
+          }
+        }
+      }
+    `;
+		const input = questions.map((q) => ({
+			title: q.title,
+			type: q.type,
+			subType: q.subType || "NONE",
+			placeholder: q.placeholder || "",
+			description: q.description || "",
+			isRequired: q.isRequired ?? false,
+			referenceId: q.referenceId,
+			assessmentSectionId,
+			answerOptions: q.answerOptions || [],
+			allowSelectOther: q.allowSelectOther ?? false,
+			requireRiskEvaluation: q.requireRiskEvaluation ?? false
+		}));
+		return (await this.makeRequest(mutation, { input })).createAssessmentQuestions.assessmentQuestions;
+	}
+	async getAssessmentFormTemplate(templateId) {
+		const node = (await this.makeRequest(`
+      query GetAssessmentFormTemplate($ids: [ID!]) {
+        assessmentFormTemplates(first: 1, filterBy: { ids: $ids }) {
+          nodes {
+            id
+            title
+            description
+            status
+            source
+            createdAt
+            updatedAt
+            sections {
+              id
+              title
+              index
+              questions {
+                id
+                title
+                index
+                type
+                subType
+                description
+                placeholder
+                isRequired
+                referenceId
+                allowSelectOther
+                requireRiskEvaluation
+                answerOptions {
+                  id
+                  index
+                  value
+                }
+              }
+            }
+          }
+        }
+      }
+    `, { ids: [templateId] })).assessmentFormTemplates.nodes[0];
+		if (!node) throw new Error(`Assessment template with id ${templateId} not found`);
+		return node;
+	}
+};
+//#endregion
+export { AnswerQuestionValueSchema as _, SubmitResponseSchema as a, ListGroupsSchema as c, GetAssessmentSchema as d, ExportTemplateSchema as f, AnswerQuestionSchema as g, CreateAssessmentSchema as h, UpdateAssessmentSchema as i, AssessmentStatusEnum as l, CreateGroupSchema as m, getAssessmentTools as n, PrefillSchema as o, CreateTemplateSchema as p, UpdateAssigneesSchema as r, ListTemplatesSchema as s, AssessmentsMixin as t, ListAssessmentsSchema as u, AddSectionSchema as v };
+
+//# sourceMappingURL=graphql-BVBi59RV.mjs.map