@trycompai/mcp-server 0.3.2 → 0.3.3

package/src/models/exchangecodedto.ts

@@ -5,8 +5,10 @@
 
 import * as z from "zod";
 
-export type ExchangeCodeDto = {};
+export type ExchangeCodeDto = { code: string };
 
-export const ExchangeCodeDto$zodSchema: z.ZodType<ExchangeCodeDto> = z.object(
-  {},
-);
+export const ExchangeCodeDto$zodSchema: z.ZodType<ExchangeCodeDto> = z.object({
+  code: z.string().describe(
+    "Single-use authorization code issued to the device agent, exchanged for a session token",
+  ),
+});

package/src/models/exportbyiddto.ts

@@ -4,7 +4,41 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
 
-export type ExportByIdDto = {};
+/**
+ * File format to export the questionnaire in.
+ */
+export const ExportByIdDtoFormat = {
+  Xlsx: "xlsx",
+  Csv: "csv",
+  Pdf: "pdf",
+} as const;
+/**
+ * File format to export the questionnaire in.
+ */
+export type ExportByIdDtoFormat = ClosedEnum<typeof ExportByIdDtoFormat>;
+
+export const ExportByIdDtoFormat$zodSchema = z.enum([
+  "xlsx",
+  "csv",
+  "pdf",
+]).describe("File format to export the questionnaire in.");
+
+export type ExportByIdDto = {
+  questionnaireId: string;
+  organizationId: string;
+  format: ExportByIdDtoFormat;
+};
 
-export const ExportByIdDto$zodSchema: z.ZodType<ExportByIdDto> = z.object({});
+export const ExportByIdDto$zodSchema: z.ZodType<ExportByIdDto> = z.object({
+  format: ExportByIdDtoFormat$zodSchema.describe(
+    "File format to export the questionnaire in.",
+  ),
+  organizationId: z.string().describe(
+    "Organization ID. The API overwrites this with the authenticated active organization.",
+  ),
+  questionnaireId: z.string().describe(
+    "Questionnaire to export, including all of its answers.",
+  ),
+});

package/src/models/exportismsdocumentdto.ts

@@ -9,22 +9,24 @@ import { ClosedEnum } from "../types/enums.js";
 /**
  * File format to export the ISMS document as
  */
