@trycompai/mcp-server 0.3.5 → 0.3.7

package/src/models/policiescontrollergetpolicyevidencetasksv1op.ts

@@ -4,6 +4,80 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
+
+export const PoliciesControllerGetPolicyEvidenceTasksV1Status = {
+  Todo: "todo",
+  InProgress: "in_progress",
+  InReview: "in_review",
+  Done: "done",
+  NotRelevant: "not_relevant",
+  Failed: "failed",
+} as const;
+export type PoliciesControllerGetPolicyEvidenceTasksV1Status = ClosedEnum<
+  typeof PoliciesControllerGetPolicyEvidenceTasksV1Status
+>;
+
+export const PoliciesControllerGetPolicyEvidenceTasksV1Status$zodSchema = z
+  .enum([
+    "todo",
+    "in_progress",
+    "in_review",
+    "done",
+    "not_relevant",
+    "failed",
+  ]);
+
+export const PoliciesControllerGetPolicyEvidenceTasksV1Frequency = {
+  Daily: "daily",
+  Weekly: "weekly",
+  Monthly: "monthly",
+  Quarterly: "quarterly",
+  Yearly: "yearly",
+} as const;
+export type PoliciesControllerGetPolicyEvidenceTasksV1Frequency = ClosedEnum<
+  typeof PoliciesControllerGetPolicyEvidenceTasksV1Frequency
+>;
+
+export const PoliciesControllerGetPolicyEvidenceTasksV1Frequency$zodSchema = z
+  .enum([
+    "daily",
+    "weekly",
+    "monthly",
+    "quarterly",
+    "yearly",
+  ]);
+
+export const AutomationStatus = {
+  Automated: "AUTOMATED",
+  Manual: "MANUAL",
+} as const;
+export type AutomationStatus = ClosedEnum<typeof AutomationStatus>;
+
+export const AutomationStatus$zodSchema = z.enum([
+  "AUTOMATED",
+  "MANUAL",
+]);
+
+/**
+ * How the request was authenticated
+ */
+export const PoliciesControllerGetPolicyEvidenceTasksV1AuthType = {
+  ApiKey: "api-key",
+  Session: "session",
+} as const;
+/**
+ * How the request was authenticated
+ */
+export type PoliciesControllerGetPolicyEvidenceTasksV1AuthType = ClosedEnum<
+  typeof PoliciesControllerGetPolicyEvidenceTasksV1AuthType
+>;
+
+export const PoliciesControllerGetPolicyEvidenceTasksV1AuthType$zodSchema = z
+  .enum([
+    "api-key",
+    "session",
+  ]).describe("How the request was authenticated");
 
 export type PoliciesControllerGetPolicyEvidenceTasksV1Request = {
   xOrganizationId?: string | undefined;
@@ -17,3 +91,123 @@ export const PoliciesControllerGetPolicyEvidenceTasksV1Request$zodSchema:
       "Organization ID (required for session auth, optional for API key auth)",
     ).optional(),
   });
