@noresponse/mcp 0.11.15 → 0.11.16

package/bin/mcp-server.js

@@ -48136,9 +48136,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1",
-    sdkVersion: "0.11.15",
+    sdkVersion: "0.11.16",
     genVersion: "internal",
-    userAgent: "noresponse-sdk/mcp-typescript 0.11.15 internal 1 @noresponse/mcp"
+    userAgent: "noresponse-sdk/mcp-typescript 0.11.16 internal 1 @noresponse/mcp"
   };
 });
 
@@ -51535,7 +51535,10 @@ var init_conflicterrorcode = __esm(() => {
     "already_member",
     "member_limit_reached",
     "owner_invite_pending",
-    "aggregate_erased_data"
+    "aggregate_erased_data",
+    "event_conflict",
+    "event_limit_reached",
+    "screening_unavailable"
   ]).describe("Machine codes an HTTP 409 answer can carry.");
 });
 
@@ -59914,6 +59917,2641 @@ Publish an explicitly reviewed candidate with its exact manifest, input and resu
   };
 });
 
+// src/models/attendeebatchitemoutcome.ts
+var AttendeeBatchItemOutcome$zodSchema;
+var init_attendeebatchitemoutcome = __esm(() => {
+  init_zod();
+  AttendeeBatchItemOutcome$zodSchema = _enum([
+    "created",
+    "updated",
+    "unchanged"
+  ]).describe("unchanged: the row matched an attendee with the same details.");
+});
+
+// src/models/attendeebatchitem.ts
+var AttendeeBatchItem$zodSchema;
+var init_attendeebatchitem = __esm(() => {
+  init_zod();
+  init_attendeebatchitemoutcome();
+  AttendeeBatchItem$zodSchema = object({
+    id: string2(),
+    index: int().describe("The row's position in the request."),
+    outcome: AttendeeBatchItemOutcome$zodSchema.describe("unchanged: the row matched an attendee with the same details.")
+  });
+});
+
+// src/models/attendeebatch.ts
+var AttendeeBatch$zodSchema;
+var init_attendeebatch = __esm(() => {
+  init_zod();
+  init_attendeebatchitem();
+  AttendeeBatch$zodSchema = object({
+    created: int(),
+    items: array(AttendeeBatchItem$zodSchema),
+    updated: int()
+  }).describe("What the batch did, row by row.");
+});
+
+// src/models/handleplatform.ts
+var HandlePlatform$zodSchema;
+var init_handleplatform = __esm(() => {
+  init_zod();
+  HandlePlatform$zodSchema = _enum([
+    "instagram",
+    "x",
+    "bluesky",
+    "youtube",
+    "tiktok",
+    "facebook",
+    "threads",
+    "reddit",
+    "telegram",
+    "linkedin"
+  ]);
+});
+
+// src/models/handle.ts
+var Handle$zodSchema;
+var init_handle = __esm(() => {
+  init_zod();
+  init_handleplatform();
+  Handle$zodSchema = object({
+    handle: string2().describe("The account's handle, without a leading @."),
+    platform: HandlePlatform$zodSchema
+  }).describe("An account the attendee is known to hold.");
+});
+
+// src/models/attendeeidentity.ts
+var AttendeeIdentity$zodSchema;
+var init_attendeeidentity = __esm(() => {
+  init_zod();
+  init_handle();
+  AttendeeIdentity$zodSchema = object({
+    city: string2().optional().describe("Where the attendee lives."),
+    company: string2().optional().describe("Where the attendee works."),
+    email: string2().optional().describe("The attendee's email."),
+    external_id: string2().optional().describe("Your own id for the attendee, unique within the event. A later row with the same external id updates this attendee."),
+    handles: array(Handle$zodSchema).optional().describe("Accounts the attendee is known to hold, at most 20."),
+    name: string2().describe("The attendee's full name."),
+    phone: string2().optional().describe("The attendee's phone in E.164 form.")
+  }).describe("What you know about an attendee. Stored encrypted under the workspace's key.");
+});
+
+// src/models/attendeebatchrequest.ts
+var AttendeeBatchRequest$zodSchema;
+var init_attendeebatchrequest = __esm(() => {
+  init_zod();
+  init_attendeeidentity();
+  AttendeeBatchRequest$zodSchema = object({
+    attendees: array(AttendeeIdentity$zodSchema)
+  }).describe("Adds or updates 1 to 500 attendees. A row naming an existing attendee of the event (the same external_id, else the same email, else the same phone) updates it.");
+});
+
+// src/models/addattendeesop.ts
+var AddAttendeesRequest$zodSchema, AddAttendeesResponseResult$zodSchema, AddAttendeesResponse$zodSchema;
+var init_addattendeesop = __esm(() => {
+  init_zod();
+  init_attendeebatch();
+  init_attendeebatchrequest();
+  init_authenticationerror();
+  init_badrequesterror();
+  init_conflicterror();
+  init_keyenvironment();
+  init_notfounderror();
+  init_permissiondeniederror();
+  init_ratelimiterror();
+  AddAttendeesRequest$zodSchema = object({
+    body: AttendeeBatchRequest$zodSchema,
+    environment: KeyEnvironment$zodSchema.describe("The environment: live or test. Each has its own settings. Any other value answers 400. An API key reads and changes only its own environment's; the other answers 404."),
+    event_id: string2(),
+    idempotencyKey: string2().describe("Opaque client key, 16 to 128 characters of [A-Za-z0-9._:-] (a UUID or ULID fits). Scoped to the workspace principal and bound to the canonical body for 24 hours. Optional: the SDK generates a UUID when you omit it and sends the same key on every retry of the call.").optional(),
+    workspace_id: string2().describe("Your workspace id, as each key lists it in workspace_id. Another workspace, a malformed id and a test environment's id answer 404.")
+  });
+  AddAttendeesResponseResult$zodSchema = union([
+    BadRequestError$zodSchema,
+    AuthenticationError$zodSchema,
+    PermissionDeniedError$zodSchema,
+    NotFoundError$zodSchema,
+    ConflictError$zodSchema,
+    RateLimitError$zodSchema,
+    AttendeeBatch$zodSchema
+  ]);
+  AddAttendeesResponse$zodSchema = object({
+    Headers: record(string2(), array(string2())).default({}),
+    Result: union([
+      BadRequestError$zodSchema,
+      AuthenticationError$zodSchema,
+      PermissionDeniedError$zodSchema,
+      NotFoundError$zodSchema,
+      ConflictError$zodSchema,
+      RateLimitError$zodSchema,
+      AttendeeBatch$zodSchema
+    ])
+  });
+});
+
+// src/funcs/eventsAddAttendees.ts
+function eventsAddAttendees(client$, request, options) {
+  return new APIPromise($do40(client$, request, options));
+}
+async function $do40(client$, request, options) {
+  const parsed$ = safeParse2(request, (value$) => AddAttendeesRequest$zodSchema.parse(value$), "Input validation failed");
+  if (!parsed$.ok) {
+    return [parsed$, { status: "invalid" }];
+  }
+  const payload$ = parsed$.value;
+  const body$ = encodeJSON("body", payload$.body, { explode: true });
+  const pathParams$ = {
+    environment: encodeSimple("environment", payload$.environment, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    event_id: encodeSimple("event_id", payload$.event_id, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    workspace_id: encodeSimple("workspace_id", payload$.workspace_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path$ = pathToFunc("/v1/workspaces/{workspace_id}/events/{environment}/{event_id}/attendees")(pathParams$);
+  const headers$ = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: options?.acceptHeaderOverride || "application/json;q=1, application/problem+json;q=0",
+    "Idempotency-Key": encodeSimple("Idempotency-Key", payload$.idempotencyKey, { explode: false, charEncoding: "none" })
+  }));
+  const securityInput = await extractSecurity(client$._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client$._options,
+    baseURL: options?.serverURL ?? client$._baseURL ?? "",
+    operationID: "addAttendees",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client$._options.security,
+    retryConfig: options?.retries || client$._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 500,
+        maxInterval: 8000,
+        exponent: 2,
+        maxElapsedTime: 30000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || [
+      "408",
+      "429",
+      "5XX"
+    ]
+  };
+  const requestRes = client$._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path: path$,
+    headers: headers$,
+    body: body$,
+    userAgent: client$._options.userAgent,
+    timeoutMs: options?.timeoutMs || client$._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req$ = requestRes.value;
+  const doResult = await client$._do(req$, {
+    context,
+    errorCodes: [],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req$ }];
+  }
+  return [doResult, {
+    status: "complete",
+    request: req$,
+    response: doResult.value
+  }];
+}
+var init_eventsAddAttendees = __esm(() => {
+  init_encodings();
+  init_primitives();
+  init_schemas3();
+  init_security();
+  init_url();
+  init_addattendeesop();
+  init_async();
+});
+
+// src/mcp-server/tools/eventsAddAttendees.ts
+var args41, tool$eventsAddAttendees;
+var init_eventsAddAttendees2 = __esm(() => {
+  init_eventsAddAttendees();
+  init_addattendeesop();
+  init_tools();
+  args41 = {
+    request: AddAttendeesRequest$zodSchema
+  };
+  tool$eventsAddAttendees = {
+    name: "add_attendees",
+    description: `Add or update a batch of attendees.
+
+Add or update 1 to 500 attendees with an Idempotency-Key. A row with the same external_id, else email, else phone as an existing attendee updates it. Identities are stored encrypted.`,
+    annotations: {
+      title: "Add or update up to 500 attendees with an idempotency key",
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+      readOnlyHint: false
+    },
+    args: args41,
+    tool: async (client, args, ctx) => {
+      const [result] = await eventsAddAttendees(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      return formatResult(result.value);
+    }
+  };
+});
+
+// src/models/screeningdepth.ts
+var ScreeningDepth$zodSchema;
+var init_screeningdepth = __esm(() => {
+  init_zod();
+  ScreeningDepth$zodSchema = _enum([
+    "standard"
+  ]);
+});
+
+// src/models/screeningstatus.ts
+var ScreeningStatus$zodSchema;
+var init_screeningstatus = __esm(() => {
+  init_zod();
+  ScreeningStatus$zodSchema = _enum([
+    "queued",
+    "running",
+    "completed",
+    "partial",
+    "failed",
+    "cancelled"
+  ]).describe("partial finished with some attendees not covered; attendees_failed counts them.");
+});
+
+// src/models/screening.ts
+var ScreeningPlatform$zodSchema, Screening$zodSchema;
+var init_screening = __esm(() => {
+  init_zod();
+  init_auditsettingsenvironment();
+  init_screeningdepth();
+  init_screeningstatus();
+  ScreeningPlatform$zodSchema = _enum([
+    "instagram",
+    "x",
+    "bluesky",
+    "youtube",
+    "tiktok",
+    "facebook",
+    "threads",
+    "reddit",
+    "telegram",
+    "linkedin"
+  ]);
+  Screening$zodSchema = object({
+    attendees_done: int().describe("Attendees screened so far, failed ones included."),
+    attendees_failed: int(),
+    attendees_flagged: int(),
+    attendees_total: int().describe("Attendees selected when the screening started."),
+    created_at: string2(),
+    depth: ScreeningDepth$zodSchema,
+    environment: AuditSettingsEnvironment$zodSchema,
+    error_code: string2().optional().describe("Why a failed or cancelled screening stopped."),
+    event_id: string2(),
+    expires_at: string2().describe("A screening still running then fails with error_code expired."),
+    finished_at: string2().optional(),
+    id: string2(),
+    platforms: array(ScreeningPlatform$zodSchema),
+    requested_by: string2(),
+    started_at: string2().optional(),
+    status: ScreeningStatus$zodSchema.describe("partial finished with some attendees not covered; attendees_failed counts them.")
+  }).describe("A screening and its progress.");
+});
+
+// src/models/screeningcancelrequest.ts
+var ScreeningCancelRequest$zodSchema;
+var init_screeningcancelrequest = __esm(() => {
+  init_zod();
+  ScreeningCancelRequest$zodSchema = object({}).describe("An empty object.");
+});
+
+// src/models/cancelscreeningop.ts
+var CancelScreeningRequest$zodSchema, CancelScreeningResponseResult$zodSchema, CancelScreeningResponse$zodSchema;
+var init_cancelscreeningop = __esm(() => {
+  init_zod();
+  init_authenticationerror();
+  init_badrequesterror();
+  init_conflicterror();
+  init_keyenvironment();
+  init_notfounderror();
+  init_permissiondeniederror();
+  init_ratelimiterror();
+  init_screening();
+  init_screeningcancelrequest();
+  CancelScreeningRequest$zodSchema = object({
+    body: ScreeningCancelRequest$zodSchema,
+    environment: KeyEnvironment$zodSchema.describe("The environment: live or test. Each has its own settings. Any other value answers 400. An API key reads and changes only its own environment's; the other answers 404."),
+    event_id: string2(),
+    screening_id: string2(),
+    workspace_id: string2().describe("Your workspace id, as each key lists it in workspace_id. Another workspace, a malformed id and a test environment's id answer 404.")
+  });
+  CancelScreeningResponseResult$zodSchema = union([
+    Screening$zodSchema,
+    BadRequestError$zodSchema,
+    AuthenticationError$zodSchema,
+    PermissionDeniedError$zodSchema,
+    NotFoundError$zodSchema,
+    ConflictError$zodSchema,
+    RateLimitError$zodSchema
+  ]);
+  CancelScreeningResponse$zodSchema = object({
+    Headers: record(string2(), array(string2())).default({}),
+    Result: union([
+      Screening$zodSchema,
+      BadRequestError$zodSchema,
+      AuthenticationError$zodSchema,
+      PermissionDeniedError$zodSchema,
+      NotFoundError$zodSchema,
+      ConflictError$zodSchema,
+      RateLimitError$zodSchema
+    ])
+  });
+});
+
+// src/funcs/eventsCancelScreening.ts
+function eventsCancelScreening(client$, request, options) {
+  return new APIPromise($do41(client$, request, options));
+}
+async function $do41(client$, request, options) {
+  const parsed$ = safeParse2(request, (value$) => CancelScreeningRequest$zodSchema.parse(value$), "Input validation failed");
+  if (!parsed$.ok) {
+    return [parsed$, { status: "invalid" }];
+  }
+  const payload$ = parsed$.value;
+  const body$ = encodeJSON("body", payload$.body, { explode: true });
+  const pathParams$ = {
+    environment: encodeSimple("environment", payload$.environment, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    event_id: encodeSimple("event_id", payload$.event_id, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    screening_id: encodeSimple("screening_id", payload$.screening_id, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    workspace_id: encodeSimple("workspace_id", payload$.workspace_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path$ = pathToFunc("/v1/workspaces/{workspace_id}/events/{environment}/{event_id}/screenings/{screening_id}/cancel")(pathParams$);
+  const headers$ = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: options?.acceptHeaderOverride || "application/json;q=1, application/problem+json;q=0"
+  }));
+  const securityInput = await extractSecurity(client$._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client$._options,
+    baseURL: options?.serverURL ?? client$._baseURL ?? "",
+    operationID: "cancelScreening",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client$._options.security,
+    retryConfig: options?.retries || client$._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 500,
+        maxInterval: 8000,
+        exponent: 2,
+        maxElapsedTime: 30000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || [
+      "408",
+      "429",
+      "5XX"
+    ]
+  };
+  const requestRes = client$._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path: path$,
+    headers: headers$,
+    body: body$,
+    userAgent: client$._options.userAgent,
+    timeoutMs: options?.timeoutMs || client$._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req$ = requestRes.value;
+  const doResult = await client$._do(req$, {
+    context,
+    errorCodes: [],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req$ }];
+  }
+  return [doResult, {
+    status: "complete",
+    request: req$,
+    response: doResult.value
+  }];
+}
+var init_eventsCancelScreening = __esm(() => {
+  init_encodings();
+  init_primitives();
+  init_schemas3();
+  init_security();
+  init_url();
+  init_cancelscreeningop();
+  init_async();
+});
+
+// src/mcp-server/tools/eventsCancelScreening.ts
+var args42, tool$eventsCancelScreening;
+var init_eventsCancelScreening2 = __esm(() => {
+  init_eventsCancelScreening();
+  init_cancelscreeningop();
+  init_tools();
+  args42 = {
+    request: CancelScreeningRequest$zodSchema
+  };
+  tool$eventsCancelScreening = {
+    name: "cancel_screening",
+    description: `Cancel a screening.
+
+Stop a queued or running screening. Attendees already screened keep their results.`,
+    annotations: {
+      title: "Stop a queued or running screening",
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: false,
+      readOnlyHint: false
+    },
+    args: args42,
+    tool: async (client, args, ctx) => {
+      const [result] = await eventsCancelScreening(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      return formatResult(result.value);
+    }
+  };
+});
+
+// src/models/principal.ts
+var Principal$zodSchema;
+var init_principal = __esm(() => {
+  init_zod();
+  Principal$zodSchema = object({
+    aliases: array(string2()).optional().describe("Other names the principal goes by, at most 10."),
+    name: string2().describe("The principal's name.")
+  }).describe("A person the event protects.");
+});
+
+// src/models/event.ts
+var Event$zodSchema;
+var init_event = __esm(() => {
+  init_zod();
+  init_auditsettingsenvironment();
+  init_principal();
+  Event$zodSchema = object({
+    attendees: int().describe("How many attendees the event holds."),
+    created_at: string2(),
+    created_by: string2().describe("The member or key label that created the event."),
+    ends_at: string2().describe("When the event ends, at or after its start; the start when omitted."),
+    environment: AuditSettingsEnvironment$zodSchema,
+    host: string2().optional().describe("The organisation hosting the event."),
+    id: string2(),
+    name: string2().describe("The event's name."),
+    principals: array(Principal$zodSchema).describe("The people the event protects."),
+    purge_after: string2().describe("When raw collected items and unmatched candidate profiles are purged: 30 days after the event ends."),
+    starts_at: string2().describe("When the event starts."),
+    topics: array(string2()).describe("Sensitive topics."),
+    updated_at: string2(),
+    venue: string2().optional().describe("Where the event is held."),
+    version: int().describe("Goes up by one with every change.")
+  }).describe("An event and its screening context.");
+});
+
+// src/models/eventrequest.ts
+var EventRequest$zodSchema;
+var init_eventrequest = __esm(() => {
+  init_zod();
+  init_principal();
+  EventRequest$zodSchema = object({
+    ends_at: string2().optional().describe("When the event ends, at or after its start; the start when omitted."),
+    host: string2().optional().describe("The organisation hosting the event."),
+    name: string2().describe("The event's name."),
+    principals: array(Principal$zodSchema).optional().describe("The people the event protects, at most 20."),
+    starts_at: string2().describe("When the event starts."),
+    topics: array(string2()).optional().describe("Sensitive topics the screening reads posts against, at most 50."),
+    venue: string2().optional().describe("Where the event is held.")
+  }).describe("Creates an event.");
+});
+
+// src/models/createeventop.ts
+var CreateEventRequest$zodSchema, CreateEventResponseResult$zodSchema, CreateEventResponse$zodSchema;
+var init_createeventop = __esm(() => {
+  init_zod();
+  init_authenticationerror();
+  init_badrequesterror();
+  init_conflicterror();
+  init_event();
+  init_eventrequest();
+  init_keyenvironment();
+  init_notfounderror();
+  init_permissiondeniederror();
+  init_ratelimiterror();
+  CreateEventRequest$zodSchema = object({
+    body: EventRequest$zodSchema,
+    environment: KeyEnvironment$zodSchema.describe("The environment: live or test. Each has its own settings. Any other value answers 400. An API key reads and changes only its own environment's; the other answers 404."),
+    workspace_id: string2().describe("Your workspace id, as each key lists it in workspace_id. Another workspace, a malformed id and a test environment's id answer 404.")
+  });
+  CreateEventResponseResult$zodSchema = union([
+    Event$zodSchema,
+    BadRequestError$zodSchema,
+    AuthenticationError$zodSchema,
+    PermissionDeniedError$zodSchema,
+    NotFoundError$zodSchema,
+    ConflictError$zodSchema,
+    RateLimitError$zodSchema
+  ]);
+  CreateEventResponse$zodSchema = object({
+    Headers: record(string2(), array(string2())).default({}),
+    Result: union([
+      Event$zodSchema,
+      BadRequestError$zodSchema,
+      AuthenticationError$zodSchema,
+      PermissionDeniedError$zodSchema,
+      NotFoundError$zodSchema,
+      ConflictError$zodSchema,
+      RateLimitError$zodSchema
+    ])
+  });
+});
+
+// src/funcs/eventsCreate.ts
+function eventsCreate(client$, request, options) {
+  return new APIPromise($do42(client$, request, options));
+}
+async function $do42(client$, request, options) {
+  const parsed$ = safeParse2(request, (value$) => CreateEventRequest$zodSchema.parse(value$), "Input validation failed");
+  if (!parsed$.ok) {
+    return [parsed$, { status: "invalid" }];
+  }
+  const payload$ = parsed$.value;
+  const body$ = encodeJSON("body", payload$.body, { explode: true });
+  const pathParams$ = {
+    environment: encodeSimple("environment", payload$.environment, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    workspace_id: encodeSimple("workspace_id", payload$.workspace_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path$ = pathToFunc("/v1/workspaces/{workspace_id}/events/{environment}")(pathParams$);
+  const headers$ = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: options?.acceptHeaderOverride || "application/json;q=1, application/problem+json;q=0"
+  }));
+  const securityInput = await extractSecurity(client$._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client$._options,
+    baseURL: options?.serverURL ?? client$._baseURL ?? "",
+    operationID: "createEvent",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client$._options.security,
+    retryConfig: options?.retries || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client$._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path: path$,
+    headers: headers$,
+    body: body$,
+    userAgent: client$._options.userAgent,
+    timeoutMs: options?.timeoutMs || client$._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req$ = requestRes.value;
+  const doResult = await client$._do(req$, {
+    context,
+    errorCodes: [],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req$ }];
+  }
+  return [doResult, {
+    status: "complete",
+    request: req$,
+    response: doResult.value
+  }];
+}
+var init_eventsCreate = __esm(() => {
+  init_encodings();
+  init_primitives();
+  init_schemas3();
+  init_security();
+  init_url();
+  init_createeventop();
+  init_async();
+});
+
+// src/mcp-server/tools/eventsCreate.ts
+var args43, tool$eventsCreate;
+var init_eventsCreate2 = __esm(() => {
+  init_eventsCreate();
+  init_createeventop();
+  init_tools();
+  args43 = {
+    request: CreateEventRequest$zodSchema
+  };
+  tool$eventsCreate = {
+    name: "create_event",
+    description: `Create an event to screen.
+
+Create an event to screen: its name, start, venue, host, the principals it protects and the sensitive topics posts are read against. An environment holds at most 1000 events.`,
+    annotations: {
+      title: "Create an event with its principals and sensitive topics",
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false,
+      readOnlyHint: false
+    },
+    args: args43,
+    tool: async (client, args, ctx) => {
+      const [result] = await eventsCreate(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      return formatResult(result.value);
+    }
+  };
+});
+
+// src/models/deleteeventop.ts
+var DeleteEventRequest$zodSchema, DeleteEventResponseResult$zodSchema, DeleteEventResponse$zodSchema;
+var init_deleteeventop = __esm(() => {
+  init_zod();
+  init_authenticationerror();
+  init_badrequesterror();
+  init_conflicterror();
+  init_keyenvironment();
+  init_notfounderror();
+  init_permissiondeniederror();
+  init_ratelimiterror();
+  DeleteEventRequest$zodSchema = object({
+    environment: KeyEnvironment$zodSchema.describe("The environment: live or test. Each has its own settings. Any other value answers 400. An API key reads and changes only its own environment's; the other answers 404."),
+    event_id: string2(),
+    workspace_id: string2().describe("Your workspace id, as each key lists it in workspace_id. Another workspace, a malformed id and a test environment's id answer 404.")
+  });
+  DeleteEventResponseResult$zodSchema = union([
+    BadRequestError$zodSchema,
+    AuthenticationError$zodSchema,
+    PermissionDeniedError$zodSchema,
+    NotFoundError$zodSchema,
+    ConflictError$zodSchema,
+    RateLimitError$zodSchema
+  ]);
+  DeleteEventResponse$zodSchema = object({
+    Headers: record(string2(), array(string2())).default({}),
+    Result: union([
+      BadRequestError$zodSchema,
+      AuthenticationError$zodSchema,
+      PermissionDeniedError$zodSchema,
+      NotFoundError$zodSchema,
+      ConflictError$zodSchema,
+      RateLimitError$zodSchema
+    ]).optional()
+  });
+});
+
+// src/funcs/eventsDelete.ts
+function eventsDelete(client$, request, options) {
+  return new APIPromise($do43(client$, request, options));
+}
+async function $do43(client$, request, options) {
+  const parsed$ = safeParse2(request, (value$) => DeleteEventRequest$zodSchema.parse(value$), "Input validation failed");
+  if (!parsed$.ok) {
+    return [parsed$, { status: "invalid" }];
+  }
+  const payload$ = parsed$.value;
+  const body$ = null;
+  const pathParams$ = {
+    environment: encodeSimple("environment", payload$.environment, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    event_id: encodeSimple("event_id", payload$.event_id, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    workspace_id: encodeSimple("workspace_id", payload$.workspace_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path$ = pathToFunc("/v1/workspaces/{workspace_id}/events/{environment}/{event_id}")(pathParams$);
+  const headers$ = new Headers(compactMap({
+    Accept: "application/problem+json"
+  }));
+  const securityInput = await extractSecurity(client$._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client$._options,
+    baseURL: options?.serverURL ?? client$._baseURL ?? "",
+    operationID: "deleteEvent",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client$._options.security,
+    retryConfig: options?.retries || client$._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 500,
+        maxInterval: 8000,
+        exponent: 2,
+        maxElapsedTime: 30000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || [
+      "408",
+      "429",
+      "5XX"
+    ]
+  };
+  const requestRes = client$._createRequest(context, {
+    security: requestSecurity,
+    method: "DELETE",
+    baseURL: options?.serverURL,
+    path: path$,
+    headers: headers$,
+    body: body$,
+    userAgent: client$._options.userAgent,
+    timeoutMs: options?.timeoutMs || client$._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req$ = requestRes.value;
+  const doResult = await client$._do(req$, {
+    context,
+    errorCodes: [],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req$ }];
+  }
+  return [doResult, {
+    status: "complete",
+    request: req$,
+    response: doResult.value
+  }];
+}
+var init_eventsDelete = __esm(() => {
+  init_encodings();
+  init_primitives();
+  init_schemas3();
+  init_security();
+  init_url();
+  init_deleteeventop();
+  init_async();
+});
+
+// src/mcp-server/tools/eventsDelete.ts
+var args44, tool$eventsDelete;
+var init_eventsDelete2 = __esm(() => {
+  init_eventsDelete();
+  init_deleteeventop();
+  init_tools();
+  args44 = {
+    request: DeleteEventRequest$zodSchema
+  };
+  tool$eventsDelete = {
+    name: "delete_event",
+    description: `Erase an event.
+
+Erase an event with its attendees, their decisions and its screenings, and stop any screening still running.`,
+    annotations: {
+      title: "Delete an event with its attendees, decisions and screenings",
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: false,
+      readOnlyHint: false
+    },
+    args: args44,
+    tool: async (client, args, ctx) => {
+      const [result] = await eventsDelete(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      return formatResult(result.value);
+    }
+  };
+});
+
+// src/models/geteventop.ts
+var GetEventRequest$zodSchema, GetEventResponseResult$zodSchema, GetEventResponse$zodSchema;
+var init_geteventop = __esm(() => {
+  init_zod();
+  init_authenticationerror();
+  init_badrequesterror();
+  init_conflicterror();
+  init_event();
+  init_keyenvironment();
+  init_notfounderror();
+  init_permissiondeniederror();
+  init_ratelimiterror();
+  GetEventRequest$zodSchema = object({
+    environment: KeyEnvironment$zodSchema.describe("The environment: live or test. Each has its own settings. Any other value answers 400. An API key reads and changes only its own environment's; the other answers 404."),
+    event_id: string2(),
+    workspace_id: string2().describe("Your workspace id, as each key lists it in workspace_id. Another workspace, a malformed id and a test environment's id answer 404.")
+  });
+  GetEventResponseResult$zodSchema = union([
+    Event$zodSchema,
+    BadRequestError$zodSchema,
+    AuthenticationError$zodSchema,
+    PermissionDeniedError$zodSchema,
+    NotFoundError$zodSchema,
+    ConflictError$zodSchema,
+    RateLimitError$zodSchema
+  ]);
+  GetEventResponse$zodSchema = object({
+    Headers: record(string2(), array(string2())).default({}),
+    Result: union([
+      Event$zodSchema,
+      BadRequestError$zodSchema,
+      AuthenticationError$zodSchema,
+      PermissionDeniedError$zodSchema,
+      NotFoundError$zodSchema,
+      ConflictError$zodSchema,
+      RateLimitError$zodSchema
+    ])
+  });
+});
+
+// src/funcs/eventsGet.ts
+function eventsGet(client$, request, options) {
+  return new APIPromise($do44(client$, request, options));
+}
+async function $do44(client$, request, options) {
+  const parsed$ = safeParse2(request, (value$) => GetEventRequest$zodSchema.parse(value$), "Input validation failed");
+  if (!parsed$.ok) {
+    return [parsed$, { status: "invalid" }];
+  }
+  const payload$ = parsed$.value;
+  const body$ = null;
+  const pathParams$ = {
+    environment: encodeSimple("environment", payload$.environment, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    event_id: encodeSimple("event_id", payload$.event_id, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    workspace_id: encodeSimple("workspace_id", payload$.workspace_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path$ = pathToFunc("/v1/workspaces/{workspace_id}/events/{environment}/{event_id}")(pathParams$);
+  const headers$ = new Headers(compactMap({
+    Accept: options?.acceptHeaderOverride || "application/json;q=1, application/problem+json;q=0"
+  }));
+  const securityInput = await extractSecurity(client$._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client$._options,
+    baseURL: options?.serverURL ?? client$._baseURL ?? "",
+    operationID: "getEvent",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client$._options.security,
+    retryConfig: options?.retries || client$._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 500,
+        maxInterval: 8000,
+        exponent: 2,
+        maxElapsedTime: 30000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || [
+      "408",
+      "429",
+      "5XX"
+    ]
+  };
+  const requestRes = client$._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path: path$,
+    headers: headers$,
+    body: body$,
+    userAgent: client$._options.userAgent,
+    timeoutMs: options?.timeoutMs || client$._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req$ = requestRes.value;
+  const doResult = await client$._do(req$, {
+    context,
+    errorCodes: [],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req$ }];
+  }
+  return [doResult, {
+    status: "complete",
+    request: req$,
+    response: doResult.value
+  }];
+}
+var init_eventsGet = __esm(() => {
+  init_encodings();
+  init_primitives();
+  init_schemas3();
+  init_security();
+  init_url();
+  init_geteventop();
+  init_async();
+});
+
+// src/mcp-server/tools/eventsGet.ts
+var args45, tool$eventsGet;
+var init_eventsGet2 = __esm(() => {
+  init_eventsGet();
+  init_geteventop();
+  init_tools();
+  args45 = {
+    request: GetEventRequest$zodSchema
+  };
+  tool$eventsGet = {
+    name: "get_event",
+    description: `Read an event.
+
+Read an event and how many attendees it holds.`,
+    annotations: {
+      title: "Read an event and its attendee count",
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+      readOnlyHint: true
+    },
+    args: args45,
+    tool: async (client, args, ctx) => {
+      const [result] = await eventsGet(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      return formatResult(result.value);
+    }
+  };
+});
+
+// src/models/attendeedecision.ts
+var AttendeeDecision$zodSchema;
+var init_attendeedecision = __esm(() => {
+  init_zod();
+  AttendeeDecision$zodSchema = _enum([
+    "cleared",
+    "watch",
+    "escalated"
+  ]);
+});
+
+// src/models/highestband.ts
+var HighestBand$zodSchema;
+var init_highestband = __esm(() => {
+  init_zod();
+  HighestBand$zodSchema = _enum([
+    "critical",
+    "high",
+    "moderate",
+    "low",
+    "info"
+  ]);
+});
+
+// src/models/matchstate.ts
+var MatchState$zodSchema;
+var init_matchstate = __esm(() => {
+  init_zod();
+  MatchState$zodSchema = _enum([
+    "unscreened",
+    "confirmed",
+    "probable",
+    "possible",
+    "none_found",
+    "inaccessible"
+  ]).describe("How sure the latest screening is that it found the attendee's accounts. unscreened until a screening reaches the attendee.");
+});
+
+// src/models/attendee.ts
+var AttendeeCoverage$zodSchema, Attendee$zodSchema;
+var init_attendee = __esm(() => {
+  init_zod();
+  init_attendeedecision();
+  init_handle();
+  init_highestband();
+  init_matchstate();
+  AttendeeCoverage$zodSchema = object({}).describe("What the latest screening read, per platform.");
+  Attendee$zodSchema = object({
+    city: string2().optional().describe("Where the attendee lives."),
+    company: string2().optional().describe("Where the attendee works."),
+    coverage: lazy(() => AttendeeCoverage$zodSchema).describe("What the latest screening read, per platform."),
+    created_at: string2(),
+    decided_at: string2().optional(),
+    decided_by: string2().optional(),
+    decision: AttendeeDecision$zodSchema.nullable().describe("The latest reviewer decision, or null before any."),
+    decision_note: string2().optional(),
+    email: string2().optional().describe("The attendee's email."),
+    event_id: string2(),
+    external_id: string2().optional().describe("Your own id for the attendee, unique within the event. A later row with the same external id updates this attendee."),
+    handles: array(Handle$zodSchema).optional().describe("Accounts the attendee is known to hold, at most 20."),
+    highest_band: HighestBand$zodSchema.nullable().describe("The most severe finding's band, or null when nothing was flagged."),
+    id: string2(),
+    last_screening_id: string2().optional(),
+    match_state: MatchState$zodSchema.describe("How sure the latest screening is that it found the attendee's accounts. unscreened until a screening reaches the attendee."),
+    name: string2().describe("The attendee's full name."),
+    phone: string2().optional().describe("The attendee's phone in E.164 form."),
+    screened_at: string2().optional(),
+    updated_at: string2()
+  }).describe("An attendee and where their screening and review stand.");
+});
+
+// src/models/attendeereview.ts
+var AttendeeReview$zodSchema;
+var init_attendeereview = __esm(() => {
+  init_zod();
+  init_attendeedecision();
+  AttendeeReview$zodSchema = object({
+    created_at: string2(),
+    created_by: string2(),
+    decision: AttendeeDecision$zodSchema,
+    id: string2(),
+    note: string2().optional()
+  }).describe("One recorded decision.");
+});
+
+// src/models/attendeereport.ts
+var Profile$zodSchema, Finding$zodSchema, AttendeeReport$zodSchema;
+var init_attendeereport = __esm(() => {
+  init_zod();
+  init_attendee();
+  init_attendeereview();
+  Profile$zodSchema = object({});
+  Finding$zodSchema = object({});
+  AttendeeReport$zodSchema = object({
+    attendee: Attendee$zodSchema.describe("An attendee and where their screening and review stand."),
+    findings: array(lazy(() => Finding$zodSchema)).describe("What the screening flagged, with its evidence."),
+    profiles: array(lazy(() => Profile$zodSchema)).describe("The accounts the screening matched, with how each was matched."),
+    reviews: array(AttendeeReview$zodSchema).describe("Every recorded decision, oldest first.")
+  }).describe("Everything known about one attendee.");
+});
+
+// src/models/getattendeeop.ts
+var GetAttendeeRequest$zodSchema, GetAttendeeResponseResult$zodSchema, GetAttendeeResponse$zodSchema;
+var init_getattendeeop = __esm(() => {
+  init_zod();
+  init_attendeereport();
+  init_authenticationerror();
+  init_badrequesterror();
+  init_conflicterror();
+  init_keyenvironment();
+  init_notfounderror();
+  init_permissiondeniederror();
+  init_ratelimiterror();
+  GetAttendeeRequest$zodSchema = object({
+    attendee_id: string2(),
+    environment: KeyEnvironment$zodSchema.describe("The environment: live or test. Each has its own settings. Any other value answers 400. An API key reads and changes only its own environment's; the other answers 404."),
+    event_id: string2(),
+    workspace_id: string2().describe("Your workspace id, as each key lists it in workspace_id. Another workspace, a malformed id and a test environment's id answer 404.")
+  });
+  GetAttendeeResponseResult$zodSchema = union([
+    BadRequestError$zodSchema,
+    AuthenticationError$zodSchema,
+    PermissionDeniedError$zodSchema,
+    NotFoundError$zodSchema,
+    ConflictError$zodSchema,
+    RateLimitError$zodSchema,
+    AttendeeReport$zodSchema
+  ]);
+  GetAttendeeResponse$zodSchema = object({
+    Headers: record(string2(), array(string2())).default({}),
+    Result: union([
+      BadRequestError$zodSchema,
+      AuthenticationError$zodSchema,
+      PermissionDeniedError$zodSchema,
+      NotFoundError$zodSchema,
+      ConflictError$zodSchema,
+      RateLimitError$zodSchema,
+      AttendeeReport$zodSchema
+    ])
+  });
+});
+
+// src/funcs/eventsGetAttendee.ts
+function eventsGetAttendee(client$, request, options) {
+  return new APIPromise($do45(client$, request, options));
+}
+async function $do45(client$, request, options) {
+  const parsed$ = safeParse2(request, (value$) => GetAttendeeRequest$zodSchema.parse(value$), "Input validation failed");
+  if (!parsed$.ok) {
+    return [parsed$, { status: "invalid" }];
+  }
+  const payload$ = parsed$.value;
+  const body$ = null;
+  const pathParams$ = {
+    attendee_id: encodeSimple("attendee_id", payload$.attendee_id, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    environment: encodeSimple("environment", payload$.environment, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    event_id: encodeSimple("event_id", payload$.event_id, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    workspace_id: encodeSimple("workspace_id", payload$.workspace_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path$ = pathToFunc("/v1/workspaces/{workspace_id}/events/{environment}/{event_id}/attendees/{attendee_id}")(pathParams$);
+  const headers$ = new Headers(compactMap({
+    Accept: options?.acceptHeaderOverride || "application/json;q=1, application/problem+json;q=0"
+  }));
+  const securityInput = await extractSecurity(client$._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client$._options,
+    baseURL: options?.serverURL ?? client$._baseURL ?? "",
+    operationID: "getAttendee",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client$._options.security,
+    retryConfig: options?.retries || client$._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 500,
+        maxInterval: 8000,
+        exponent: 2,
+        maxElapsedTime: 30000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || [
+      "408",
+      "429",
+      "5XX"
+    ]
+  };
+  const requestRes = client$._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path: path$,
+    headers: headers$,
+    body: body$,
+    userAgent: client$._options.userAgent,
+    timeoutMs: options?.timeoutMs || client$._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req$ = requestRes.value;
+  const doResult = await client$._do(req$, {
+    context,
+    errorCodes: [],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req$ }];
+  }
+  return [doResult, {
+    status: "complete",
+    request: req$,
+    response: doResult.value
+  }];
+}
+var init_eventsGetAttendee = __esm(() => {
+  init_encodings();
+  init_primitives();
+  init_schemas3();
+  init_security();
+  init_url();
+  init_getattendeeop();
+  init_async();
+});
+
+// src/mcp-server/tools/eventsGetAttendee.ts
+var args46, tool$eventsGetAttendee;
+var init_eventsGetAttendee2 = __esm(() => {
+  init_eventsGetAttendee();
+  init_getattendeeop();
+  init_tools();
+  args46 = {
+    request: GetAttendeeRequest$zodSchema
+  };
+  tool$eventsGetAttendee = {
+    name: "get_attendee",
+    description: `Read an attendee's report.
+
+Read an attendee's report: matched profiles, findings with their evidence and every recorded decision.`,
+    annotations: {
+      title: "Read an attendee's profiles, findings and decisions",
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+      readOnlyHint: true
+    },
+    args: args46,
+    tool: async (client, args, ctx) => {
+      const [result] = await eventsGetAttendee(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      return formatResult(result.value);
+    }
+  };
+});
+
+// src/models/getscreeningop.ts
+var GetScreeningRequest$zodSchema, GetScreeningResponseResult$zodSchema, GetScreeningResponse$zodSchema;
+var init_getscreeningop = __esm(() => {
+  init_zod();
+  init_authenticationerror();
+  init_badrequesterror();
+  init_conflicterror();
+  init_keyenvironment();
+  init_notfounderror();
+  init_permissiondeniederror();
+  init_ratelimiterror();
+  init_screening();
+  GetScreeningRequest$zodSchema = object({
+    environment: KeyEnvironment$zodSchema.describe("The environment: live or test. Each has its own settings. Any other value answers 400. An API key reads and changes only its own environment's; the other answers 404."),
+    event_id: string2(),
+    screening_id: string2(),
+    workspace_id: string2().describe("Your workspace id, as each key lists it in workspace_id. Another workspace, a malformed id and a test environment's id answer 404.")
+  });
+  GetScreeningResponseResult$zodSchema = union([
+    Screening$zodSchema,
+    BadRequestError$zodSchema,
+    AuthenticationError$zodSchema,
+    PermissionDeniedError$zodSchema,
+    NotFoundError$zodSchema,
+    ConflictError$zodSchema,
+    RateLimitError$zodSchema
+  ]);
+  GetScreeningResponse$zodSchema = object({
+    Headers: record(string2(), array(string2())).default({}),
+    Result: union([
+      Screening$zodSchema,
+      BadRequestError$zodSchema,
+      AuthenticationError$zodSchema,
+      PermissionDeniedError$zodSchema,
+      NotFoundError$zodSchema,
+      ConflictError$zodSchema,
+      RateLimitError$zodSchema
+    ])
+  });
+});
+
+// src/funcs/eventsGetScreening.ts
+function eventsGetScreening(client$, request, options) {
+  return new APIPromise($do46(client$, request, options));
+}
+async function $do46(client$, request, options) {
+  const parsed$ = safeParse2(request, (value$) => GetScreeningRequest$zodSchema.parse(value$), "Input validation failed");
+  if (!parsed$.ok) {
+    return [parsed$, { status: "invalid" }];
+  }
+  const payload$ = parsed$.value;
+  const body$ = null;
+  const pathParams$ = {
+    environment: encodeSimple("environment", payload$.environment, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    event_id: encodeSimple("event_id", payload$.event_id, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    screening_id: encodeSimple("screening_id", payload$.screening_id, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    workspace_id: encodeSimple("workspace_id", payload$.workspace_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path$ = pathToFunc("/v1/workspaces/{workspace_id}/events/{environment}/{event_id}/screenings/{screening_id}")(pathParams$);
+  const headers$ = new Headers(compactMap({
+    Accept: options?.acceptHeaderOverride || "application/json;q=1, application/problem+json;q=0"
+  }));
+  const securityInput = await extractSecurity(client$._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client$._options,
+    baseURL: options?.serverURL ?? client$._baseURL ?? "",
+    operationID: "getScreening",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client$._options.security,
+    retryConfig: options?.retries || client$._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 500,
+        maxInterval: 8000,
+        exponent: 2,
+        maxElapsedTime: 30000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || [
+      "408",
+      "429",
+      "5XX"
+    ]
+  };
+  const requestRes = client$._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path: path$,
+    headers: headers$,
+    body: body$,
+    userAgent: client$._options.userAgent,
+    timeoutMs: options?.timeoutMs || client$._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req$ = requestRes.value;
+  const doResult = await client$._do(req$, {
+    context,
+    errorCodes: [],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req$ }];
+  }
+  return [doResult, {
+    status: "complete",
+    request: req$,
+    response: doResult.value
+  }];
+}
+var init_eventsGetScreening = __esm(() => {
+  init_encodings();
+  init_primitives();
+  init_schemas3();
+  init_security();
+  init_url();
+  init_getscreeningop();
+  init_async();
+});
+
+// src/mcp-server/tools/eventsGetScreening.ts
+var args47, tool$eventsGetScreening;
+var init_eventsGetScreening2 = __esm(() => {
+  init_eventsGetScreening();
+  init_getscreeningop();
+  init_tools();
+  args47 = {
+    request: GetScreeningRequest$zodSchema
+  };
+  tool$eventsGetScreening = {
+    name: "get_screening",
+    description: `Read a screening.
+
+Read a screening's status and progress.`,
+    annotations: {
+      title: "Read a screening's status and progress",
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+      readOnlyHint: true
+    },
+    args: args47,
+    tool: async (client, args, ctx) => {
+      const [result] = await eventsGetScreening(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      return formatResult(result.value);
+    }
+  };
+});
+
+// src/models/eventlist.ts
+var EventList$zodSchema;
+var init_eventlist = __esm(() => {
+  init_zod();
+  init_event();
+  EventList$zodSchema = object({
+    items: array(Event$zodSchema),
+    next_before: string2().optional().describe("Pass as before to read the next, older page.")
+  }).describe("Events, newest first.");
+});
+
+// src/models/listeventsop.ts
+var ListEventsRequest$zodSchema, ListEventsResponseResult$zodSchema, ListEventsResponse$zodSchema;
+var init_listeventsop = __esm(() => {
+  init_zod();
+  init_authenticationerror();
+  init_badrequesterror();
+  init_conflicterror();
+  init_eventlist();
+  init_keyenvironment();
+  init_notfounderror();
+  init_permissiondeniederror();
+  init_ratelimiterror();
+  ListEventsRequest$zodSchema = object({
+    before: string2().describe("Read events older than this one.").optional(),
+    environment: KeyEnvironment$zodSchema.describe("The environment: live or test. Each has its own settings. Any other value answers 400. An API key reads and changes only its own environment's; the other answers 404."),
+    limit: int().default(20).describe("At most this many items."),
+    workspace_id: string2().describe("Your workspace id, as each key lists it in workspace_id. Another workspace, a malformed id and a test environment's id answer 404.")
+  });
+  ListEventsResponseResult$zodSchema = union([
+    BadRequestError$zodSchema,
+    AuthenticationError$zodSchema,
+    PermissionDeniedError$zodSchema,
+    NotFoundError$zodSchema,
+    ConflictError$zodSchema,
+    RateLimitError$zodSchema,
+    EventList$zodSchema
+  ]);
+  ListEventsResponse$zodSchema = object({
+    Headers: record(string2(), array(string2())).default({}),
+    Result: union([
+      BadRequestError$zodSchema,
+      AuthenticationError$zodSchema,
+      PermissionDeniedError$zodSchema,
+      NotFoundError$zodSchema,
+      ConflictError$zodSchema,
+      RateLimitError$zodSchema,
+      EventList$zodSchema
+    ])
+  });
+});
+
+// src/funcs/eventsList.ts
+function eventsList(client$, request, options) {
+  return new APIPromise($do47(client$, request, options));
+}
+async function $do47(client$, request, options) {
+  const parsed$ = safeParse2(request, (value$) => ListEventsRequest$zodSchema.parse(value$), "Input validation failed");
+  if (!parsed$.ok) {
+    return [parsed$, { status: "invalid" }];
+  }
+  const payload$ = parsed$.value;
+  const body$ = null;
+  const pathParams$ = {
+    environment: encodeSimple("environment", payload$.environment, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    workspace_id: encodeSimple("workspace_id", payload$.workspace_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path$ = pathToFunc("/v1/workspaces/{workspace_id}/events/{environment}")(pathParams$);
+  const query$ = encodeFormQuery({
+    before: payload$.before,
+    limit: payload$.limit
+  });
+  const headers$ = new Headers(compactMap({
+    Accept: options?.acceptHeaderOverride || "application/json;q=1, application/problem+json;q=0"
+  }));
+  const securityInput = await extractSecurity(client$._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client$._options,
+    baseURL: options?.serverURL ?? client$._baseURL ?? "",
+    operationID: "listEvents",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client$._options.security,
+    retryConfig: options?.retries || client$._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 500,
+        maxInterval: 8000,
+        exponent: 2,
+        maxElapsedTime: 30000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || [
+      "408",
+      "429",
+      "5XX"
+    ]
+  };
+  const requestRes = client$._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path: path$,
+    headers: headers$,
+    query: query$,
+    body: body$,
+    userAgent: client$._options.userAgent,
+    timeoutMs: options?.timeoutMs || client$._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req$ = requestRes.value;
+  const doResult = await client$._do(req$, {
+    context,
+    errorCodes: [],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req$ }];
+  }
+  return [doResult, {
+    status: "complete",
+    request: req$,
+    response: doResult.value
+  }];
+}
+var init_eventsList = __esm(() => {
+  init_encodings();
+  init_primitives();
+  init_schemas3();
+  init_security();
+  init_url();
+  init_listeventsop();
+  init_async();
+});
+
+// src/mcp-server/tools/eventsList.ts
+var args48, tool$eventsList;
+var init_eventsList2 = __esm(() => {
+  init_eventsList();
+  init_listeventsop();
+  init_tools();
+  args48 = {
+    request: ListEventsRequest$zodSchema
+  };
+  tool$eventsList = {
+    name: "list_events",
+    description: `List an environment's events.
+
+List this environment's events, newest first. Pass next_before back as before for the next page. Requires the events scope.`,
+    annotations: {
+      title: "Read this environment's events",
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+      readOnlyHint: true
+    },
+    args: args48,
+    tool: async (client, args, ctx) => {
+      const [result] = await eventsList(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      return formatResult(result.value);
+    }
+  };
+});
+
+// src/models/attendeelist.ts
+var AttendeeList$zodSchema;
+var init_attendeelist = __esm(() => {
+  init_zod();
+  init_attendee();
+  AttendeeList$zodSchema = object({
+    items: array(Attendee$zodSchema),
+    next_after: string2().optional().describe("Pass as after to read the next page.")
+  }).describe("Attendees in upload order.");
+});
+
+// src/models/listattendeesband.ts
+var ListAttendeesBand$zodSchema;
+var init_listattendeesband = __esm(() => {
+  init_zod();
+  ListAttendeesBand$zodSchema = _enum([
+    "critical",
+    "high",
+    "moderate",
+    "low",
+    "info",
+    "none"
+  ]);
+});
+
+// src/models/listattendeesdecision.ts
+var ListAttendeesDecision$zodSchema;
+var init_listattendeesdecision = __esm(() => {
+  init_zod();
+  ListAttendeesDecision$zodSchema = _enum([
+    "cleared",
+    "watch",
+    "escalated",
+    "undecided"
+  ]);
+});
+
+// src/models/listattendeesop.ts
+var ListAttendeesRequest$zodSchema, ListAttendeesResponseResult$zodSchema, ListAttendeesResponse$zodSchema;
+var init_listattendeesop = __esm(() => {
+  init_zod();
+  init_attendeelist();
+  init_authenticationerror();
+  init_badrequesterror();
+  init_conflicterror();
+  init_keyenvironment();
+  init_listattendeesband();
+  init_listattendeesdecision();
+  init_notfounderror();
+  init_permissiondeniederror();
+  init_ratelimiterror();
+  ListAttendeesRequest$zodSchema = object({
+    after: string2().describe("Read attendees after this one.").optional(),
+    band: ListAttendeesBand$zodSchema.optional().describe("Only attendees whose highest finding has this band; none for attendees with no finding."),
+    decision: ListAttendeesDecision$zodSchema.optional().describe("Only attendees with this decision; undecided for none yet."),
+    environment: KeyEnvironment$zodSchema.describe("The environment: live or test. Each has its own settings. Any other value answers 400. An API key reads and changes only its own environment's; the other answers 404."),
+    event_id: string2(),
+    limit: int().default(100).describe("At most this many attendees."),
+    workspace_id: string2().describe("Your workspace id, as each key lists it in workspace_id. Another workspace, a malformed id and a test environment's id answer 404.")
+  });
+  ListAttendeesResponseResult$zodSchema = union([
+    BadRequestError$zodSchema,
+    AuthenticationError$zodSchema,
+    PermissionDeniedError$zodSchema,
+    NotFoundError$zodSchema,
+    ConflictError$zodSchema,
+    RateLimitError$zodSchema,
+    AttendeeList$zodSchema
+  ]);
+  ListAttendeesResponse$zodSchema = object({
+    Headers: record(string2(), array(string2())).default({}),
+    Result: union([
+      BadRequestError$zodSchema,
+      AuthenticationError$zodSchema,
+      PermissionDeniedError$zodSchema,
+      NotFoundError$zodSchema,
+      ConflictError$zodSchema,
+      RateLimitError$zodSchema,
+      AttendeeList$zodSchema
+    ])
+  });
+});
+
+// src/funcs/eventsListAttendees.ts
+function eventsListAttendees(client$, request, options) {
+  return new APIPromise($do48(client$, request, options));
+}
+async function $do48(client$, request, options) {
+  const parsed$ = safeParse2(request, (value$) => ListAttendeesRequest$zodSchema.parse(value$), "Input validation failed");
+  if (!parsed$.ok) {
+    return [parsed$, { status: "invalid" }];
+  }
+  const payload$ = parsed$.value;
+  const body$ = null;
+  const pathParams$ = {
+    environment: encodeSimple("environment", payload$.environment, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    event_id: encodeSimple("event_id", payload$.event_id, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    workspace_id: encodeSimple("workspace_id", payload$.workspace_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path$ = pathToFunc("/v1/workspaces/{workspace_id}/events/{environment}/{event_id}/attendees")(pathParams$);
+  const query$ = encodeFormQuery({
+    after: payload$.after,
+    band: payload$.band,
+    decision: payload$.decision,
+    limit: payload$.limit
+  });
+  const headers$ = new Headers(compactMap({
+    Accept: options?.acceptHeaderOverride || "application/json;q=1, application/problem+json;q=0"
+  }));
+  const securityInput = await extractSecurity(client$._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client$._options,
+    baseURL: options?.serverURL ?? client$._baseURL ?? "",
+    operationID: "listAttendees",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client$._options.security,
+    retryConfig: options?.retries || client$._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 500,
+        maxInterval: 8000,
+        exponent: 2,
+        maxElapsedTime: 30000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || [
+      "408",
+      "429",
+      "5XX"
+    ]
+  };
+  const requestRes = client$._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path: path$,
+    headers: headers$,
+    query: query$,
+    body: body$,
+    userAgent: client$._options.userAgent,
+    timeoutMs: options?.timeoutMs || client$._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req$ = requestRes.value;
+  const doResult = await client$._do(req$, {
+    context,
+    errorCodes: [],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req$ }];
+  }
+  return [doResult, {
+    status: "complete",
+    request: req$,
+    response: doResult.value
+  }];
+}
+var init_eventsListAttendees = __esm(() => {
+  init_encodings();
+  init_primitives();
+  init_schemas3();
+  init_security();
+  init_url();
+  init_listattendeesop();
+  init_async();
+});
+
+// src/mcp-server/tools/eventsListAttendees.ts
+var args49, tool$eventsListAttendees;
+var init_eventsListAttendees2 = __esm(() => {
+  init_eventsListAttendees();
+  init_listattendeesop();
+  init_tools();
+  args49 = {
+    request: ListAttendeesRequest$zodSchema
+  };
+  tool$eventsListAttendees = {
+    name: "list_attendees",
+    description: `List an event's attendees.
+
+Read an event's roster in upload order, with each attendee's match state, highest finding band and decision. Filter by band or decision; pass next_after back as after.`,
+    annotations: {
+      title: "Read an event's roster with match states, bands and decisions",
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+      readOnlyHint: true
+    },
+    args: args49,
+    tool: async (client, args, ctx) => {
+      const [result] = await eventsListAttendees(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      return formatResult(result.value);
+    }
+  };
+});
+
+// src/models/screeninglist.ts
+var ScreeningList$zodSchema;
+var init_screeninglist = __esm(() => {
+  init_zod();
+  init_screening();
+  ScreeningList$zodSchema = object({
+    items: array(Screening$zodSchema),
+    next_before: string2().optional().describe("Pass as before to read the next, older page.")
+  }).describe("Screenings, newest first.");
+});
+
+// src/models/listscreeningsop.ts
+var ListScreeningsRequest$zodSchema, ListScreeningsResponseResult$zodSchema, ListScreeningsResponse$zodSchema;
+var init_listscreeningsop = __esm(() => {
+  init_zod();
+  init_authenticationerror();
+  init_badrequesterror();
+  init_conflicterror();
+  init_keyenvironment();
+  init_notfounderror();
+  init_permissiondeniederror();
+  init_ratelimiterror();
+  init_screeninglist();
+  ListScreeningsRequest$zodSchema = object({
+    before: string2().describe("Read screenings older than this one.").optional(),
+    environment: KeyEnvironment$zodSchema.describe("The environment: live or test. Each has its own settings. Any other value answers 400. An API key reads and changes only its own environment's; the other answers 404."),
+    event_id: string2(),
+    limit: int().default(20).describe("At most this many items."),
+    workspace_id: string2().describe("Your workspace id, as each key lists it in workspace_id. Another workspace, a malformed id and a test environment's id answer 404.")
+  });
+  ListScreeningsResponseResult$zodSchema = union([
+    BadRequestError$zodSchema,
+    AuthenticationError$zodSchema,
+    PermissionDeniedError$zodSchema,
+    NotFoundError$zodSchema,
+    ConflictError$zodSchema,
+    RateLimitError$zodSchema,
+    ScreeningList$zodSchema
+  ]);
+  ListScreeningsResponse$zodSchema = object({
+    Headers: record(string2(), array(string2())).default({}),
+    Result: union([
+      BadRequestError$zodSchema,
+      AuthenticationError$zodSchema,
+      PermissionDeniedError$zodSchema,
+      NotFoundError$zodSchema,
+      ConflictError$zodSchema,
+      RateLimitError$zodSchema,
+      ScreeningList$zodSchema
+    ])
+  });
+});
+
+// src/funcs/eventsListScreenings.ts
+function eventsListScreenings(client$, request, options) {
+  return new APIPromise($do49(client$, request, options));
+}
+async function $do49(client$, request, options) {
+  const parsed$ = safeParse2(request, (value$) => ListScreeningsRequest$zodSchema.parse(value$), "Input validation failed");
+  if (!parsed$.ok) {
+    return [parsed$, { status: "invalid" }];
+  }
+  const payload$ = parsed$.value;
+  const body$ = null;
+  const pathParams$ = {
+    environment: encodeSimple("environment", payload$.environment, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    event_id: encodeSimple("event_id", payload$.event_id, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    workspace_id: encodeSimple("workspace_id", payload$.workspace_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path$ = pathToFunc("/v1/workspaces/{workspace_id}/events/{environment}/{event_id}/screenings")(pathParams$);
+  const query$ = encodeFormQuery({
+    before: payload$.before,
+    limit: payload$.limit
+  });
+  const headers$ = new Headers(compactMap({
+    Accept: options?.acceptHeaderOverride || "application/json;q=1, application/problem+json;q=0"
+  }));
+  const securityInput = await extractSecurity(client$._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client$._options,
+    baseURL: options?.serverURL ?? client$._baseURL ?? "",
+    operationID: "listScreenings",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client$._options.security,
+    retryConfig: options?.retries || client$._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 500,
+        maxInterval: 8000,
+        exponent: 2,
+        maxElapsedTime: 30000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || [
+      "408",
+      "429",
+      "5XX"
+    ]
+  };
+  const requestRes = client$._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path: path$,
+    headers: headers$,
+    query: query$,
+    body: body$,
+    userAgent: client$._options.userAgent,
+    timeoutMs: options?.timeoutMs || client$._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req$ = requestRes.value;
+  const doResult = await client$._do(req$, {
+    context,
+    errorCodes: [],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req$ }];
+  }
+  return [doResult, {
+    status: "complete",
+    request: req$,
+    response: doResult.value
+  }];
+}
+var init_eventsListScreenings = __esm(() => {
+  init_encodings();
+  init_primitives();
+  init_schemas3();
+  init_security();
+  init_url();
+  init_listscreeningsop();
+  init_async();
+});
+
+// src/mcp-server/tools/eventsListScreenings.ts
+var args50, tool$eventsListScreenings;
+var init_eventsListScreenings2 = __esm(() => {
+  init_eventsListScreenings();
+  init_listscreeningsop();
+  init_tools();
+  args50 = {
+    request: ListScreeningsRequest$zodSchema
+  };
+  tool$eventsListScreenings = {
+    name: "list_screenings",
+    description: `List an event's screenings.
+
+List an event's screenings, newest first.`,
+    annotations: {
+      title: "Read an event's screenings",
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+      readOnlyHint: true
+    },
+    args: args50,
+    tool: async (client, args, ctx) => {
+      const [result] = await eventsListScreenings(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      return formatResult(result.value);
+    }
+  };
+});
+
+// src/models/attendeereviewrequest.ts
+var AttendeeReviewRequest$zodSchema;
+var init_attendeereviewrequest = __esm(() => {
+  init_zod();
+  init_attendeedecision();
+  AttendeeReviewRequest$zodSchema = object({
+    decision: AttendeeDecision$zodSchema,
+    note: string2().optional().describe("Why, for the venue team and later reviewers.")
+  }).describe("Records a decision on an attendee.");
+});
+
+// src/models/reviewattendeeop.ts
+var ReviewAttendeeRequest$zodSchema, ReviewAttendeeResponseResult$zodSchema, ReviewAttendeeResponse$zodSchema;
+var init_reviewattendeeop = __esm(() => {
+  init_zod();
+  init_attendee();
+  init_attendeereviewrequest();
+  init_authenticationerror();
+  init_badrequesterror();
+  init_conflicterror();
+  init_keyenvironment();
+  init_notfounderror();
+  init_permissiondeniederror();
+  init_ratelimiterror();
+  ReviewAttendeeRequest$zodSchema = object({
+    attendee_id: string2(),
+    body: AttendeeReviewRequest$zodSchema,
+    environment: KeyEnvironment$zodSchema.describe("The environment: live or test. Each has its own settings. Any other value answers 400. An API key reads and changes only its own environment's; the other answers 404."),
+    event_id: string2(),
+    workspace_id: string2().describe("Your workspace id, as each key lists it in workspace_id. Another workspace, a malformed id and a test environment's id answer 404.")
+  });
+  ReviewAttendeeResponseResult$zodSchema = union([
+    Attendee$zodSchema,
+    BadRequestError$zodSchema,
+    AuthenticationError$zodSchema,
+    PermissionDeniedError$zodSchema,
+    NotFoundError$zodSchema,
+    ConflictError$zodSchema,
+    RateLimitError$zodSchema
+  ]);
+  ReviewAttendeeResponse$zodSchema = object({
+    Headers: record(string2(), array(string2())).default({}),
+    Result: union([
+      Attendee$zodSchema,
+      BadRequestError$zodSchema,
+      AuthenticationError$zodSchema,
+      PermissionDeniedError$zodSchema,
+      NotFoundError$zodSchema,
+      ConflictError$zodSchema,
+      RateLimitError$zodSchema
+    ])
+  });
+});
+
+// src/funcs/eventsReviewAttendee.ts
+function eventsReviewAttendee(client$, request, options) {
+  return new APIPromise($do50(client$, request, options));
+}
+async function $do50(client$, request, options) {
+  const parsed$ = safeParse2(request, (value$) => ReviewAttendeeRequest$zodSchema.parse(value$), "Input validation failed");
+  if (!parsed$.ok) {
+    return [parsed$, { status: "invalid" }];
+  }
+  const payload$ = parsed$.value;
+  const body$ = encodeJSON("body", payload$.body, { explode: true });
+  const pathParams$ = {
+    attendee_id: encodeSimple("attendee_id", payload$.attendee_id, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    environment: encodeSimple("environment", payload$.environment, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    event_id: encodeSimple("event_id", payload$.event_id, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    workspace_id: encodeSimple("workspace_id", payload$.workspace_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path$ = pathToFunc("/v1/workspaces/{workspace_id}/events/{environment}/{event_id}/attendees/{attendee_id}/review")(pathParams$);
+  const headers$ = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: options?.acceptHeaderOverride || "application/json;q=1, application/problem+json;q=0"
+  }));
+  const securityInput = await extractSecurity(client$._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client$._options,
+    baseURL: options?.serverURL ?? client$._baseURL ?? "",
+    operationID: "reviewAttendee",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client$._options.security,
+    retryConfig: options?.retries || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client$._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path: path$,
+    headers: headers$,
+    body: body$,
+    userAgent: client$._options.userAgent,
+    timeoutMs: options?.timeoutMs || client$._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req$ = requestRes.value;
+  const doResult = await client$._do(req$, {
+    context,
+    errorCodes: [],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req$ }];
+  }
+  return [doResult, {
+    status: "complete",
+    request: req$,
+    response: doResult.value
+  }];
+}
+var init_eventsReviewAttendee = __esm(() => {
+  init_encodings();
+  init_primitives();
+  init_schemas3();
+  init_security();
+  init_url();
+  init_reviewattendeeop();
+  init_async();
+});
+
+// src/mcp-server/tools/eventsReviewAttendee.ts
+var args51, tool$eventsReviewAttendee;
+var init_eventsReviewAttendee2 = __esm(() => {
+  init_eventsReviewAttendee();
+  init_reviewattendeeop();
+  init_tools();
+  args51 = {
+    request: ReviewAttendeeRequest$zodSchema
+  };
+  tool$eventsReviewAttendee = {
+    name: "review_attendee",
+    description: `Record a decision on an attendee.
+
+Record a cleared, watch or escalated decision with a note. The latest decision is the attendee's; the next screening refreshes everyone on watch or escalated.`,
+    annotations: {
+      title: "Mark an attendee cleared, watch or escalated with a note",
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false,
+      readOnlyHint: false
+    },
+    args: args51,
+    tool: async (client, args, ctx) => {
+      const [result] = await eventsReviewAttendee(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      return formatResult(result.value);
+    }
+  };
+});
+
+// src/models/screeningrequest.ts
+var ScreeningRequestPlatform$zodSchema, ScreeningRequest$zodSchema;
+var init_screeningrequest = __esm(() => {
+  init_zod();
+  init_screeningdepth();
+  ScreeningRequestPlatform$zodSchema = _enum([
+    "instagram",
+    "x",
+    "bluesky",
+    "youtube",
+    "tiktok",
+    "facebook",
+    "threads",
+    "reddit",
+    "telegram",
+    "linkedin"
+  ]);
+  ScreeningRequest$zodSchema = object({
+    depth: ScreeningDepth$zodSchema,
+    platforms: array(ScreeningRequestPlatform$zodSchema)
+  }).describe("Screens the event's attendees no screening has reached and everyone on watch or escalated.");
+});
+
+// src/models/startscreeningop.ts
+var StartScreeningRequest$zodSchema, StartScreeningResponseResult$zodSchema, StartScreeningResponse$zodSchema;
+var init_startscreeningop = __esm(() => {
+  init_zod();
+  init_authenticationerror();
+  init_badrequesterror();
+  init_conflicterror();
+  init_keyenvironment();
+  init_notfounderror();
+  init_permissiondeniederror();
+  init_ratelimiterror();
+  init_screening();
+  init_screeningrequest();
+  StartScreeningRequest$zodSchema = object({
+    body: ScreeningRequest$zodSchema,
+    environment: KeyEnvironment$zodSchema.describe("The environment: live or test. Each has its own settings. Any other value answers 400. An API key reads and changes only its own environment's; the other answers 404."),
+    event_id: string2(),
+    idempotencyKey: string2().describe("Opaque client key, 16 to 128 characters of [A-Za-z0-9._:-] (a UUID or ULID fits). Scoped to the workspace principal and bound to the canonical body for 24 hours. Optional: the SDK generates a UUID when you omit it and sends the same key on every retry of the call.").optional(),
+    workspace_id: string2().describe("Your workspace id, as each key lists it in workspace_id. Another workspace, a malformed id and a test environment's id answer 404.")
+  });
+  StartScreeningResponseResult$zodSchema = union([
+    Screening$zodSchema,
+    BadRequestError$zodSchema,
+    AuthenticationError$zodSchema,
+    PermissionDeniedError$zodSchema,
+    NotFoundError$zodSchema,
+    ConflictError$zodSchema,
+    RateLimitError$zodSchema
+  ]);
+  StartScreeningResponse$zodSchema = object({
+    Headers: record(string2(), array(string2())).default({}),
+    Result: union([
+      Screening$zodSchema,
+      BadRequestError$zodSchema,
+      AuthenticationError$zodSchema,
+      PermissionDeniedError$zodSchema,
+      NotFoundError$zodSchema,
+      ConflictError$zodSchema,
+      RateLimitError$zodSchema
+    ])
+  });
+});
+
+// src/funcs/eventsStartScreening.ts
+function eventsStartScreening(client$, request, options) {
+  return new APIPromise($do51(client$, request, options));
+}
+async function $do51(client$, request, options) {
+  const parsed$ = safeParse2(request, (value$) => StartScreeningRequest$zodSchema.parse(value$), "Input validation failed");
+  if (!parsed$.ok) {
+    return [parsed$, { status: "invalid" }];
+  }
+  const payload$ = parsed$.value;
+  const body$ = encodeJSON("body", payload$.body, { explode: true });
+  const pathParams$ = {
+    environment: encodeSimple("environment", payload$.environment, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    event_id: encodeSimple("event_id", payload$.event_id, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    workspace_id: encodeSimple("workspace_id", payload$.workspace_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path$ = pathToFunc("/v1/workspaces/{workspace_id}/events/{environment}/{event_id}/screenings")(pathParams$);
+  const headers$ = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: options?.acceptHeaderOverride || "application/json;q=1, application/problem+json;q=0",
+    "Idempotency-Key": encodeSimple("Idempotency-Key", payload$.idempotencyKey, { explode: false, charEncoding: "none" })
+  }));
+  const securityInput = await extractSecurity(client$._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client$._options,
+    baseURL: options?.serverURL ?? client$._baseURL ?? "",
+    operationID: "startScreening",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client$._options.security,
+    retryConfig: options?.retries || client$._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 500,
+        maxInterval: 8000,
+        exponent: 2,
+        maxElapsedTime: 30000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || [
+      "408",
+      "429",
+      "5XX"
+    ]
+  };
+  const requestRes = client$._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path: path$,
+    headers: headers$,
+    body: body$,
+    userAgent: client$._options.userAgent,
+    timeoutMs: options?.timeoutMs || client$._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req$ = requestRes.value;
+  const doResult = await client$._do(req$, {
+    context,
+    errorCodes: [],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req$ }];
+  }
+  return [doResult, {
+    status: "complete",
+    request: req$,
+    response: doResult.value
+  }];
+}
+var init_eventsStartScreening = __esm(() => {
+  init_encodings();
+  init_primitives();
+  init_schemas3();
+  init_security();
+  init_url();
+  init_startscreeningop();
+  init_async();
+});
+
+// src/mcp-server/tools/eventsStartScreening.ts
+var args52, tool$eventsStartScreening;
+var init_eventsStartScreening2 = __esm(() => {
+  init_eventsStartScreening();
+  init_startscreeningop();
+  init_tools();
+  args52 = {
+    request: StartScreeningRequest$zodSchema
+  };
+  tool$eventsStartScreening = {
+    name: "start_screening",
+    description: `Start a screening.
+
+Start a screening of new attendees and everyone on watch or escalated, with an Idempotency-Key. It finishes completed, partial or failed minutes to hours later; poll it. The test environment screens with stand-ins that find no accounts.`,
+    annotations: {
+      title: "Screen new attendees and everyone on watch or escalated",
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+      readOnlyHint: false
+    },
+    args: args52,
+    tool: async (client, args, ctx) => {
+      const [result] = await eventsStartScreening(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      return formatResult(result.value);
+    }
+  };
+});
+
+// src/models/eventupdate.ts
+var EventUpdate$zodSchema;
+var init_eventupdate = __esm(() => {
+  init_zod();
+  init_principal();
+  EventUpdate$zodSchema = object({
+    ends_at: string2().optional().describe("When the event ends, at or after its start; the start when omitted."),
+    expected_version: int().optional().describe("When present, the change applies only if the event is still at this version (409 event_conflict otherwise)."),
+    host: string2().optional().describe("The organisation hosting the event."),
+    name: string2().optional().describe("The event's name."),
+    principals: array(Principal$zodSchema).optional().describe("The people the event protects, at most 20."),
+    starts_at: string2().optional().describe("When the event starts."),
+    topics: array(string2()).optional().describe("Sensitive topics the screening reads posts against, at most 50."),
+    venue: string2().optional().describe("Where the event is held.")
+  }).describe("Changes the fields it names; at least one besides expected_version.");
+});
+
+// src/models/updateeventop.ts
+var UpdateEventRequest$zodSchema, UpdateEventResponseResult$zodSchema, UpdateEventResponse$zodSchema;
+var init_updateeventop = __esm(() => {
+  init_zod();
+  init_authenticationerror();
+  init_badrequesterror();
+  init_conflicterror();
+  init_event();
+  init_eventupdate();
+  init_keyenvironment();
+  init_notfounderror();
+  init_permissiondeniederror();
+  init_ratelimiterror();
+  UpdateEventRequest$zodSchema = object({
+    body: EventUpdate$zodSchema,
+    environment: KeyEnvironment$zodSchema.describe("The environment: live or test. Each has its own settings. Any other value answers 400. An API key reads and changes only its own environment's; the other answers 404."),
+    event_id: string2(),
+    workspace_id: string2().describe("Your workspace id, as each key lists it in workspace_id. Another workspace, a malformed id and a test environment's id answer 404.")
+  });
+  UpdateEventResponseResult$zodSchema = union([
+    Event$zodSchema,
+    BadRequestError$zodSchema,
+    AuthenticationError$zodSchema,
+    PermissionDeniedError$zodSchema,
+    NotFoundError$zodSchema,
+    ConflictError$zodSchema,
+    RateLimitError$zodSchema
+  ]);
+  UpdateEventResponse$zodSchema = object({
+    Headers: record(string2(), array(string2())).default({}),
+    Result: union([
+      Event$zodSchema,
+      BadRequestError$zodSchema,
+      AuthenticationError$zodSchema,
+      PermissionDeniedError$zodSchema,
+      NotFoundError$zodSchema,
+      ConflictError$zodSchema,
+      RateLimitError$zodSchema
+    ])
+  });
+});
+
+// src/funcs/eventsUpdate.ts
+function eventsUpdate(client$, request, options) {
+  return new APIPromise($do52(client$, request, options));
+}
+async function $do52(client$, request, options) {
+  const parsed$ = safeParse2(request, (value$) => UpdateEventRequest$zodSchema.parse(value$), "Input validation failed");
+  if (!parsed$.ok) {
+    return [parsed$, { status: "invalid" }];
+  }
+  const payload$ = parsed$.value;
+  const body$ = encodeJSON("body", payload$.body, { explode: true });
+  const pathParams$ = {
+    environment: encodeSimple("environment", payload$.environment, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    event_id: encodeSimple("event_id", payload$.event_id, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    workspace_id: encodeSimple("workspace_id", payload$.workspace_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path$ = pathToFunc("/v1/workspaces/{workspace_id}/events/{environment}/{event_id}")(pathParams$);
+  const headers$ = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: options?.acceptHeaderOverride || "application/json;q=1, application/problem+json;q=0"
+  }));
+  const securityInput = await extractSecurity(client$._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client$._options,
+    baseURL: options?.serverURL ?? client$._baseURL ?? "",
+    operationID: "updateEvent",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client$._options.security,
+    retryConfig: options?.retries || client$._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 500,
+        maxInterval: 8000,
+        exponent: 2,
+        maxElapsedTime: 30000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || [
+      "408",
+      "429",
+      "5XX"
+    ]
+  };
+  const requestRes = client$._createRequest(context, {
+    security: requestSecurity,
+    method: "PATCH",
+    baseURL: options?.serverURL,
+    path: path$,
+    headers: headers$,
+    body: body$,
+    userAgent: client$._options.userAgent,
+    timeoutMs: options?.timeoutMs || client$._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req$ = requestRes.value;
+  const doResult = await client$._do(req$, {
+    context,
+    errorCodes: [],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req$ }];
+  }
+  return [doResult, {
+    status: "complete",
+    request: req$,
+    response: doResult.value
+  }];
+}
+var init_eventsUpdate = __esm(() => {
+  init_encodings();
+  init_primitives();
+  init_schemas3();
+  init_security();
+  init_url();
+  init_updateeventop();
+  init_async();
+});
+
+// src/mcp-server/tools/eventsUpdate.ts
+var args53, tool$eventsUpdate;
+var init_eventsUpdate2 = __esm(() => {
+  init_eventsUpdate();
+  init_updateeventop();
+  init_tools();
+  args53 = {
+    request: UpdateEventRequest$zodSchema
+  };
+  tool$eventsUpdate = {
+    name: "update_event",
+    description: `Change an event.
+
+Change the fields you name. Send expected_version to apply the change only to that version.`,
+    annotations: {
+      title: "Change an event's details",
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+      readOnlyHint: false
+    },
+    args: args53,
+    tool: async (client, args, ctx) => {
+      const [result] = await eventsUpdate(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      return formatResult(result.value);
+    }
+  };
+});
+
 // src/models/customerexportrequestkind.ts
 var CustomerExportRequestKind$zodSchema;
 var init_customerexportrequestkind = __esm(() => {
@@ -60015,9 +62653,9 @@ var init_cancelcustomerexportop = __esm(() => {
 
 // src/funcs/exportsCancel.ts
 function exportsCancel(client$, request, options) {
-  return new APIPromise($do40(client$, request, options));
+  return new APIPromise($do53(client$, request, options));
 }
-async function $do40(client$, request, options) {
+async function $do53(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => CancelCustomerExportRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -60104,12 +62742,12 @@ var init_exportsCancel = __esm(() => {
 });
 
 // src/mcp-server/tools/exportsCancel.ts
-var args41, tool$exportsCancel;
+var args54, tool$exportsCancel;
 var init_exportsCancel2 = __esm(() => {
   init_exportsCancel();
   init_cancelcustomerexportop();
   init_tools();
-  args41 = {
+  args54 = {
     request: CancelCustomerExportRequest$zodSchema
   };
   tool$exportsCancel = {
@@ -60124,7 +62762,7 @@ Cancel an export and remove its stored chunks. Repeating cancellation is safe. A
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args41,
+    args: args54,
     tool: async (client, args, ctx) => {
       const [result] = await exportsCancel(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -60215,9 +62853,9 @@ var init_createcustomerexportop = __esm(() => {
 
 // src/funcs/exportsCreate.ts
 function exportsCreate(client$, request, options) {
-  return new APIPromise($do41(client$, request, options));
+  return new APIPromise($do54(client$, request, options));
 }
-async function $do41(client$, request, options) {
+async function $do54(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => CreateCustomerExportRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -60288,12 +62926,12 @@ var init_exportsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/exportsCreate.ts
-var args42, tool$exportsCreate;
+var args55, tool$exportsCreate;
 var init_exportsCreate2 = __esm(() => {
   init_exportsCreate();
   init_createcustomerexportop();
   init_tools();
-  args42 = {
+  args55 = {
     request: CreateCustomerExportRequest$zodSchema
   };
   tool$exportsCreate = {
@@ -60308,7 +62946,7 @@ Request an encrypted JSON Lines snapshot of retained account or audit records. R
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args42,
+    args: args55,
     tool: async (client, args, ctx) => {
       const [result] = await exportsCreate(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -60377,9 +63015,9 @@ var init_downloadcustomerexportchunkop = __esm(() => {
 
 // src/funcs/exportsDownloadChunk.ts
 function exportsDownloadChunk(client$, request, options) {
-  return new APIPromise($do42(client$, request, options));
+  return new APIPromise($do55(client$, request, options));
 }
-async function $do42(client$, request, options) {
+async function $do55(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => DownloadCustomerExportChunkRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -60469,12 +63107,12 @@ var init_exportsDownloadChunk = __esm(() => {
 });
 
 // src/mcp-server/tools/exportsDownloadChunk.ts
-var args43, tool$exportsDownloadChunk;
+var args56, tool$exportsDownloadChunk;
 var init_exportsDownloadChunk2 = __esm(() => {
   init_exportsDownloadChunk();
   init_downloadcustomerexportchunkop();
   init_tools();
-  args43 = {
+  args56 = {
     request: DownloadCustomerExportChunkRequest$zodSchema
   };
   tool$exportsDownloadChunk = {
@@ -60489,7 +63127,7 @@ Download one chunk of a completed, unexpired export after a fresh permission and
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args43,
+    args: args56,
     tool: async (client, args, ctx) => {
       const [result] = await exportsDownloadChunk(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -60543,9 +63181,9 @@ var init_getcustomerexportop = __esm(() => {
 
 // src/funcs/exportsGet.ts
 function exportsGet(client$, request, options) {
-  return new APIPromise($do43(client$, request, options));
+  return new APIPromise($do56(client$, request, options));
 }
-async function $do43(client$, request, options) {
+async function $do56(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => GetCustomerExportRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -60631,12 +63269,12 @@ var init_exportsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/exportsGet.ts
-var args44, tool$exportsGet;
+var args57, tool$exportsGet;
 var init_exportsGet2 = __esm(() => {
   init_exportsGet();
   init_getcustomerexportop();
   init_tools();
-  args44 = {
+  args57 = {
     request: GetCustomerExportRequest$zodSchema
   };
   tool$exportsGet = {
@@ -60651,7 +63289,7 @@ Read the status of an authorised export. Records and bytes describe committed pr
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args44,
+    args: args57,
     tool: async (client, args, ctx) => {
       const [result] = await exportsGet(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -60721,9 +63359,9 @@ var init_listcustomerexportsop = __esm(() => {
 
 // src/funcs/exportsList.ts
 function exportsList(client$, request, options) {
-  return new APIPromise($do44(client$, request, options));
+  return new APIPromise($do57(client$, request, options));
 }
-async function $do44(client$, request, options) {
+async function $do57(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => ListCustomerExportsRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -60812,12 +63450,12 @@ var init_exportsList = __esm(() => {
 });
 
 // src/mcp-server/tools/exportsList.ts
-var args45, tool$exportsList;
+var args58, tool$exportsList;
 var init_exportsList2 = __esm(() => {
   init_exportsList();
   init_listcustomerexportsop();
   init_tools();
-  args45 = {
+  args58 = {
     request: ListCustomerExportsRequest$zodSchema
   };
   tool$exportsList = {
@@ -60832,7 +63470,7 @@ List authorised jobs for one kind and environment. Detailed jobs require current
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args45,
+    args: args58,
     tool: async (client, args, ctx) => {
       const [result] = await exportsList(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -60888,9 +63526,9 @@ var init_retrycustomerexportop = __esm(() => {
 
 // src/funcs/exportsRetry.ts
 function exportsRetry(client$, request, options) {
-  return new APIPromise($do45(client$, request, options));
+  return new APIPromise($do58(client$, request, options));
 }
-async function $do45(client$, request, options) {
+async function $do58(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => RetryCustomerExportRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -60964,12 +63602,12 @@ var init_exportsRetry = __esm(() => {
 });
 
 // src/mcp-server/tools/exportsRetry.ts
-var args46, tool$exportsRetry;
+var args59, tool$exportsRetry;
 var init_exportsRetry2 = __esm(() => {
   init_exportsRetry();
   init_retrycustomerexportop();
   init_tools();
-  args46 = {
+  args59 = {
     request: RetryCustomerExportRequest$zodSchema
   };
   tool$exportsRetry = {
@@ -60984,7 +63622,7 @@ Start a new generation of a failed export before its original expiry, up to ten
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args46,
+    args: args59,
     tool: async (client, args, ctx) => {
       const [result] = await exportsRetry(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -61034,9 +63672,9 @@ var init_integrationrequest = __esm(() => {
 
 // src/funcs/integrationsCreate.ts
 function integrationsCreate(client$, request, options) {
-  return new APIPromise($do46(client$, request, options));
+  return new APIPromise($do59(client$, request, options));
 }
-async function $do46(client$, request, options) {
+async function $do59(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => IntegrationRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -61100,12 +63738,12 @@ var init_integrationsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/integrationsCreate.ts
-var args47, tool$integrationsCreate;
+var args60, tool$integrationsCreate;
 var init_integrationsCreate2 = __esm(() => {
   init_integrationsCreate();
   init_integrationrequest();
   init_tools();
-  args47 = {
+  args60 = {
     request: IntegrationRequest$zodSchema
   };
   tool$integrationsCreate = {
@@ -61120,7 +63758,7 @@ Registers a WorkOS, Auth0 or Supabase integration and returns its hosted endpoin
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args47,
+    args: args60,
     tool: async (client, args, ctx) => {
       const [result] = await integrationsCreate(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -61170,9 +63808,9 @@ var init_deleteintegrationop = __esm(() => {
 
 // src/funcs/integrationsDelete.ts
 function integrationsDelete(client$, request, options) {
-  return new APIPromise($do47(client$, request, options));
+  return new APIPromise($do60(client$, request, options));
 }
-async function $do47(client$, request, options) {
+async function $do60(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => DeleteIntegrationRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -61254,12 +63892,12 @@ var init_integrationsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/integrationsDelete.ts
-var args48, tool$integrationsDelete;
+var args61, tool$integrationsDelete;
 var init_integrationsDelete2 = __esm(() => {
   init_integrationsDelete();
   init_deleteintegrationop();
   init_tools();
-  args48 = {
+  args61 = {
     request: DeleteIntegrationRequest$zodSchema
   };
   tool$integrationsDelete = {
@@ -61274,7 +63912,7 @@ Removes the integration and its secrets; its endpoint answers 404 from then on,
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args48,
+    args: args61,
     tool: async (client, args, ctx) => {
       const [result] = await integrationsDelete(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -61290,9 +63928,9 @@ Removes the integration and its secrets; its endpoint answers 404 from then on,
 
 // src/funcs/integrationsList.ts
 function integrationsList(client$, options) {
-  return new APIPromise($do48(client$, options));
+  return new APIPromise($do61(client$, options));
 }
-async function $do48(client$, options) {
+async function $do61(client$, options) {
   const path$ = pathToFunc("/v1/integrations")();
   const headers$ = new Headers(compactMap({
     Accept: options?.acceptHeaderOverride || "application/json;q=1, application/problem+json;q=0"
@@ -61455,9 +64093,9 @@ var init_rotateintegrationsecretop = __esm(() => {
 
 // src/funcs/integrationsRotate.ts
 function integrationsRotate(client$, request, options) {
-  return new APIPromise($do49(client$, request, options));
+  return new APIPromise($do62(client$, request, options));
 }
-async function $do49(client$, request, options) {
+async function $do62(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => RotateIntegrationSecretRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -61527,12 +64165,12 @@ var init_integrationsRotate = __esm(() => {
 });
 
 // src/mcp-server/tools/integrationsRotate.ts
-var args49, tool$integrationsRotate;
+var args62, tool$integrationsRotate;
 var init_integrationsRotate2 = __esm(() => {
   init_integrationsRotate();
   init_rotateintegrationsecretop();
   init_tools();
-  args49 = {
+  args62 = {
     request: RotateIntegrationSecretRequest$zodSchema
   };
   tool$integrationsRotate = {
@@ -61547,7 +64185,7 @@ For Auth0, send {} and the answer's secret is the new shared secret, shown once.
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args49,
+    args: args62,
     tool: async (client, args, ctx) => {
       const [result] = await integrationsRotate(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -61655,9 +64293,9 @@ var init_listinvitesop = __esm(() => {
 
 // src/funcs/invitesList.ts
 function invitesList(client$, request, options) {
-  return new APIPromise($do50(client$, request, options));
+  return new APIPromise($do63(client$, request, options));
 }
-async function $do50(client$, request, options) {
+async function $do63(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => ListInvitesRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -61739,12 +64377,12 @@ var init_invitesList = __esm(() => {
 });
 
 // src/mcp-server/tools/invitesList.ts
-var args50, tool$invitesList;
+var args63, tool$invitesList;
 var init_invitesList2 = __esm(() => {
   init_invitesList();
   init_listinvitesop();
   init_tools();
-  args50 = {
+  args63 = {
     request: ListInvitesRequest$zodSchema
   };
   tool$invitesList = {
@@ -61759,7 +64397,7 @@ Read pending workspace invitations with a live members_manage key. Tokens are ex
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args50,
+    args: args63,
     tool: async (client, args, ctx) => {
       const [result] = await invitesList(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -61810,9 +64448,9 @@ var init_revokeinviteop = __esm(() => {
 
 // src/funcs/invitesRevoke.ts
 function invitesRevoke(client$, request, options) {
-  return new APIPromise($do51(client$, request, options));
+  return new APIPromise($do64(client$, request, options));
 }
-async function $do51(client$, request, options) {
+async function $do64(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => RevokeInviteRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -61898,12 +64536,12 @@ var init_invitesRevoke = __esm(() => {
 });
 
 // src/mcp-server/tools/invitesRevoke.ts
-var args51, tool$invitesRevoke;
+var args64, tool$invitesRevoke;
 var init_invitesRevoke2 = __esm(() => {
   init_invitesRevoke();
   init_revokeinviteop();
   init_tools();
-  args51 = {
+  args64 = {
     request: RevokeInviteRequest$zodSchema
   };
   tool$invitesRevoke = {
@@ -61918,7 +64556,7 @@ Revoke a pending invitation with a live members_manage key. A revoked token cann
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args51,
+    args: args64,
     tool: async (client, args, ctx) => {
       const [result] = await invitesRevoke(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -61977,7 +64615,8 @@ var init_key = __esm(() => {
     "settings",
     "policy_publish",
     "members",
-    "members_manage"
+    "members_manage",
+    "events"
   ]);
   Key$zodSchema = object({
     created_at: string2(),
@@ -62050,9 +64689,9 @@ var init_listkeysop = __esm(() => {
 
 // src/funcs/keysList.ts
 function keysList(client$, request, options) {
-  return new APIPromise($do52(client$, request, options));
+  return new APIPromise($do65(client$, request, options));
 }
-async function $do52(client$, request, options) {
+async function $do65(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => ListKeysRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -62134,12 +64773,12 @@ var init_keysList = __esm(() => {
 });
 
 // src/mcp-server/tools/keysList.ts
-var args52, tool$keysList;
+var args65, tool$keysList;
 var init_keysList2 = __esm(() => {
   init_keysList();
   init_listkeysop();
   init_tools();
-  args52 = {
+  args65 = {
     request: ListKeysRequest$zodSchema
   };
   tool$keysList = {
@@ -62154,7 +64793,7 @@ Lists the keys of the signing key's environment, newest first, at most 200, revo
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args52,
+    args: args65,
     tool: async (client, args, ctx) => {
       const [result] = await keysList(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -62208,9 +64847,9 @@ var init_revokekeyop = __esm(() => {
 
 // src/funcs/keysRevoke.ts
 function keysRevoke(client$, request, options) {
-  return new APIPromise($do53(client$, request, options));
+  return new APIPromise($do66(client$, request, options));
 }
-async function $do53(client$, request, options) {
+async function $do66(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => RevokeKeyRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -62296,12 +64935,12 @@ var init_keysRevoke = __esm(() => {
 });
 
 // src/mcp-server/tools/keysRevoke.ts
-var args53, tool$keysRevoke;
+var args66, tool$keysRevoke;
 var init_keysRevoke2 = __esm(() => {
   init_keysRevoke();
   init_revokekeyop();
   init_tools();
-  args53 = {
+  args66 = {
     request: RevokeKeyRequest$zodSchema
   };
   tool$keysRevoke = {
@@ -62316,7 +64955,7 @@ Revokes a key of the signing key's environment at once: its next request answers
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args53,
+    args: args66,
     tool: async (client, args, ctx) => {
       const [result] = await keysRevoke(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -62458,9 +65097,9 @@ var init_changelistsop = __esm(() => {
 
 // src/funcs/listsChange.ts
 function listsChange(client$, request, options) {
-  return new APIPromise($do54(client$, request, options));
+  return new APIPromise($do67(client$, request, options));
 }
-async function $do54(client$, request, options) {
+async function $do67(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => ChangeListsRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -62548,12 +65187,12 @@ var init_listsChange = __esm(() => {
 });
 
 // src/mcp-server/tools/listsChange.ts
-var args54, tool$listsChange;
+var args67, tool$listsChange;
 var init_listsChange2 = __esm(() => {
   init_listsChange();
   init_changelistsop();
   init_tools();
-  args54 = {
+  args67 = {
     request: ChangeListsRequest$zodSchema
   };
   tool$listsChange = {
@@ -62568,7 +65207,7 @@ Atomically add and remove a bounded batch of entries with an idempotency key. Re
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args54,
+    args: args67,
     tool: async (client, args, ctx) => {
       const [result] = await listsChange(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -62625,9 +65264,9 @@ var init_createlistentryop = __esm(() => {
 
 // src/funcs/listsCreate.ts
 function listsCreate(client$, request, options) {
-  return new APIPromise($do55(client$, request, options));
+  return new APIPromise($do68(client$, request, options));
 }
-async function $do55(client$, request, options) {
+async function $do68(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => CreateListEntryRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -62714,12 +65353,12 @@ var init_listsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/listsCreate.ts
-var args55, tool$listsCreate;
+var args68, tool$listsCreate;
 var init_listsCreate2 = __esm(() => {
   init_listsCreate();
   init_createlistentryop();
   init_tools();
-  args55 = {
+  args68 = {
     request: CreateListEntryRequest$zodSchema
   };
   tool$listsCreate = {
@@ -62734,7 +65373,7 @@ Add a canonical email or email-domain override with a reason and optional expiry
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args55,
+    args: args68,
     tool: async (client, args, ctx) => {
       const [result] = await listsCreate(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -62787,9 +65426,9 @@ var init_deletelistentryop = __esm(() => {
 
 // src/funcs/listsDelete.ts
 function listsDelete(client$, request, options) {
-  return new APIPromise($do56(client$, request, options));
+  return new APIPromise($do69(client$, request, options));
 }
-async function $do56(client$, request, options) {
+async function $do69(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => DeleteListEntryRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -62879,12 +65518,12 @@ var init_listsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/listsDelete.ts
-var args56, tool$listsDelete;
+var args69, tool$listsDelete;
 var init_listsDelete2 = __esm(() => {
   init_listsDelete();
   init_deletelistentryop();
   init_tools();
-  args56 = {
+  args69 = {
     request: DeleteListEntryRequest$zodSchema
   };
   tool$listsDelete = {
@@ -62899,7 +65538,7 @@ Remove an override with settings plus policy_publish, or legacy management. The
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args56,
+    args: args69,
     tool: async (client, args, ctx) => {
       const [result] = await listsDelete(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -62955,9 +65594,9 @@ var init_getlistchangeop = __esm(() => {
 
 // src/funcs/listsGetChange.ts
 function listsGetChange(client$, request, options) {
-  return new APIPromise($do57(client$, request, options));
+  return new APIPromise($do70(client$, request, options));
 }
-async function $do57(client$, request, options) {
+async function $do70(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => GetListChangeRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -63047,12 +65686,12 @@ var init_listsGetChange = __esm(() => {
 });
 
 // src/mcp-server/tools/listsGetChange.ts
-var args57, tool$listsGetChange;
+var args70, tool$listsGetChange;
 var init_listsGetChange2 = __esm(() => {
   init_listsGetChange();
   init_getlistchangeop();
   init_tools();
-  args57 = {
+  args70 = {
     request: GetListChangeRequest$zodSchema
   };
   tool$listsGetChange = {
@@ -63067,7 +65706,7 @@ Read retained propagation progress for a list change with settings or management
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args57,
+    args: args70,
     tool: async (client, args, ctx) => {
       const [result] = await listsGetChange(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -63135,9 +65774,9 @@ var init_listlistentriesop = __esm(() => {
 
 // src/funcs/listsList.ts
 function listsList(client$, request, options) {
-  return new APIPromise($do58(client$, request, options));
+  return new APIPromise($do71(client$, request, options));
 }
-async function $do58(client$, request, options) {
+async function $do71(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => ListListEntriesRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -63228,12 +65867,12 @@ var init_listsList = __esm(() => {
 });
 
 // src/mcp-server/tools/listsList.ts
-var args58, tool$listsList;
+var args71, tool$listsList;
 var init_listsList2 = __esm(() => {
   init_listsList();
   init_listlistentriesop();
   init_tools();
-  args58 = {
+  args71 = {
     request: ListListEntriesRequest$zodSchema
   };
   tool$listsList = {
@@ -63248,7 +65887,7 @@ Page through this environment allow and block entries, with canonical values, re
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args58,
+    args: args71,
     tool: async (client, args, ctx) => {
       const [result] = await listsList(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -63380,9 +66019,9 @@ var init_previewlistop = __esm(() => {
 
 // src/funcs/listsPreview.ts
 function listsPreview(client$, request, options) {
-  return new APIPromise($do59(client$, request, options));
+  return new APIPromise($do72(client$, request, options));
 }
-async function $do59(client$, request, options) {
+async function $do72(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => PreviewListRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -63469,12 +66108,12 @@ var init_listsPreview = __esm(() => {
 });
 
 // src/mcp-server/tools/listsPreview.ts
-var args59, tool$listsPreview;
+var args72, tool$listsPreview;
 var init_listsPreview2 = __esm(() => {
   init_listsPreview();
   init_previewlistop();
   init_tools();
-  args59 = {
+  args72 = {
     request: PreviewListRequest$zodSchema
   };
   tool$listsPreview = {
@@ -63489,7 +66128,7 @@ Preview canonical list matches and current override effects with settings or man
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args59,
+    args: args72,
     tool: async (client, args, ctx) => {
       const [result] = await listsPreview(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -63592,9 +66231,9 @@ var init_listmembersop = __esm(() => {
 
 // src/funcs/membersList.ts
 function membersList(client$, request, options) {
-  return new APIPromise($do60(client$, request, options));
+  return new APIPromise($do73(client$, request, options));
 }
-async function $do60(client$, request, options) {
+async function $do73(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => ListMembersRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -63676,12 +66315,12 @@ var init_membersList = __esm(() => {
 });
 
 // src/mcp-server/tools/membersList.ts
-var args60, tool$membersList;
+var args73, tool$membersList;
 var init_membersList2 = __esm(() => {
   init_membersList();
   init_listmembersop();
   init_tools();
-  args60 = {
+  args73 = {
     request: ListMembersRequest$zodSchema
   };
   tool$membersList = {
@@ -63696,7 +66335,7 @@ Read the workspace directory with a live key carrying members or members_manage.
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args60,
+    args: args73,
     tool: async (client, args, ctx) => {
       const [result] = await membersList(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -63747,9 +66386,9 @@ var init_removememberop = __esm(() => {
 
 // src/funcs/membersRemove.ts
 function membersRemove(client$, request, options) {
-  return new APIPromise($do61(client$, request, options));
+  return new APIPromise($do74(client$, request, options));
 }
-async function $do61(client$, request, options) {
+async function $do74(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => RemoveMemberRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -63835,12 +66474,12 @@ var init_membersRemove = __esm(() => {
 });
 
 // src/mcp-server/tools/membersRemove.ts
-var args61, tool$membersRemove;
+var args74, tool$membersRemove;
 var init_membersRemove2 = __esm(() => {
   init_membersRemove();
   init_removememberop();
   init_tools();
-  args61 = {
+  args74 = {
     request: RemoveMemberRequest$zodSchema
   };
   tool$membersRemove = {
@@ -63855,7 +66494,7 @@ Remove a non-owner member with a live members_manage key. Subsequent access is r
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args61,
+    args: args74,
     tool: async (client, args, ctx) => {
       const [result] = await membersRemove(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -63932,9 +66571,9 @@ var init_updatememberop = __esm(() => {
 
 // src/funcs/membersUpdate.ts
 function membersUpdate(client$, request, options) {
-  return new APIPromise($do62(client$, request, options));
+  return new APIPromise($do75(client$, request, options));
 }
-async function $do62(client$, request, options) {
+async function $do75(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => UpdateMemberRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -64021,12 +66660,12 @@ var init_membersUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/membersUpdate.ts
-var args62, tool$membersUpdate;
+var args75, tool$membersUpdate;
 var init_membersUpdate2 = __esm(() => {
   init_membersUpdate();
   init_updatememberop();
   init_tools();
-  args62 = {
+  args75 = {
     request: UpdateMemberRequest$zodSchema
   };
   tool$membersUpdate = {
@@ -64041,7 +66680,7 @@ Update a non-owner member role, environment access or sensitive permission exclu
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args62,
+    args: args75,
     tool: async (client, args, ctx) => {
       const [result] = await membersUpdate(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -64218,9 +66857,9 @@ var init_summarizeworkspaceoperationsop = __esm(() => {
 
 // src/funcs/operationsSummarize.ts
 function operationsSummarize(client$, request, options) {
-  return new APIPromise($do63(client$, request, options));
+  return new APIPromise($do76(client$, request, options));
 }
-async function $do63(client$, request, options) {
+async function $do76(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => SummarizeWorkspaceOperationsRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -64303,12 +66942,12 @@ var init_operationsSummarize = __esm(() => {
 });
 
 // src/mcp-server/tools/operationsSummarize.ts
-var args63, tool$operationsSummarize;
+var args76, tool$operationsSummarize;
 var init_operationsSummarize2 = __esm(() => {
   init_operationsSummarize();
   init_summarizeworkspaceoperationsop();
   init_tools();
-  args63 = {
+  args76 = {
     request: SummarizeWorkspaceOperationsRequest$zodSchema
   };
   tool$operationsSummarize = {
@@ -64323,7 +66962,7 @@ Read one retained snapshot of account outcomes, enforcement reports and review s
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args63,
+    args: args76,
     tool: async (client, args, ctx) => {
       const [result] = await operationsSummarize(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -64364,9 +67003,9 @@ var init_requestaggregaterequest = __esm(() => {
 
 // src/funcs/requestsAggregate.ts
 function requestsAggregate(client$, request, options) {
-  return new APIPromise($do64(client$, request, options));
+  return new APIPromise($do77(client$, request, options));
 }
-async function $do64(client$, request, options) {
+async function $do77(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => RequestAggregateRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -64443,12 +67082,12 @@ var init_requestsAggregate = __esm(() => {
 });
 
 // src/mcp-server/tools/requestsAggregate.ts
-var args64, tool$requestsAggregate;
+var args77, tool$requestsAggregate;
 var init_requestsAggregate2 = __esm(() => {
   init_requestsAggregate();
   init_requestaggregaterequest();
   init_tools();
-  args64 = {
+  args77 = {
     request: RequestAggregateRequest$zodSchema
   };
   tool$requestsAggregate = {
@@ -64463,7 +67102,7 @@ Count all retained matching request attempts and latency samples within seven da
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args64,
+    args: args77,
     tool: async (client, args, ctx) => {
       const [result] = await requestsAggregate(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -64534,9 +67173,9 @@ var init_listrequestdiagnosticsop = __esm(() => {
 
 // src/funcs/requestsList.ts
 function requestsList(client$, request, options) {
-  return new APIPromise($do65(client$, request, options));
+  return new APIPromise($do78(client$, request, options));
 }
-async function $do65(client$, request, options) {
+async function $do78(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => ListRequestDiagnosticsRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -64623,12 +67262,12 @@ var init_requestsList = __esm(() => {
 });
 
 // src/mcp-server/tools/requestsList.ts
-var args65, tool$requestsList;
+var args78, tool$requestsList;
 var init_requestsList2 = __esm(() => {
   init_requestsList();
   init_listrequestdiagnosticsop();
   init_tools();
-  args65 = {
+  args78 = {
     request: ListRequestDiagnosticsRequest$zodSchema
   };
   tool$requestsList = {
@@ -64643,7 +67282,7 @@ Search authenticated request attempts by time, route, status or request correlat
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args65,
+    args: args78,
     tool: async (client, args, ctx) => {
       const [result] = await requestsList(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -64758,9 +67397,9 @@ var init_addreviewsubjectop = __esm(() => {
 
 // src/funcs/reviewsAddSubject.ts
 function reviewsAddSubject(client$, request, options) {
-  return new APIPromise($do66(client$, request, options));
+  return new APIPromise($do79(client$, request, options));
 }
-async function $do66(client$, request, options) {
+async function $do79(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => AddReviewSubjectRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -64838,12 +67477,12 @@ var init_reviewsAddSubject = __esm(() => {
 });
 
 // src/mcp-server/tools/reviewsAddSubject.ts
-var args66, tool$reviewsAddSubject;
+var args79, tool$reviewsAddSubject;
 var init_reviewsAddSubject2 = __esm(() => {
   init_reviewsAddSubject();
   init_addreviewsubjectop();
   init_tools();
-  args66 = {
+  args79 = {
     request: AddReviewSubjectRequest$zodSchema
   };
   tool$reviewsAddSubject = {
@@ -64858,7 +67497,7 @@ Link an account, exact assessment revision or issued-key association within this
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args66,
+    args: args79,
     tool: async (client, args, ctx) => {
       const [result] = await reviewsAddSubject(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -64939,9 +67578,9 @@ var init_commentreviewop = __esm(() => {
 
 // src/funcs/reviewsComment.ts
 function reviewsComment(client$, request, options) {
-  return new APIPromise($do67(client$, request, options));
+  return new APIPromise($do80(client$, request, options));
 }
-async function $do67(client$, request, options) {
+async function $do80(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => CommentReviewRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -65019,12 +67658,12 @@ var init_reviewsComment = __esm(() => {
 });
 
 // src/mcp-server/tools/reviewsComment.ts
-var args67, tool$reviewsComment;
+var args80, tool$reviewsComment;
 var init_reviewsComment2 = __esm(() => {
   init_reviewsComment();
   init_commentreviewop();
   init_tools();
-  args67 = {
+  args80 = {
     request: CommentReviewRequest$zodSchema
   };
   tool$reviewsComment = {
@@ -65039,7 +67678,7 @@ Append a comment after checking the expected review version.`,
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args67,
+    args: args80,
     tool: async (client, args, ctx) => {
       const [result] = await reviewsComment(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -65185,9 +67824,9 @@ var init_createreviewop = __esm(() => {
 
 // src/funcs/reviewsCreate.ts
 function reviewsCreate(client$, request, options) {
-  return new APIPromise($do68(client$, request, options));
+  return new APIPromise($do81(client$, request, options));
 }
-async function $do68(client$, request, options) {
+async function $do81(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => CreateReviewRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -65261,12 +67900,12 @@ var init_reviewsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/reviewsCreate.ts
-var args68, tool$reviewsCreate;
+var args81, tool$reviewsCreate;
 var init_reviewsCreate2 = __esm(() => {
   init_reviewsCreate();
   init_createreviewop();
   init_tools();
-  args68 = {
+  args81 = {
     request: CreateReviewRequest$zodSchema
   };
   tool$reviewsCreate = {
@@ -65281,7 +67920,7 @@ Open a review for one account. An account can have one active review in its envi
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args68,
+    args: args81,
     tool: async (client, args, ctx) => {
       const [result] = await reviewsCreate(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -65397,9 +68036,9 @@ var init_createreviewviewop = __esm(() => {
 
 // src/funcs/reviewsCreateView.ts
 function reviewsCreateView(client$, request, options) {
-  return new APIPromise($do69(client$, request, options));
+  return new APIPromise($do82(client$, request, options));
 }
-async function $do69(client$, request, options) {
+async function $do82(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => CreateReviewViewRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -65473,12 +68112,12 @@ var init_reviewsCreateView = __esm(() => {
 });
 
 // src/mcp-server/tools/reviewsCreateView.ts
-var args69, tool$reviewsCreateView;
+var args82, tool$reviewsCreateView;
 var init_reviewsCreateView2 = __esm(() => {
   init_reviewsCreateView();
   init_createreviewviewop();
   init_tools();
-  args69 = {
+  args82 = {
     request: CreateReviewViewRequest$zodSchema
   };
   tool$reviewsCreateView = {
@@ -65493,7 +68132,7 @@ Save a private or shared review filter.`,
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args69,
+    args: args82,
     tool: async (client, args, ctx) => {
       const [result] = await reviewsCreateView(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -65561,9 +68200,9 @@ var init_deletereviewsubjectop = __esm(() => {
 
 // src/funcs/reviewsDeleteSubject.ts
 function reviewsDeleteSubject(client$, request, options) {
-  return new APIPromise($do70(client$, request, options));
+  return new APIPromise($do83(client$, request, options));
 }
-async function $do70(client$, request, options) {
+async function $do83(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => DeleteReviewSubjectRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -65658,12 +68297,12 @@ var init_reviewsDeleteSubject = __esm(() => {
 });
 
 // src/mcp-server/tools/reviewsDeleteSubject.ts
-var args70, tool$reviewsDeleteSubject;
+var args83, tool$reviewsDeleteSubject;
 var init_reviewsDeleteSubject2 = __esm(() => {
   init_reviewsDeleteSubject();
   init_deletereviewsubjectop();
   init_tools();
-  args70 = {
+  args83 = {
     request: DeleteReviewSubjectRequest$zodSchema
   };
   tool$reviewsDeleteSubject = {
@@ -65678,7 +68317,7 @@ Remove a subject link with the expected review version. The linked account, asse
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args70,
+    args: args83,
     tool: async (client, args, ctx) => {
       const [result] = await reviewsDeleteSubject(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -65733,9 +68372,9 @@ var init_deletereviewviewop = __esm(() => {
 
 // src/funcs/reviewsDeleteView.ts
 function reviewsDeleteView(client$, request, options) {
-  return new APIPromise($do71(client$, request, options));
+  return new APIPromise($do84(client$, request, options));
 }
-async function $do71(client$, request, options) {
+async function $do84(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => DeleteReviewViewRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -65826,12 +68465,12 @@ var init_reviewsDeleteView = __esm(() => {
 });
 
 // src/mcp-server/tools/reviewsDeleteView.ts
-var args71, tool$reviewsDeleteView;
+var args84, tool$reviewsDeleteView;
 var init_reviewsDeleteView2 = __esm(() => {
   init_reviewsDeleteView();
   init_deletereviewviewop();
   init_tools();
-  args71 = {
+  args84 = {
     request: DeleteReviewViewRequest$zodSchema
   };
   tool$reviewsDeleteView = {
@@ -65846,7 +68485,7 @@ Delete your saved review filter after checking its expected version.`,
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args71,
+    args: args84,
     tool: async (client, args, ctx) => {
       const [result] = await reviewsDeleteView(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -65919,9 +68558,9 @@ var init_exportreviewop = __esm(() => {
 
 // src/funcs/reviewsExport.ts
 function reviewsExport(client$, request, options) {
-  return new APIPromise($do72(client$, request, options));
+  return new APIPromise($do85(client$, request, options));
 }
-async function $do72(client$, request, options) {
+async function $do85(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => ExportReviewRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -66011,12 +68650,12 @@ var init_reviewsExport = __esm(() => {
 });
 
 // src/mcp-server/tools/reviewsExport.ts
-var args72, tool$reviewsExport;
+var args85, tool$reviewsExport;
 var init_reviewsExport2 = __esm(() => {
   init_reviewsExport();
   init_exportreviewop();
   init_tools();
-  args72 = {
+  args85 = {
     request: ExportReviewRequest$zodSchema
   };
   tool$reviewsExport = {
@@ -66031,7 +68670,7 @@ Export retained review details, comments, resolutions and linked subjects. Requi
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args72,
+    args: args85,
     tool: async (client, args, ctx) => {
       const [result] = await reviewsExport(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -66087,9 +68726,9 @@ var init_getreviewop = __esm(() => {
 
 // src/funcs/reviewsGet.ts
 function reviewsGet(client$, request, options) {
-  return new APIPromise($do73(client$, request, options));
+  return new APIPromise($do86(client$, request, options));
 }
-async function $do73(client$, request, options) {
+async function $do86(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => GetReviewRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -66179,12 +68818,12 @@ var init_reviewsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/reviewsGet.ts
-var args73, tool$reviewsGet;
+var args86, tool$reviewsGet;
 var init_reviewsGet2 = __esm(() => {
   init_reviewsGet();
   init_getreviewop();
   init_tools();
-  args73 = {
+  args86 = {
     request: GetReviewRequest$zodSchema
   };
   tool$reviewsGet = {
@@ -66199,7 +68838,7 @@ Read a retained review and its current version.`,
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args73,
+    args: args86,
     tool: async (client, args, ctx) => {
       const [result] = await reviewsGet(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -66274,9 +68913,9 @@ var init_listreviewsop = __esm(() => {
 
 // src/funcs/reviewsList.ts
 function reviewsList(client$, request, options) {
-  return new APIPromise($do74(client$, request, options));
+  return new APIPromise($do87(client$, request, options));
 }
-async function $do74(client$, request, options) {
+async function $do87(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => ListReviewsRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -66372,12 +69011,12 @@ var init_reviewsList = __esm(() => {
 });
 
 // src/mcp-server/tools/reviewsList.ts
-var args74, tool$reviewsList;
+var args87, tool$reviewsList;
 var init_reviewsList2 = __esm(() => {
   init_reviewsList();
   init_listreviewsop();
   init_tools();
-  args74 = {
+  args87 = {
     request: ListReviewsRequest$zodSchema
   };
   tool$reviewsList = {
@@ -66392,7 +69031,7 @@ List retained investigation reviews using filters and an authenticated cursor. U
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args74,
+    args: args87,
     tool: async (client, args, ctx) => {
       const [result] = await reviewsList(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -66461,9 +69100,9 @@ var init_listreviewcommentsop = __esm(() => {
 
 // src/funcs/reviewsListComments.ts
 function reviewsListComments(client$, request, options) {
-  return new APIPromise($do75(client$, request, options));
+  return new APIPromise($do88(client$, request, options));
 }
-async function $do75(client$, request, options) {
+async function $do88(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => ListReviewCommentsRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -66558,12 +69197,12 @@ var init_reviewsListComments = __esm(() => {
 });
 
 // src/mcp-server/tools/reviewsListComments.ts
-var args75, tool$reviewsListComments;
+var args88, tool$reviewsListComments;
 var init_reviewsListComments2 = __esm(() => {
   init_reviewsListComments();
   init_listreviewcommentsop();
   init_tools();
-  args75 = {
+  args88 = {
     request: ListReviewCommentsRequest$zodSchema
   };
   tool$reviewsListComments = {
@@ -66578,7 +69217,7 @@ Page through retained review comments.`,
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args75,
+    args: args88,
     tool: async (client, args, ctx) => {
       const [result] = await reviewsListComments(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -66647,9 +69286,9 @@ var init_listreviewresolutionsop = __esm(() => {
 
 // src/funcs/reviewsListResolutions.ts
 function reviewsListResolutions(client$, request, options) {
-  return new APIPromise($do76(client$, request, options));
+  return new APIPromise($do89(client$, request, options));
 }
-async function $do76(client$, request, options) {
+async function $do89(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => ListReviewResolutionsRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -66744,12 +69383,12 @@ var init_reviewsListResolutions = __esm(() => {
 });
 
 // src/mcp-server/tools/reviewsListResolutions.ts
-var args76, tool$reviewsListResolutions;
+var args89, tool$reviewsListResolutions;
 var init_reviewsListResolutions2 = __esm(() => {
   init_reviewsListResolutions();
   init_listreviewresolutionsop();
   init_tools();
-  args76 = {
+  args89 = {
     request: ListReviewResolutionsRequest$zodSchema
   };
   tool$reviewsListResolutions = {
@@ -66764,7 +69403,7 @@ Page through immutable review resolutions.`,
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args76,
+    args: args89,
     tool: async (client, args, ctx) => {
       const [result] = await reviewsListResolutions(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -66831,9 +69470,9 @@ var init_listreviewsubjectsop = __esm(() => {
 
 // src/funcs/reviewsListSubjects.ts
 function reviewsListSubjects(client$, request, options) {
-  return new APIPromise($do77(client$, request, options));
+  return new APIPromise($do90(client$, request, options));
 }
-async function $do77(client$, request, options) {
+async function $do90(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => ListReviewSubjectsRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -66923,12 +69562,12 @@ var init_reviewsListSubjects = __esm(() => {
 });
 
 // src/mcp-server/tools/reviewsListSubjects.ts
-var args77, tool$reviewsListSubjects;
+var args90, tool$reviewsListSubjects;
 var init_reviewsListSubjects2 = __esm(() => {
   init_reviewsListSubjects();
   init_listreviewsubjectsop();
   init_tools();
-  args77 = {
+  args90 = {
     request: ListReviewSubjectsRequest$zodSchema
   };
   tool$reviewsListSubjects = {
@@ -66943,7 +69582,7 @@ List retained subjects linked to this review. A link supplies investigation cont
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args77,
+    args: args90,
     tool: async (client, args, ctx) => {
       const [result] = await reviewsListSubjects(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -67008,9 +69647,9 @@ var init_listreviewviewsop = __esm(() => {
 
 // src/funcs/reviewsListViews.ts
 function reviewsListViews(client$, request, options) {
-  return new APIPromise($do78(client$, request, options));
+  return new APIPromise($do91(client$, request, options));
 }
-async function $do78(client$, request, options) {
+async function $do91(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => ListReviewViewsRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -67096,12 +69735,12 @@ var init_reviewsListViews = __esm(() => {
 });
 
 // src/mcp-server/tools/reviewsListViews.ts
-var args78, tool$reviewsListViews;
+var args91, tool$reviewsListViews;
 var init_reviewsListViews2 = __esm(() => {
   init_reviewsListViews();
   init_listreviewviewsop();
   init_tools();
-  args78 = {
+  args91 = {
     request: ListReviewViewsRequest$zodSchema
   };
   tool$reviewsListViews = {
@@ -67116,7 +69755,7 @@ List private and shared saved review filters visible to you.`,
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args78,
+    args: args91,
     tool: async (client, args, ctx) => {
       const [result] = await reviewsListViews(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -67191,9 +69830,9 @@ var init_queryreviewsop = __esm(() => {
 
 // src/funcs/reviewsQuery.ts
 function reviewsQuery(client$, request, options) {
-  return new APIPromise($do79(client$, request, options));
+  return new APIPromise($do92(client$, request, options));
 }
-async function $do79(client$, request, options) {
+async function $do92(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => QueryReviewsRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -67280,12 +69919,12 @@ var init_reviewsQuery = __esm(() => {
 });
 
 // src/mcp-server/tools/reviewsQuery.ts
-var args79, tool$reviewsQuery;
+var args92, tool$reviewsQuery;
 var init_reviewsQuery2 = __esm(() => {
   init_reviewsQuery();
   init_queryreviewsop();
   init_tools();
-  args79 = {
+  args92 = {
     request: QueryReviewsRequest$zodSchema
   };
   tool$reviewsQuery = {
@@ -67300,7 +69939,7 @@ Query retained investigation reviews using a JSON body, including an exact accou
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args79,
+    args: args92,
     tool: async (client, args, ctx) => {
       const [result] = await reviewsQuery(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -67371,9 +70010,9 @@ var init_resolvereviewop = __esm(() => {
 
 // src/funcs/reviewsResolve.ts
 function reviewsResolve(client$, request, options) {
-  return new APIPromise($do80(client$, request, options));
+  return new APIPromise($do93(client$, request, options));
 }
-async function $do80(client$, request, options) {
+async function $do93(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => ResolveReviewRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -67451,12 +70090,12 @@ var init_reviewsResolve = __esm(() => {
 });
 
 // src/mcp-server/tools/reviewsResolve.ts
-var args80, tool$reviewsResolve;
+var args93, tool$reviewsResolve;
 var init_reviewsResolve2 = __esm(() => {
   init_reviewsResolve();
   init_resolvereviewop();
   init_tools();
-  args80 = {
+  args93 = {
     request: ResolveReviewRequest$zodSchema
   };
   tool$reviewsResolve = {
@@ -67471,7 +70110,7 @@ Resolve a review against the exact current review and account decision versions.
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args80,
+    args: args93,
     tool: async (client, args, ctx) => {
       const [result] = await reviewsResolve(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -67553,9 +70192,9 @@ var init_updatereviewop = __esm(() => {
 
 // src/funcs/reviewsUpdate.ts
 function reviewsUpdate(client$, request, options) {
-  return new APIPromise($do81(client$, request, options));
+  return new APIPromise($do94(client$, request, options));
 }
-async function $do81(client$, request, options) {
+async function $do94(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => UpdateReviewRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -67633,12 +70272,12 @@ var init_reviewsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/reviewsUpdate.ts
-var args81, tool$reviewsUpdate;
+var args94, tool$reviewsUpdate;
 var init_reviewsUpdate2 = __esm(() => {
   init_reviewsUpdate();
   init_updatereviewop();
   init_tools();
-  args81 = {
+  args94 = {
     request: UpdateReviewRequest$zodSchema
   };
   tool$reviewsUpdate = {
@@ -67653,7 +70292,7 @@ Change review status, priority or assignment after checking the expected version
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args81,
+    args: args94,
     tool: async (client, args, ctx) => {
       const [result] = await reviewsUpdate(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -67711,9 +70350,9 @@ var init_updatereviewviewop = __esm(() => {
 
 // src/funcs/reviewsUpdateView.ts
 function reviewsUpdateView(client$, request, options) {
-  return new APIPromise($do82(client$, request, options));
+  return new APIPromise($do95(client$, request, options));
 }
-async function $do82(client$, request, options) {
+async function $do95(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => UpdateReviewViewRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -67791,12 +70430,12 @@ var init_reviewsUpdateView = __esm(() => {
 });
 
 // src/mcp-server/tools/reviewsUpdateView.ts
-var args82, tool$reviewsUpdateView;
+var args95, tool$reviewsUpdateView;
 var init_reviewsUpdateView2 = __esm(() => {
   init_reviewsUpdateView();
   init_updatereviewviewop();
   init_tools();
-  args82 = {
+  args95 = {
     request: UpdateReviewViewRequest$zodSchema
   };
   tool$reviewsUpdateView = {
@@ -67811,7 +70450,7 @@ Update your saved review filter after checking its expected version.`,
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args82,
+    args: args95,
     tool: async (client, args, ctx) => {
       const [result] = await reviewsUpdateView(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -67866,9 +70505,9 @@ var init_getsettingsop = __esm(() => {
 
 // src/funcs/settingsGet.ts
 function settingsGet(client$, request, options) {
-  return new APIPromise($do83(client$, request, options));
+  return new APIPromise($do96(client$, request, options));
 }
-async function $do83(client$, request, options) {
+async function $do96(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => GetSettingsRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -67954,12 +70593,12 @@ var init_settingsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/settingsGet.ts
-var args83, tool$settingsGet;
+var args96, tool$settingsGet;
 var init_settingsGet2 = __esm(() => {
   init_settingsGet();
   init_getsettingsop();
   init_tools();
-  args83 = {
+  args96 = {
     request: GetSettingsRequest$zodSchema
   };
   tool$settingsGet = {
@@ -67974,7 +70613,7 @@ Read this environment retention, source selection and effective flow policies. A
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args83,
+    args: args96,
     tool: async (client, args, ctx) => {
       const [result] = await settingsGet(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -68077,9 +70716,9 @@ var init_listpolicyhistoryop = __esm(() => {
 
 // src/funcs/settingsListHistory.ts
 function settingsListHistory(client$, request, options) {
-  return new APIPromise($do84(client$, request, options));
+  return new APIPromise($do97(client$, request, options));
 }
-async function $do84(client$, request, options) {
+async function $do97(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => ListPolicyHistoryRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -68170,12 +70809,12 @@ var init_settingsListHistory = __esm(() => {
 });
 
 // src/mcp-server/tools/settingsListHistory.ts
-var args84, tool$settingsListHistory;
+var args97, tool$settingsListHistory;
 var init_settingsListHistory2 = __esm(() => {
   init_settingsListHistory();
   init_listpolicyhistoryop();
   init_tools();
-  args84 = {
+  args97 = {
     request: ListPolicyHistoryRequest$zodSchema
   };
   tool$settingsListHistory = {
@@ -68190,7 +70829,7 @@ Read immutable configuration versions in one environment with settings or manage
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args84,
+    args: args97,
     tool: async (client, args, ctx) => {
       const [result] = await settingsListHistory(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -68369,9 +71008,9 @@ var init_previewpolicyop = __esm(() => {
 
 // src/funcs/settingsPreview.ts
 function settingsPreview(client$, request, options) {
-  return new APIPromise($do85(client$, request, options));
+  return new APIPromise($do98(client$, request, options));
 }
-async function $do85(client$, request, options) {
+async function $do98(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => PreviewPolicyRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -68458,12 +71097,12 @@ var init_settingsPreview = __esm(() => {
 });
 
 // src/mcp-server/tools/settingsPreview.ts
-var args85, tool$settingsPreview;
+var args98, tool$settingsPreview;
 var init_settingsPreview2 = __esm(() => {
   init_settingsPreview();
   init_previewpolicyop();
   init_tools();
-  args85 = {
+  args98 = {
     request: PreviewPolicyRequest$zodSchema
   };
   tool$settingsPreview = {
@@ -68478,7 +71117,7 @@ Compare proposed policy with bounded retained first answers, including baseline,
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args85,
+    args: args98,
     tool: async (client, args, ctx) => {
       const [result] = await settingsPreview(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -68546,9 +71185,9 @@ var init_restorepolicyop = __esm(() => {
 
 // src/funcs/settingsRestore.ts
 function settingsRestore(client$, request, options) {
-  return new APIPromise($do86(client$, request, options));
+  return new APIPromise($do99(client$, request, options));
 }
-async function $do86(client$, request, options) {
+async function $do99(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => RestorePolicyRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -68622,12 +71261,12 @@ var init_settingsRestore = __esm(() => {
 });
 
 // src/mcp-server/tools/settingsRestore.ts
-var args86, tool$settingsRestore;
+var args99, tool$settingsRestore;
 var init_settingsRestore2 = __esm(() => {
   init_settingsRestore();
   init_restorepolicyop();
   init_tools();
-  args86 = {
+  args99 = {
     request: RestorePolicyRequest$zodSchema
   };
   tool$settingsRestore = {
@@ -68642,7 +71281,7 @@ Restore a retained configuration as a fresh version with the expected current ve
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args86,
+    args: args99,
     tool: async (client, args, ctx) => {
       const [result] = await settingsRestore(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -68747,9 +71386,9 @@ var init_updatesettingsop = __esm(() => {
 
 // src/funcs/settingsUpdate.ts
 function settingsUpdate(client$, request, options) {
-  return new APIPromise($do87(client$, request, options));
+  return new APIPromise($do100(client$, request, options));
 }
-async function $do87(client$, request, options) {
+async function $do100(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => UpdateSettingsRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -68836,12 +71475,12 @@ var init_settingsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/settingsUpdate.ts
-var args87, tool$settingsUpdate;
+var args100, tool$settingsUpdate;
 var init_settingsUpdate2 = __esm(() => {
   init_settingsUpdate();
   init_updatesettingsop();
   init_tools();
-  args87 = {
+  args100 = {
     request: UpdateSettingsRequest$zodSchema
   };
   tool$settingsUpdate = {
@@ -68856,7 +71495,7 @@ Change named retention, source or flow settings in one transaction. Requires set
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args87,
+    args: args100,
     tool: async (client, args, ctx) => {
       const [result] = await settingsUpdate(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -68977,9 +71616,9 @@ var init_getusageop = __esm(() => {
 
 // src/funcs/usageGet.ts
 function usageGet(client$, request, options) {
-  return new APIPromise($do88(client$, request, options));
+  return new APIPromise($do101(client$, request, options));
 }
-async function $do88(client$, request, options) {
+async function $do101(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => GetUsageRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -69066,12 +71705,12 @@ var init_usageGet = __esm(() => {
 });
 
 // src/mcp-server/tools/usageGet.ts
-var args88, tool$usageGet;
+var args101, tool$usageGet;
 var init_usageGet2 = __esm(() => {
   init_usageGet();
   init_getusageop();
   init_tools();
-  args88 = {
+  args101 = {
     request: GetUsageRequest$zodSchema
   };
   tool$usageGet = {
@@ -69086,7 +71725,7 @@ Read daily usage units for the environments you can access. These counts are unp
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args88,
+    args: args101,
     tool: async (client, args, ctx) => {
       const [result] = await usageGet(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -69116,9 +71755,9 @@ var init_webhookaggregaterequest = __esm(() => {
 
 // src/funcs/webhookEndpointsAggregate.ts
 function webhookEndpointsAggregate(client$, request, options) {
-  return new APIPromise($do89(client$, request, options));
+  return new APIPromise($do102(client$, request, options));
 }
-async function $do89(client$, request, options) {
+async function $do102(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => WebhookAggregateRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -69195,12 +71834,12 @@ var init_webhookEndpointsAggregate = __esm(() => {
 });
 
 // src/mcp-server/tools/webhookEndpointsAggregate.ts
-var args89, tool$webhookEndpointsAggregate;
+var args102, tool$webhookEndpointsAggregate;
 var init_webhookEndpointsAggregate2 = __esm(() => {
   init_webhookEndpointsAggregate();
   init_webhookaggregaterequest();
   init_tools();
-  args89 = {
+  args102 = {
     request: WebhookAggregateRequest$zodSchema
   };
   tool$webhookEndpointsAggregate = {
@@ -69215,7 +71854,7 @@ Count retained webhook delivery attempts within thirty days and report current r
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args89,
+    args: args102,
     tool: async (client, args, ctx) => {
       const [result] = await webhookEndpointsAggregate(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -69242,9 +71881,9 @@ var init_webhookendpointrequest = __esm(() => {
 
 // src/funcs/webhookEndpointsCreate.ts
 function webhookEndpointsCreate(client$, request, options) {
-  return new APIPromise($do90(client$, request, options));
+  return new APIPromise($do103(client$, request, options));
 }
-async function $do90(client$, request, options) {
+async function $do103(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => WebhookEndpointRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -69308,12 +71947,12 @@ var init_webhookEndpointsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/webhookEndpointsCreate.ts
-var args90, tool$webhookEndpointsCreate;
+var args103, tool$webhookEndpointsCreate;
 var init_webhookEndpointsCreate2 = __esm(() => {
   init_webhookEndpointsCreate();
   init_webhookendpointrequest();
   init_tools();
-  args90 = {
+  args103 = {
     request: WebhookEndpointRequest$zodSchema
   };
   tool$webhookEndpointsCreate = {
@@ -69328,7 +71967,7 @@ Registers a webhook endpoint and returns it with its first signing secret, shown
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args90,
+    args: args103,
     tool: async (client, args, ctx) => {
       const [result] = await webhookEndpointsCreate(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -69378,9 +72017,9 @@ var init_deletewebhookendpointop = __esm(() => {
 
 // src/funcs/webhookEndpointsDelete.ts
 function webhookEndpointsDelete(client$, request, options) {
-  return new APIPromise($do91(client$, request, options));
+  return new APIPromise($do104(client$, request, options));
 }
-async function $do91(client$, request, options) {
+async function $do104(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => DeleteWebhookEndpointRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -69462,12 +72101,12 @@ var init_webhookEndpointsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/webhookEndpointsDelete.ts
-var args91, tool$webhookEndpointsDelete;
+var args104, tool$webhookEndpointsDelete;
 var init_webhookEndpointsDelete2 = __esm(() => {
   init_webhookEndpointsDelete();
   init_deletewebhookendpointop();
   init_tools();
-  args91 = {
+  args104 = {
     request: DeleteWebhookEndpointRequest$zodSchema
   };
   tool$webhookEndpointsDelete = {
@@ -69482,7 +72121,7 @@ Deletes the endpoint and its signing keys. Deliveries still queued for it are dr
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args91,
+    args: args104,
     tool: async (client, args, ctx) => {
       const [result] = await webhookEndpointsDelete(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -69498,9 +72137,9 @@ Deletes the endpoint and its signing keys. Deliveries still queued for it are dr
 
 // src/funcs/webhookEndpointsList.ts
 function webhookEndpointsList(client$, options) {
-  return new APIPromise($do92(client$, options));
+  return new APIPromise($do105(client$, options));
 }
-async function $do92(client$, options) {
+async function $do105(client$, options) {
   const path$ = pathToFunc("/v1/webhooks")();
   const headers$ = new Headers(compactMap({
     Accept: options?.acceptHeaderOverride || "application/json;q=1, application/problem+json;q=0"
@@ -69694,9 +72333,9 @@ var init_listwebhookdeliveriesop = __esm(() => {
 
 // src/funcs/webhookEndpointsListDeliveries.ts
 function webhookEndpointsListDeliveries(client$, request, options) {
-  return new APIPromise($do93(client$, request, options));
+  return new APIPromise($do106(client$, request, options));
 }
-async function $do93(client$, request, options) {
+async function $do106(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => ListWebhookDeliveriesRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -69783,12 +72422,12 @@ var init_webhookEndpointsListDeliveries = __esm(() => {
 });
 
 // src/mcp-server/tools/webhookEndpointsListDeliveries.ts
-var args92, tool$webhookEndpointsListDeliveries;
+var args105, tool$webhookEndpointsListDeliveries;
 var init_webhookEndpointsListDeliveries2 = __esm(() => {
   init_webhookEndpointsListDeliveries();
   init_listwebhookdeliveriesop();
   init_tools();
-  args92 = {
+  args105 = {
     request: ListWebhookDeliveriesRequest$zodSchema
   };
   tool$webhookEndpointsListDeliveries = {
@@ -69803,7 +72442,7 @@ Every POST the endpoint received, newest first: the event id and type, which att
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args92,
+    args: args105,
     tool: async (client, args, ctx) => {
       const [result] = await webhookEndpointsListDeliveries(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -69877,9 +72516,9 @@ var init_replaywebhookdeliveryop = __esm(() => {
 
 // src/funcs/webhookEndpointsReplayDelivery.ts
 function webhookEndpointsReplayDelivery(client$, request, options) {
-  return new APIPromise($do94(client$, request, options));
+  return new APIPromise($do107(client$, request, options));
 }
-async function $do94(client$, request, options) {
+async function $do107(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => ReplayWebhookDeliveryRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -69953,12 +72592,12 @@ var init_webhookEndpointsReplayDelivery = __esm(() => {
 });
 
 // src/mcp-server/tools/webhookEndpointsReplayDelivery.ts
-var args93, tool$webhookEndpointsReplayDelivery;
+var args106, tool$webhookEndpointsReplayDelivery;
 var init_webhookEndpointsReplayDelivery2 = __esm(() => {
   init_webhookEndpointsReplayDelivery();
   init_replaywebhookdeliveryop();
   init_tools();
-  args93 = {
+  args106 = {
     request: ReplayWebhookDeliveryRequest$zodSchema
   };
   tool$webhookEndpointsReplayDelivery = {
@@ -69973,7 +72612,7 @@ Queues the event for the endpoint again: the same event id and body it received,
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args93,
+    args: args106,
     tool: async (client, args, ctx) => {
       const [result] = await webhookEndpointsReplayDelivery(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -70059,9 +72698,9 @@ var init_rotatewebhooksigningkeyop = __esm(() => {
 
 // src/funcs/webhookEndpointsRotateSigningKey.ts
 function webhookEndpointsRotateSigningKey(client$, request, options) {
-  return new APIPromise($do95(client$, request, options));
+  return new APIPromise($do108(client$, request, options));
 }
-async function $do95(client$, request, options) {
+async function $do108(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => RotateWebhookSigningKeyRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -70131,12 +72770,12 @@ var init_webhookEndpointsRotateSigningKey = __esm(() => {
 });
 
 // src/mcp-server/tools/webhookEndpointsRotateSigningKey.ts
-var args94, tool$webhookEndpointsRotateSigningKey;
+var args107, tool$webhookEndpointsRotateSigningKey;
 var init_webhookEndpointsRotateSigningKey2 = __esm(() => {
   init_webhookEndpointsRotateSigningKey();
   init_rotatewebhooksigningkeyop();
   init_tools();
-  args94 = {
+  args107 = {
     request: RotateWebhookSigningKeyRequest$zodSchema
   };
   tool$webhookEndpointsRotateSigningKey = {
@@ -70151,7 +72790,7 @@ Issues a new signing key for the endpoint and returns its secret once. Every del
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args94,
+    args: args107,
     tool: async (client, args, ctx) => {
       const [result] = await webhookEndpointsRotateSigningKey(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -70241,9 +72880,9 @@ var init_sendwebhooktesteventop = __esm(() => {
 
 // src/funcs/webhookEndpointsSendTestEvent.ts
 function webhookEndpointsSendTestEvent(client$, request, options) {
-  return new APIPromise($do96(client$, request, options));
+  return new APIPromise($do109(client$, request, options));
 }
-async function $do96(client$, request, options) {
+async function $do109(client$, request, options) {
   const parsed$ = safeParse2(request, (value$) => SendWebhookTestEventRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -70313,12 +72952,12 @@ var init_webhookEndpointsSendTestEvent = __esm(() => {
 });
 
 // src/mcp-server/tools/webhookEndpointsSendTestEvent.ts
-var args95, tool$webhookEndpointsSendTestEvent;
+var args108, tool$webhookEndpointsSendTestEvent;
 var init_webhookEndpointsSendTestEvent2 = __esm(() => {
   init_webhookEndpointsSendTestEvent();
   init_sendwebhooktesteventop();
   init_tools();
-  args95 = {
+  args108 = {
     request: SendWebhookTestEventRequest$zodSchema
   };
   tool$webhookEndpointsSendTestEvent = {
@@ -70333,7 +72972,7 @@ endpoint.verification sends a signed challenge now and answers whether the endpo
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args95,
+    args: args108,
     tool: async (client, args, ctx) => {
       const [result] = await webhookEndpointsSendTestEvent(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
       if (!result.ok) {
@@ -70351,7 +72990,7 @@ endpoint.verification sends a signed challenge now and answers whether the endpo
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "NoResponse",
-    version: "0.11.15"
+    version: "0.11.16"
   });
   const getClient = deps.getSDK || (() => new NoResponseCore({
     security: deps.security,
@@ -70466,6 +73105,19 @@ function createMCPServer(deps) {
   tool(tool$evaluationsCancel);
   tool(tool$evaluationsPublish);
   tool(tool$operationsSummarize);
+  tool(tool$eventsList);
+  tool(tool$eventsCreate);
+  tool(tool$eventsGet);
+  tool(tool$eventsUpdate);
+  tool(tool$eventsDelete);
+  tool(tool$eventsListAttendees);
+  tool(tool$eventsAddAttendees);
+  tool(tool$eventsGetAttendee);
+  tool(tool$eventsReviewAttendee);
+  tool(tool$eventsListScreenings);
+  tool(tool$eventsStartScreening);
+  tool(tool$eventsGetScreening);
+  tool(tool$eventsCancelScreening);
   if (deps.dynamic) {
     registerDynamicTools(deps.logger, server, getClient, toolMap, scopes);
   }
@@ -70518,6 +73170,19 @@ var init_server = __esm(() => {
   init_evaluationsGetResult2();
   init_evaluationsList2();
   init_evaluationsPublish2();
+  init_eventsAddAttendees2();
+  init_eventsCancelScreening2();
+  init_eventsCreate2();
+  init_eventsDelete2();
+  init_eventsGet2();
+  init_eventsGetAttendee2();
+  init_eventsGetScreening2();
+  init_eventsList2();
+  init_eventsListAttendees2();
+  init_eventsListScreenings2();
+  init_eventsReviewAttendee2();
+  init_eventsStartScreening2();
+  init_eventsUpdate2();
   init_exportsCancel2();
   init_exportsCreate2();
   init_exportsDownloadChunk2();
@@ -71156,6 +73821,84 @@ Publish an explicitly reviewed candidate with its exact manifest, input and resu
       description: `Summarize retained account outcomes, enforcement reports and reviews.
 
 Read one retained snapshot of account outcomes, enforcement reports and review states for the environment and a window of at most 31 days. Each section declares its own population, numerator, denominator and label coverage. Current outcome heads preserve explicit unknown labels. Enforcement rows are reports from your application and do not independently verify execution. Requires history or investigate together with management scope. A result exceeding 100000 population rows or the query budget is refused without truncation.`
+    },
+    {
+      name: "list_events",
+      description: `List an environment's events.
+
+List this environment's events, newest first. Pass next_before back as before for the next page. Requires the events scope.`
+    },
+    {
+      name: "create_event",
+      description: `Create an event to screen.
+
+Create an event to screen: its name, start, venue, host, the principals it protects and the sensitive topics posts are read against. An environment holds at most 1000 events.`
+    },
+    {
+      name: "get_event",
+      description: `Read an event.
+
+Read an event and how many attendees it holds.`
+    },
+    {
+      name: "update_event",
+      description: `Change an event.
+
+Change the fields you name. Send expected_version to apply the change only to that version.`
+    },
+    {
+      name: "delete_event",
+      description: `Erase an event.
+
+Erase an event with its attendees, their decisions and its screenings, and stop any screening still running.`
+    },
+    {
+      name: "list_attendees",
+      description: `List an event's attendees.
+
+Read an event's roster in upload order, with each attendee's match state, highest finding band and decision. Filter by band or decision; pass next_after back as after.`
+    },
+    {
+      name: "add_attendees",
+      description: `Add or update a batch of attendees.
+
+Add or update 1 to 500 attendees with an Idempotency-Key. A row with the same external_id, else email, else phone as an existing attendee updates it. Identities are stored encrypted.`
+    },
+    {
+      name: "get_attendee",
+      description: `Read an attendee's report.
+
+Read an attendee's report: matched profiles, findings with their evidence and every recorded decision.`
+    },
+    {
+      name: "review_attendee",
+      description: `Record a decision on an attendee.
+
+Record a cleared, watch or escalated decision with a note. The latest decision is the attendee's; the next screening refreshes everyone on watch or escalated.`
+    },
+    {
+      name: "list_screenings",
+      description: `List an event's screenings.
+
+List an event's screenings, newest first.`
+    },
+    {
+      name: "start_screening",
+      description: `Start a screening.
+
+Start a screening of new attendees and everyone on watch or escalated, with an Idempotency-Key. It finishes completed, partial or failed minutes to hours later; poll it. The test environment screens with stand-ins that find no accounts.`
+    },
+    {
+      name: "get_screening",
+      description: `Read a screening.
+
+Read a screening's status and progress.`
+    },
+    {
+      name: "cancel_screening",
+      description: `Cancel a screening.
+
+Stop a queued or running screening. Attendees already screened keep their results.`
     },
     {
       name: "wait_for_assessment",
@@ -79656,7 +82399,7 @@ var routes = buildRouteMap({
 var app = buildApplication(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.11.15"
+    currentVersion: "0.11.16"
   }
 });
 run(app, process3.argv.slice(2), buildContext(process3));
@@ -79664,5 +82407,5 @@ export {
   app
 };
 
-//# debugId=EC0EB10BE44F5A5E64756E2164756E21
+//# debugId=7F2ED000CF8D80D564756E2164756E21
 //# sourceMappingURL=mcp-server.js.map