-export const Format = {
+export const ExportIsmsDocumentDtoFormat = {
   Pdf: "pdf",
   Docx: "docx",
 } as const;
 /**
  * File format to export the ISMS document as
  */
-export type Format = ClosedEnum<typeof Format>;
+export type ExportIsmsDocumentDtoFormat = ClosedEnum<
+  typeof ExportIsmsDocumentDtoFormat
+>;
 
-export const Format$zodSchema = z.enum([
+export const ExportIsmsDocumentDtoFormat$zodSchema = z.enum([
   "pdf",
   "docx",
 ]).describe("File format to export the ISMS document as");
 
 export type ExportIsmsDocumentDto = {
-  format: Format;
+  format: ExportIsmsDocumentDtoFormat;
   versionId?: string | undefined;
   draft?: boolean | undefined;
 };
@@ -34,7 +36,7 @@ export const ExportIsmsDocumentDto$zodSchema: z.ZodType<ExportIsmsDocumentDto> =
     draft: z.boolean().optional().describe(
       "Export the WORKING DRAFT rather than the published version — the customer's attached file when the document is in upload mode, or a live render of the form when it is not. Cannot be combined with versionId: the two name different artifacts, so asking for both is rejected.",
     ),
-    format: Format$zodSchema.describe(
+    format: ExportIsmsDocumentDtoFormat$zodSchema.describe(
       "File format to export the ISMS document as",
     ),
     versionId: z.string().optional().describe(

package/src/models/exportquestionnairedto.ts

@@ -4,9 +4,61 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
 
-export type ExportQuestionnaireDto = {};
+/**
+ * File format to export the answered questionnaire in.
+ */
+export const ExportQuestionnaireDtoFormat = {
+  Pdf: "pdf",
+  Csv: "csv",
+  Xlsx: "xlsx",
+} as const;
+/**
+ * File format to export the answered questionnaire in.
+ */
+export type ExportQuestionnaireDtoFormat = ClosedEnum<
+  typeof ExportQuestionnaireDtoFormat
+>;
+
+export const ExportQuestionnaireDtoFormat$zodSchema = z.enum([
+  "pdf",
+  "csv",
+  "xlsx",
+]).describe("File format to export the answered questionnaire in.");
+
+export type ExportQuestionnaireDto = {
+  fileData: string;
+  fileType: string;
+  fileName?: string | undefined;
+  vendorName?: string | undefined;
+  organizationId: string;
+  format: ExportQuestionnaireDtoFormat;
+  exportInAllExtensions?: boolean | undefined;
+};
 
 export const ExportQuestionnaireDto$zodSchema: z.ZodType<
   ExportQuestionnaireDto
-> = z.object({});
+> = z.object({
+  exportInAllExtensions: z.boolean().optional().describe(
+    "Return a ZIP containing the questionnaire in every format (PDF, CSV and XLSX) instead of one file.",
+  ),
+  fileData: z.string().describe(
+    "Base64-encoded contents of the questionnaire file.",
+  ),
+  fileName: z.string().optional().describe(
+    "Original name of the questionnaire file.",
+  ),
+  fileType: z.string().describe(
+    "MIME type of the file (PDF, image, XLSX, CSV, TXT).",
+  ),
+  format: ExportQuestionnaireDtoFormat$zodSchema.describe(
+    "File format to export the answered questionnaire in.",
+  ),
+  organizationId: z.string().describe(
+    "Organization ID. The API overwrites this with the authenticated active organization.",
+  ),
+  vendorName: z.string().optional().describe(
+    "Name of the vendor the questionnaire came from.",
+  ),
+});

package/src/models/exportsoadocumentdto.ts

@@ -4,8 +4,38 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
 
-export type ExportSOADocumentDto = {};
+/**
+ * File format to export the SOA document as
+ */
+export const ExportSOADocumentDtoFormat = {
+  Pdf: "pdf",
+} as const;
+/**
+ * File format to export the SOA document as
+ */
+export type ExportSOADocumentDtoFormat = ClosedEnum<
+  typeof ExportSOADocumentDtoFormat
+>;
+
+export const ExportSOADocumentDtoFormat$zodSchema = z.enum([
+  "pdf",
+]).describe("File format to export the SOA document as");
+
+export type ExportSOADocumentDto = {
+  documentId: string;
+  organizationId: string;
+  format: ExportSOADocumentDtoFormat;
+};
 
 export const ExportSOADocumentDto$zodSchema: z.ZodType<ExportSOADocumentDto> = z
-  .object({});
+  .object({
+    documentId: z.string().describe("ID of the SOA document to export"),
+    format: ExportSOADocumentDtoFormat$zodSchema.describe(
+      "File format to export the SOA document as",
+    ),
+    organizationId: z.string().describe(
+      "ID of the organization that owns the SOA document",
+    ),
+  });

package/src/models/parsequestionnairedto.ts

@@ -5,7 +5,25 @@
 
 import * as z from "zod";
 
-export type ParseQuestionnaireDto = {};
+export type ParseQuestionnaireDto = {
+  fileData: string;
+  fileType: string;
+  fileName?: string | undefined;
+  vendorName?: string | undefined;
+};
 
 export const ParseQuestionnaireDto$zodSchema: z.ZodType<ParseQuestionnaireDto> =
-  z.object({});
+  z.object({
+    fileData: z.string().describe(
+      "Base64-encoded contents of the questionnaire file.",
+    ),
+    fileName: z.string().optional().describe(
+      "Original name of the questionnaire file.",
+    ),
+    fileType: z.string().describe(
+      "MIME type of the file (PDF, image, XLSX, CSV, TXT).",
+    ),
+    vendorName: z.string().optional().describe(
+      "Name of the vendor the questionnaire came from.",
+    ),
+  });

package/src/models/processdocumentsdto.ts

@@ -5,7 +5,17 @@
 
 import * as z from "zod";
 
-export type ProcessDocumentsDto = {};
+export type ProcessDocumentsDto = {
+  organizationId: string;
+  documentIds: Array<string>;
+};
 
 export const ProcessDocumentsDto$zodSchema: z.ZodType<ProcessDocumentsDto> = z
-  .object({});
+  .object({
+    documentIds: z.array(z.string()).describe(
+      "Knowledge base documents to index into the vector store. At least one is required.",
+    ),
+    organizationId: z.string().describe(
+      "Organization that owns the documents. Overwritten with the authenticated organization.",
+    ),
+  });

package/src/models/registerdevicedto.ts

@@ -4,8 +4,60 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
 
-export type RegisterDeviceDto = {};
+/**
+ * Operating system family the device runs
+ */
+export const Platform = {
+  Macos: "macos",
+  Windows: "windows",
+  Linux: "linux",
+} as const;
+/**
+ * Operating system family the device runs
+ */
+export type Platform = ClosedEnum<typeof Platform>;
+
+export const Platform$zodSchema = z.enum([
+  "macos",
+  "windows",
+  "linux",
+]).describe("Operating system family the device runs");
+
+export type RegisterDeviceDto = {
+  name: string;
+  hostname: string;
+  platform: Platform;
+  osVersion: string;
+  organizationId: string;
+  serialNumber?: string | undefined;
+  hardwareModel?: string | undefined;
+  agentVersion?: string | undefined;
+};
 
 export const RegisterDeviceDto$zodSchema: z.ZodType<RegisterDeviceDto> = z
-  .object({});
+  .object({
+    agentVersion: z.string().optional().describe(
+      "Version of the device agent performing the registration",
+    ),
+    hardwareModel: z.string().optional().describe(
+      "Hardware model identifier reported by the device",
+    ),
+    hostname: z.string().describe("Network hostname of the device"),
+    name: z.string().describe(
+      "Human-readable computer name reported by the device",
+    ),
+    organizationId: z.string().describe(
+      "ID of the organization to register the device under",
+    ),
+    osVersion: z.string().describe(
+      "Operating system version string reported by the device",
+    ),
+    platform: Platform$zodSchema.describe(
+      "Operating system family the device runs",
+    ),
+    serialNumber: z.string().optional().describe(
+      "Hardware serial number, used to match the device to an existing record",
+    ),
+  });

package/src/models/rollbackframeworkdto.ts

@@ -5,7 +5,11 @@
 
 import * as z from "zod";
 
-export type RollbackFrameworkDto = {};
+export type RollbackFrameworkDto = { syncOperationId: string };
 
 export const RollbackFrameworkDto$zodSchema: z.ZodType<RollbackFrameworkDto> = z
-  .object({});
+  .object({
+    syncOperationId: z.string().describe(
+      "ID of the framework sync operation to roll back",
+    ),
+  });

package/src/models/saveanswerdto.ts

@@ -4,7 +4,59 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
+import {
+  AnswerSourceDto,
+  AnswerSourceDto$zodSchema,
+} from "./answersourcedto.js";
 
-export type SaveAnswerDto = {};
+/**
+ * Whether the answer was AI-generated or written by a person.
+ */
+export const SaveAnswerDtoStatus = {
+  Generated: "generated",
+  Manual: "manual",
+} as const;
+/**
+ * Whether the answer was AI-generated or written by a person.
+ */
+export type SaveAnswerDtoStatus = ClosedEnum<typeof SaveAnswerDtoStatus>;
+
+export const SaveAnswerDtoStatus$zodSchema = z.enum([
+  "generated",
+  "manual",
+]).describe("Whether the answer was AI-generated or written by a person.");
+
+export type SaveAnswerDto = {
+  questionnaireId: string;
+  organizationId: string;
+  questionAnswerId?: string | undefined;
+  questionIndex?: number | undefined;
+  answer?: string | null | undefined;
+  sources?: Array<AnswerSourceDto> | undefined;
+  status: SaveAnswerDtoStatus;
+};
 
-export const SaveAnswerDto$zodSchema: z.ZodType<SaveAnswerDto> = z.object({});
+export const SaveAnswerDto$zodSchema: z.ZodType<SaveAnswerDto> = z.object({
+  answer: z.string().nullable().optional().describe(
+    "Answer text to store. Send null or empty to clear it.",
+  ),
+  organizationId: z.string().describe(
+    "Organization ID. The API overwrites this with the authenticated active organization.",
+  ),
+  questionAnswerId: z.string().optional().describe(
+    "Question/answer record to update. Provide this or questionIndex.",
+  ),
+  questionIndex: z.number().optional().describe(
+    "Zero-based position of the question in the questionnaire. Provide this or questionAnswerId.",
+  ),
+  questionnaireId: z.string().describe(
+    "Questionnaire that contains the answer being saved.",
+  ),
+  sources: z.array(AnswerSourceDto$zodSchema).optional().describe(
+    "Knowledge sources the answer was derived from.",
+  ),
+  status: SaveAnswerDtoStatus$zodSchema.describe(
+    "Whether the answer was AI-generated or written by a person.",
+  ),
+});

package/src/models/savemanualanswerdto.ts

@@ -5,7 +5,25 @@
 
 import * as z from "zod";
 
-export type SaveManualAnswerDto = {};
+export type SaveManualAnswerDto = {
+  question: string;
+  answer: string;
+  tags?: Array<string> | undefined;
+  sourceQuestionnaireId?: string | undefined;
+};
 
 export const SaveManualAnswerDto$zodSchema: z.ZodType<SaveManualAnswerDto> = z
-  .object({});
+  .object({
+    answer: z.string().describe(
+      "Answer text reused when generating questionnaire answers.",
+    ),
+    question: z.string().describe(
+      "Question this manual answer covers. Unique per organization, so re-sending it updates the answer.",
+    ),
+    sourceQuestionnaireId: z.string().optional().describe(
+      "Questionnaire this answer was originally saved from.",
+    ),
+    tags: z.array(z.string()).optional().describe(
+      "Tags used to categorize and search this manual answer.",
+    ),
+  });

package/src/models/savesoaanswerdto.ts

@@ -5,8 +5,34 @@
 
 import * as z from "zod";
 
-export type SaveSOAAnswerDto = {};
+export type SaveSOAAnswerDto = {
+  organizationId: string;
+  documentId: string;
+  questionId: string;
+  answer?: string | null | undefined;
+  isApplicable?: boolean | null | undefined;
+  justification?: string | null | undefined;
+};
 
 export const SaveSOAAnswerDto$zodSchema: z.ZodType<SaveSOAAnswerDto> = z.object(
-  {},
+  {
+    answer: z.string().nullable().optional().describe(
+      "Free-text answer for the question",
+    ),
+    documentId: z.string().describe(
+      "ID of the SOA document the answer belongs to",
+    ),
+    isApplicable: z.boolean().nullable().optional().describe(
+      "Whether the control is applicable to the organization; null when not yet decided",
+    ),
+    justification: z.string().nullable().optional().describe(
+      "Justification for including or excluding the control from the SOA",
+    ),
+    organizationId: z.string().describe(
+      "ID of the organization that owns the SOA document",
+    ),
+    questionId: z.string().describe(
+      "ID of the question being answered, from the document's SOA configuration",
+    ),
+  },
 );

package/src/models/searchcontrollersearchv1op.ts

@@ -0,0 +1,20 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: a591590c63de
+ */
+
+import * as z from "zod";
+
+export type SearchControllerSearchV1Request = {
+  q: string;
+  limit?: number | undefined;
+};
+
+export const SearchControllerSearchV1Request$zodSchema: z.ZodType<
+  SearchControllerSearchV1Request
+> = z.object({
+  limit: z.number().default(5).describe("Maximum results per entity type"),
+  q: z.string().describe(
+    "Search term, matched case-insensitively against names first, then descriptions. Terms shorter than 2 characters return no results.",
+  ),
+});

package/src/models/searchresponsedto.ts

@@ -0,0 +1,20 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: ab439ce9ac4b
+ */
+
+import * as z from "zod";
+import {
+  SearchResultDto,
+  SearchResultDto$zodSchema,
+} from "./searchresultdto.js";
+
+export type SearchResponseDto = { data: Array<SearchResultDto>; count: number };
+
+export const SearchResponseDto$zodSchema: z.ZodType<SearchResponseDto> = z
+  .object({
+    count: z.number().describe("Number of results returned"),
+    data: z.array(SearchResultDto$zodSchema).describe(
+      "Matches, grouped by entity kind in a stable order",
+    ),
+  });

package/src/models/searchresultdto.ts

@@ -0,0 +1,58 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 9c0fcf3d675d
+ */
+
+import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
+
+/**
+ * Entity kind this result points at
+ */
+export const SearchResultDtoType = {
+  Policy: "policy",
+  Task: "task",
+  Document: "document",
+  Person: "person",
+  Control: "control",
+  Vendor: "vendor",
+  Risk: "risk",
+} as const;
+/**
+ * Entity kind this result points at
+ */
+export type SearchResultDtoType = ClosedEnum<typeof SearchResultDtoType>;
+
+export const SearchResultDtoType$zodSchema = z.enum([
+  "policy",
+  "task",
+  "document",
+  "person",
+  "control",
+  "vendor",
+  "risk",
+]).describe("Entity kind this result points at");
+
+export type SearchResultDto = {
+  type: SearchResultDtoType;
+  id: string;
+  title: string;
+  subtitle: string | null;
+  status?: string | undefined;
+};
+
+export const SearchResultDto$zodSchema: z.ZodType<SearchResultDto> = z.object({
+  id: z.string().describe(
+    "Entity ID, usable against that entity’s own endpoints",
+  ),
+  status: z.string().optional().describe(
+    "Workflow status, when the entity kind has one",
+  ),
+  subtitle: z.string().nullable().describe(
+    "Truncated description, or null when the record has none",
+  ),
+  title: z.string().describe("Display name of the matched record"),
+  type: SearchResultDtoType$zodSchema.describe(
+    "Entity kind this result points at",
+  ),
+});

package/src/models/submitsoaforapprovaldto.ts

@@ -5,8 +5,22 @@
 
 import * as z from "zod";
 
-export type SubmitSOAForApprovalDto = {};
+export type SubmitSOAForApprovalDto = {
+  organizationId: string;
+  documentId: string;
+  approverId: string;
+};
 
 export const SubmitSOAForApprovalDto$zodSchema: z.ZodType<
   SubmitSOAForApprovalDto
-> = z.object({});
+> = z.object({
+  approverId: z.string().describe(
+    "Member ID of the approver the SOA document is submitted to",
+  ),
+  documentId: z.string().describe(
+    "ID of the SOA document to submit for approval",
+  ),
+  organizationId: z.string().describe(
+    "ID of the organization that owns the SOA document",
+  ),
+});

package/src/models/syncframeworkdto.ts

@@ -5,8 +5,12 @@
 
 import * as z from "zod";
 
-export type SyncFrameworkDto = {};
+export type SyncFrameworkDto = { targetVersionId: string };
 
 export const SyncFrameworkDto$zodSchema: z.ZodType<SyncFrameworkDto> = z.object(
-  {},
+  {
+    targetVersionId: z.string().describe(
+      "ID of the framework version to sync the instance up to",
+    ),
+  },
 );

package/src/models/vendorscontrollersearchglobalvendorsv1op.ts

@@ -7,10 +7,19 @@ import * as z from "zod";
 
 export type VendorsControllerSearchGlobalVendorsV1Request = {
   name?: string | undefined;
+  lite?: string | undefined;
+  suggest?: string | undefined;
 };
 
 export const VendorsControllerSearchGlobalVendorsV1Request$zodSchema: z.ZodType<
   VendorsControllerSearchGlobalVendorsV1Request
 > = z.object({
-  name: z.string().describe("Vendor name to search for").optional(),
+  lite: z.string().describe(
+    "Return only the fields a suggestion list renders, omitting the risk assessment payload",
+  ).optional(),
+  name: z.string().describe("Vendor name, or part of one, to search for")
+    .optional(),
+  suggest: z.string().describe(
+    "When nothing matches, resolve the name and return the vendor the caller probably meant. Off by default: it can reach a paid provider, so set it once a name has been committed rather than on every keystroke.",
+  ).optional(),
 });

package/src/tool-names.ts

@@ -1524,6 +1524,10 @@ export const toolNames: Array<{ name: string; description: string }>= [
     "name": "get-sync-history",
     "description": "Get sync history for a framework instance\n\nGet sync history for a framework instance in Comp AI. Manage SOC 2, ISO 27001, HIPAA, GDPR, and custom framework instances, requirements, scores, and sync history."
   },
+  {
+    "name": "search",
+    "description": "Search compliance records\n\nSearch policies, tasks, documents, people, controls, vendors, and risks by keyword in one call to locate a compliance record before fetching it by ID."
+  },
   {
     "name": "get-audit-logs",
     "description": "List audit logs\n\nList organization audit logs for compliance activity, access changes, evidence updates, and customer-facing review events."