+
+/**
+ * Policy not found
+ */
+export type PoliciesControllerGetPolicyEvidenceTasksV1NotFoundResponseBody = {
+  message?: string | undefined;
+};
+
+export const PoliciesControllerGetPolicyEvidenceTasksV1NotFoundResponseBody$zodSchema:
+  z.ZodType<PoliciesControllerGetPolicyEvidenceTasksV1NotFoundResponseBody> = z
+    .object({
+      message: z.string().optional(),
+    }).describe("Policy not found");
+
+export type Control = { id: string; name: string };
+
+export const Control$zodSchema: z.ZodType<Control> = z.object({
+  id: z.string(),
+  name: z.string(),
+});
+
+export type PoliciesControllerGetPolicyEvidenceTasksV1Task = {
+  id: string;
+  title: string;
+  status: PoliciesControllerGetPolicyEvidenceTasksV1Status;
+  frequency?:
+    | PoliciesControllerGetPolicyEvidenceTasksV1Frequency
+    | null
+    | undefined;
+  department?: string | null | undefined;
+  automationStatus: AutomationStatus;
+  assigneeId?: string | null | undefined;
+};
+
+export const PoliciesControllerGetPolicyEvidenceTasksV1Task$zodSchema:
+  z.ZodType<PoliciesControllerGetPolicyEvidenceTasksV1Task> = z.object({
+    assigneeId: z.string().nullable().optional(),
+    automationStatus: AutomationStatus$zodSchema,
+    department: z.string().nullable().optional(),
+    frequency: PoliciesControllerGetPolicyEvidenceTasksV1Frequency$zodSchema
+      .nullable().optional(),
+    id: z.string(),
+    status: PoliciesControllerGetPolicyEvidenceTasksV1Status$zodSchema,
+    title: z.string(),
+  });
+
+export type PoliciesControllerGetPolicyEvidenceTasksV1Data = {
+  control: Control;
+  tasks: Array<PoliciesControllerGetPolicyEvidenceTasksV1Task>;
+};
+
+export const PoliciesControllerGetPolicyEvidenceTasksV1Data$zodSchema:
+  z.ZodType<PoliciesControllerGetPolicyEvidenceTasksV1Data> = z.object({
+    control: z.lazy(() => Control$zodSchema),
+    tasks: z.array(
+      z.lazy(() => PoliciesControllerGetPolicyEvidenceTasksV1Task$zodSchema),
+    ),
+  });
+
+/**
+ * Authenticated user information (only present for session auth)
+ */
+export type PoliciesControllerGetPolicyEvidenceTasksV1AuthenticatedUser = {
+  id?: string | undefined;
+  email?: string | undefined;
+};
+
+export const PoliciesControllerGetPolicyEvidenceTasksV1AuthenticatedUser$zodSchema:
+  z.ZodType<PoliciesControllerGetPolicyEvidenceTasksV1AuthenticatedUser> = z
+    .object({
+      email: z.string().optional(),
+      id: z.string().optional(),
+    }).describe(
+      "Authenticated user information (only present for session auth)",
+    );
+
+/**
+ * Evidence tasks retrieved successfully
+ */
+export type PoliciesControllerGetPolicyEvidenceTasksV1ResponseBody = {
+  data: Array<PoliciesControllerGetPolicyEvidenceTasksV1Data>;
+  count: number;
+  authType: PoliciesControllerGetPolicyEvidenceTasksV1AuthType;
+  authenticatedUser?:
+    | PoliciesControllerGetPolicyEvidenceTasksV1AuthenticatedUser
+    | undefined;
+};
+
+export const PoliciesControllerGetPolicyEvidenceTasksV1ResponseBody$zodSchema:
+  z.ZodType<PoliciesControllerGetPolicyEvidenceTasksV1ResponseBody> = z.object({
+    authType: PoliciesControllerGetPolicyEvidenceTasksV1AuthType$zodSchema
+      .describe("How the request was authenticated"),
+    authenticatedUser: z.lazy(() =>
+      PoliciesControllerGetPolicyEvidenceTasksV1AuthenticatedUser$zodSchema
+    ).optional().describe(
+      "Authenticated user information (only present for session auth)",
+    ),
+    count: z.number().describe(
+      "Number of DISTINCT tasks across all groups — deduplicated, so it can be smaller than the sum of the group lengths.",
+    ),
+    data: z.array(
+      z.lazy(() => PoliciesControllerGetPolicyEvidenceTasksV1Data$zodSchema),
+    ).describe(
+      "One entry per control mapped to the policy — the tasks are grouped by control, not returned as a flat list. A task mapped to two controls appears in both groups.",
+    ),
+  }).describe("Evidence tasks retrieved successfully");
+
+export type PoliciesControllerGetPolicyEvidenceTasksV1Response =
+  | PoliciesControllerGetPolicyEvidenceTasksV1ResponseBody
+  | PoliciesControllerGetPolicyEvidenceTasksV1NotFoundResponseBody;
+
+export const PoliciesControllerGetPolicyEvidenceTasksV1Response$zodSchema:
+  z.ZodType<PoliciesControllerGetPolicyEvidenceTasksV1Response> = z.union([
+    z.lazy(() =>
+      PoliciesControllerGetPolicyEvidenceTasksV1ResponseBody$zodSchema
+    ),
+    z.lazy(() =>
+      PoliciesControllerGetPolicyEvidenceTasksV1NotFoundResponseBody$zodSchema
+    ),
+  ]);

package/src/models/synccontrollergetavailablesyncprovidersv1op.ts

@@ -4,12 +4,32 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
+
+/**
+ * Capability to filter on. Defaults to employee sync.
+ */
+export const SyncType = {
+  Employee: "employee",
+  Device: "device",
+} as const;
+/**
+ * Capability to filter on. Defaults to employee sync.
+ */
+export type SyncType = ClosedEnum<typeof SyncType>;
+
+export const SyncType$zodSchema = z.enum([
+  "employee",
+  "device",
+]).describe("Capability to filter on. Defaults to employee sync.");
 
 export type SyncControllerGetAvailableSyncProvidersV1Request = {
-  syncType: string;
+  syncType?: SyncType | undefined;
 };
 
 export const SyncControllerGetAvailableSyncProvidersV1Request$zodSchema:
   z.ZodType<SyncControllerGetAvailableSyncProvidersV1Request> = z.object({
-    syncType: z.string(),
+    syncType: SyncType$zodSchema.optional().describe(
+      "Capability to filter on. Defaults to employee sync.",
+    ),
   });

package/src/models/taskintegrationscontrollergettaskcheckrunsv1op.ts

@@ -7,11 +7,13 @@ import * as z from "zod";
 
 export type TaskIntegrationsControllerGetTaskCheckRunsV1Request = {
   taskId: string;
-  limit: string;
+  limit?: string | undefined;
 };
 
 export const TaskIntegrationsControllerGetTaskCheckRunsV1Request$zodSchema:
   z.ZodType<TaskIntegrationsControllerGetTaskCheckRunsV1Request> = z.object({
-    limit: z.string(),
+    limit: z.string().describe(
+      "Runs kept per connection/check group. Defaults to 5.",
+    ).optional(),
     taskId: z.string(),
   });

package/src/models/taskscontrollergettaskactivityv1op.ts

@@ -7,14 +7,15 @@ import * as z from "zod";
 
 export type TasksControllerGetTaskActivityV1Request = {
   taskId: string;
-  skip: string;
-  take: string;
+  skip?: string | undefined;
+  take?: string | undefined;
 };
 
 export const TasksControllerGetTaskActivityV1Request$zodSchema: z.ZodType<
   TasksControllerGetTaskActivityV1Request
 > = z.object({
-  skip: z.string(),
-  take: z.string(),
+  skip: z.string().describe("Entries to skip. Defaults to 0.").optional(),
+  take: z.string().describe("Page size, capped at 50. Defaults to 10.")
+    .optional(),
   taskId: z.string().describe("Unique task identifier"),
 });

package/src/tool-names.ts

@@ -1332,6 +1332,10 @@ export const toolNames: Array<{ name: string; description: string }>= [
     "name": "import-vendors-as-software",
     "description": "Add vendors to the Approved Software Register in one action\n\nAdds the chosen vendors as approved software rows in one transaction. Vendors already listed are skipped, not duplicated. \"Where it is used\" is left unanswered: a supplier record does not say where its product runs."
   },
+  {
+    "name": "import-findings-as-nonconformities",
+    "description": "Raise register entries from internal-audit findings\n\nRaises the chosen internal-audit findings as entries in the Nonconformity & Corrective Action Register, in one transaction. A finding already imported is skipped, never duplicated. Findings must belong to this register's framework."
+  },
   {
     "name": "save-narrative",
     "description": "Save a singleton document narrative\n\nReplaces the working draft narrative of a document type that stores one, such as ISMS scope, leadership commitment, internal audit or risk assessment methodology. The narrative object is fully replaced, not merged."
@@ -1436,6 +1440,14 @@ export const toolNames: Array<{ name: string; description: string }>= [
     "name": "get-form-with-submissions",
     "description": "Get form definition and submissions\n\nGet form definition and submissions in Comp AI. Collect, review, upload, and export structured evidence submissions for compliance tasks and document requirements."
   },
+  {
+    "name": "list-evidence-form-submissions",
+    "description": "List evidence form submissions\n\nReturns the organization's submissions for one evidence form type in the standard {data, count} envelope, newest first. Use to audit evidence completeness across the org."
+  },
+  {
+    "name": "submit-form",
+    "description": "Submit evidence form\n\nSubmit structured evidence responses and attachments for review against a compliance task or document requirement."
+  },
   {
     "name": "get-submission",
     "description": "Get a single submission\n\nGet a single submission in Comp AI. Collect, review, upload, and export structured evidence submissions for compliance tasks and document requirements."
@@ -1444,10 +1456,6 @@ export const toolNames: Array<{ name: string; description: string }>= [
     "name": "delete-submission",
     "description": "Delete a submission\n\nDelete a submission in Comp AI. Collect, review, upload, and export structured evidence submissions for compliance tasks and document requirements."
   },
-  {
-    "name": "submit-form",
-    "description": "Submit evidence form\n\nSubmit structured evidence responses and attachments for review against a compliance task or document requirement."
-  },
   {
     "name": "upload-submission",
     "description": "Upload a file as an evidence submission\n\nUpload a PDF or image file and create a submission for the given form type, bypassing form-specific validation. Accepts session, API key, or service token auth. For API key / service token callers without an explicit user attribution, the."