@noresponse/mcp 0.13.7 → 0.13.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/bin/mcp-server.js CHANGED
@@ -48136,9 +48136,9 @@ var init_config = __esm(() => {
48136
48136
  SDK_METADATA = {
48137
48137
  language: "typescript",
48138
48138
  openapiDocVersion: "1",
48139
- sdkVersion: "0.13.7",
48139
+ sdkVersion: "0.13.8",
48140
48140
  genVersion: "internal",
48141
- userAgent: "noresponse-sdk/mcp-typescript 0.13.7 internal 1 @noresponse/mcp"
48141
+ userAgent: "noresponse-sdk/mcp-typescript 0.13.8 internal 1 @noresponse/mcp"
48142
48142
  };
48143
48143
  });
48144
48144
 
@@ -62534,8 +62534,9 @@ var RecordMatch$zodSchema;
62534
62534
  var init_recordmatch = __esm(() => {
62535
62535
  init_zod();
62536
62536
  RecordMatch$zodSchema = object({
62537
- by: string2().describe("The kind of searched value: email, phone, username, ip, name, or handle for a profile read of a handle."),
62538
- field: string2().optional().describe("The field the searched value hit, when the record holds it.")
62537
+ by: string2().describe("The kind of searched value: email, phone, username, ip, name, password, hash, or handle for a profile read of a handle."),
62538
+ field: string2().optional().describe("The field the searched value hit, when the record holds it."),
62539
+ search: string2().optional().describe("The search a person started on a value of another record that found this one, among the person report's searches, which names the value and the record and field it came from. A record found only by such searches is a lead, whatever kind of value found it. Absent for a match of the lookups.")
62539
62540
  }).describe("One searched value that found the record.");
62540
62541
  });
62541
62542
 
@@ -62592,6 +62593,7 @@ var init_recordremaining = __esm(() => {
62592
62593
  RecordRemaining$zodSchema = object({
62593
62594
  by: string2().describe("The kind of searched value whose search matched the rows, as a record's matched names it."),
62594
62595
  rows: int().describe("How many rows of the source that search matched beyond the records the lookup carries."),
62596
+ search: string2().optional().describe("The search a person started that matched the rows. Searching the same field again with this source's table fetches them."),
62595
62597
  source: RecordSource$zodSchema.describe("Where a record came from.")
62596
62598
  }).describe("Rows one search matched in one source that the lookup's records leave out, so no answer is cut short in silence.");
62597
62599
  });
@@ -62640,8 +62642,8 @@ var init_screeninglookup = __esm(() => {
62640
62642
  checks: array(ScreeningLookupCheck$zodSchema).describe("Each lane each identifier was looked up in, identifiers in the order email, phone, username and lanes in the order accounts, phone, breach, domain. Every lane the person's identifiers are looked up in is listed: one that no source answered, or that no source could be asked in, is not_covered. Empty when the person has no email, phone or handle to look up."),
62641
62643
  details: RiskDetails$zodSchema.optional().describe("Merged observations behind the summary, served only to a caller who may read evidence: no provider, source, origin, raw breach record or score."),
62642
62644
  looked_at: string2().describe("When the lookups ran."),
62643
- records: array(RecordT$zodSchema).optional().describe("What each source answered, whole, each answer once: every field of each account a connector found, and every column of each breach row the person's email or usernames matched, under the source's own names. Anyone who may read the person reads them: no extra permission applies, breach passwords and hashes included."),
62644
- remaining: array(RecordRemaining$zodSchema).optional().describe("For each search and source whose matched rows records leave out, how many: a breach search returns at most 20 rows of a table and 100 in all, from its first 64 tables by name. Absent when records hold every matched row."),
62645
+ records: array(RecordT$zodSchema).optional().describe("What each source answered, whole, each answer once: every field of each account a connector found, and every column of each breach row the person's email or usernames matched, under the source's own names, and what each search a person started found, each match naming its search. Anyone who may read the person reads them: no extra permission applies, breach passwords and hashes included."),
62646
+ remaining: array(RecordRemaining$zodSchema).optional().describe("For each search and source whose matched rows records leave out, how many: a breach search returns at most 20 rows of a table and 100 in all, from its first 64 tables by name. A search a person starts on one table of its source fetches the rest of that table, up to 100 rows. Absent when records hold every matched row."),
62645
62647
  summary: RiskSummary$zodSchema.optional().describe("A few typed facts per identifier: an assessment's risk.summary, and a screened person's lookup summary. Every fact is optional: absent means the evidence did not answer and makes no claim, while false or 0 is a definite answer.")
62646
62648
  }).describe("What the signup check's lookups found for a person: account presence for the email, phone and usernames (the person's handles), the phone lookup, the email domain's registration and the breach search. Context and coverage for the reviewer, not a finding: nothing here sets a band or a match state.");
62647
62649
  });
@@ -62800,6 +62802,75 @@ var init_screeningprofile = __esm(() => {
62800
62802
  }).describe("An account the screening matched to the person, how it was matched, and how much of it was read.");
62801
62803
  });
62802
62804
 
62805
+ // src/models/errorcode.ts
62806
+ var ErrorCode$zodSchema;
62807
+ var init_errorcode = __esm(() => {
62808
+ init_zod();
62809
+ ErrorCode$zodSchema = _enum([
62810
+ "not_answered",
62811
+ "no_source",
62812
+ "worker_attempts_exhausted"
62813
+ ]).describe("Why a failed search found nothing: its sources did not answer, none could be asked, or it could not run before its attempts were spent.");
62814
+ });
62815
+
62816
+ // src/models/searchkind.ts
62817
+ var SearchKind$zodSchema;
62818
+ var init_searchkind = __esm(() => {
62819
+ init_zod();
62820
+ SearchKind$zodSchema = _enum([
62821
+ "email",
62822
+ "phone",
62823
+ "username",
62824
+ "person_name",
62825
+ "password",
62826
+ "hash",
62827
+ "ip"
62828
+ ]).describe("The kind of the value searched.");
62829
+ });
62830
+
62831
+ // src/models/searchstatus.ts
62832
+ var SearchStatus$zodSchema;
62833
+ var init_searchstatus = __esm(() => {
62834
+ init_zod();
62835
+ SearchStatus$zodSchema = _enum([
62836
+ "counting",
62837
+ "counted",
62838
+ "queued",
62839
+ "running",
62840
+ "completed",
62841
+ "partial",
62842
+ "failed"
62843
+ ]).describe("A password or hash search is counting, then counted: rows says how many breach rows hold the value, and nothing runs until a person runs it (POST .../searches/{search_id}/run). Any other search is queued, then running. completed: every source it asked answered. partial: some did not. failed: none answered or none could be asked, which says nothing about whether the value is held anywhere.");
62844
+ });
62845
+
62846
+ // src/models/search.ts
62847
+ var Search$zodSchema;
62848
+ var init_search = __esm(() => {
62849
+ init_zod();
62850
+ init_errorcode();
62851
+ init_searchkind();
62852
+ init_searchstatus();
62853
+ Search$zodSchema = object({
62854
+ answered: int().describe("How many of them gave a definite answer, found or not found."),
62855
+ created_at: string2(),
62856
+ error_code: ErrorCode$zodSchema.optional().describe("Why a failed search found nothing: its sources did not answer, none could be asked, or it could not run before its attempts were spent."),
62857
+ estimated_spend: int().describe("What the search may spend, in US cents, held against the environment's daily screening cap while it runs."),
62858
+ field: string2().describe("The field of that record that holds the value."),
62859
+ finished_at: string2().optional(),
62860
+ found: int().describe("How many records the search found. They are among the person report's lookup records, each match naming this search."),
62861
+ kind: SearchKind$zodSchema.describe("The kind of the value searched."),
62862
+ record_id: string2().describe("The record whose value led to the search."),
62863
+ requested_by: string2().describe("Who started the search."),
62864
+ rows: int().optional().describe("How many breach rows hold the password or hash, counted before the search runs."),
62865
+ search_id: string2(),
62866
+ sources: int().describe("How many sources the search asked: the breach search and the account and phone lookups that take the value's kind."),
62867
+ spent: int().describe("What the search spent, in US cents, metered as screening work."),
62868
+ status: SearchStatus$zodSchema.describe("A password or hash search is counting, then counted: rows says how many breach rows hold the value, and nothing runs until a person runs it (POST .../searches/{search_id}/run). Any other search is queued, then running. completed: every source it asked answered. partial: some did not. failed: none answered or none could be asked, which says nothing about whether the value is held anywhere."),
62869
+ table: string2().optional().describe("The one breach table searched, when the search was of one table."),
62870
+ value: string2().describe("The value searched: the field's cleaned value, else as the source wrote it.")
62871
+ }).describe("One search a person started on a value of one of a person's records. Nothing searches again by itself.");
62872
+ });
62873
+
62803
62874
  // src/models/personreport.ts
62804
62875
  var PersonReport$zodSchema;
62805
62876
  var init_personreport = __esm(() => {
@@ -62812,6 +62883,7 @@ var init_personreport = __esm(() => {
62812
62883
  init_screeningmedia();
62813
62884
  init_screeningpost();
62814
62885
  init_screeningprofile();
62886
+ init_search();
62815
62887
  PersonReport$zodSchema = object({
62816
62888
  findings: array(ScreeningFinding$zodSchema).describe("What the latest screening flagged, most severe first, each citing its evidence."),
62817
62889
  lookup: ScreeningLookup$zodSchema.optional().describe("What the signup check's lookups found for a person: account presence for the email, phone and usernames (the person's handles), the phone lookup, the email domain's registration and the breach search. Context and coverage for the reviewer, not a finding: nothing here sets a band or a match state."),
@@ -62820,7 +62892,8 @@ var init_personreport = __esm(() => {
62820
62892
  person: Person$zodSchema.describe("A person and where their screening and review stand."),
62821
62893
  posts: array(ScreeningPost$zodSchema).describe("The posts the findings cite."),
62822
62894
  profiles: array(ScreeningProfile$zodSchema).describe("The accounts the latest screening matched, with how each was matched."),
62823
- reviews: array(PersonReview$zodSchema).describe("Every recorded decision, oldest first.")
62895
+ reviews: array(PersonReview$zodSchema).describe("Every recorded decision, oldest first."),
62896
+ searches: array(Search$zodSchema).optional().describe("The searches people started on this person's values, newest first: each names the value, and the record and field it came from. Absent when nobody searched.")
62824
62897
  }).describe("Everything known about one person, and where else in the environment they appear.");
62825
62898
  });
62826
62899
 
@@ -64145,6 +64218,187 @@ Record a cleared, watch or escalated decision with a note. The latest decision i
64145
64218
  };
64146
64219
  });
64147
64220
 
64221
+ // src/models/runsearchop.ts
64222
+ var RunSearchRequest$zodSchema, RunSearchResponseResult$zodSchema, RunSearchResponse$zodSchema;
64223
+ var init_runsearchop = __esm(() => {
64224
+ init_zod();
64225
+ init_authenticationerror();
64226
+ init_badrequesterror();
64227
+ init_conflicterror();
64228
+ init_keyenvironment();
64229
+ init_notfounderror();
64230
+ init_permissiondeniederror();
64231
+ init_ratelimiterror();
64232
+ init_screeningcancelrequest();
64233
+ init_search();
64234
+ RunSearchRequest$zodSchema = object({
64235
+ body: ScreeningCancelRequest$zodSchema,
64236
+ 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."),
64237
+ group_id: string2(),
64238
+ person_id: string2(),
64239
+ search_id: string2(),
64240
+ 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.")
64241
+ });
64242
+ RunSearchResponseResult$zodSchema = union([
64243
+ Search$zodSchema,
64244
+ BadRequestError$zodSchema,
64245
+ AuthenticationError$zodSchema,
64246
+ PermissionDeniedError$zodSchema,
64247
+ NotFoundError$zodSchema,
64248
+ ConflictError$zodSchema,
64249
+ RateLimitError$zodSchema
64250
+ ]);
64251
+ RunSearchResponse$zodSchema = object({
64252
+ Headers: record(string2(), array(string2())).default({}),
64253
+ Result: union([
64254
+ Search$zodSchema,
64255
+ BadRequestError$zodSchema,
64256
+ AuthenticationError$zodSchema,
64257
+ PermissionDeniedError$zodSchema,
64258
+ NotFoundError$zodSchema,
64259
+ ConflictError$zodSchema,
64260
+ RateLimitError$zodSchema
64261
+ ])
64262
+ });
64263
+ });
64264
+
64265
+ // src/funcs/groupsRunSearch.ts
64266
+ function groupsRunSearch(client$, request, options) {
64267
+ return new APIPromise($do58(client$, request, options));
64268
+ }
64269
+ async function $do58(client$, request, options) {
64270
+ const parsed$ = safeParse2(request, (value$) => RunSearchRequest$zodSchema.parse(value$), "Input validation failed");
64271
+ if (!parsed$.ok) {
64272
+ return [parsed$, { status: "invalid" }];
64273
+ }
64274
+ const payload$ = parsed$.value;
64275
+ const body$ = encodeJSON("body", payload$.body, { explode: true });
64276
+ const pathParams$ = {
64277
+ environment: encodeSimple("environment", payload$.environment, {
64278
+ explode: false,
64279
+ charEncoding: "percent"
64280
+ }),
64281
+ group_id: encodeSimple("group_id", payload$.group_id, {
64282
+ explode: false,
64283
+ charEncoding: "percent"
64284
+ }),
64285
+ person_id: encodeSimple("person_id", payload$.person_id, {
64286
+ explode: false,
64287
+ charEncoding: "percent"
64288
+ }),
64289
+ search_id: encodeSimple("search_id", payload$.search_id, {
64290
+ explode: false,
64291
+ charEncoding: "percent"
64292
+ }),
64293
+ workspace_id: encodeSimple("workspace_id", payload$.workspace_id, {
64294
+ explode: false,
64295
+ charEncoding: "percent"
64296
+ })
64297
+ };
64298
+ const path$ = pathToFunc("/v1/workspaces/{workspace_id}/groups/{environment}/{group_id}/people/{person_id}/searches/{search_id}/run")(pathParams$);
64299
+ const headers$ = new Headers(compactMap({
64300
+ "Content-Type": "application/json",
64301
+ Accept: options?.acceptHeaderOverride || "application/json;q=1, application/problem+json;q=0"
64302
+ }));
64303
+ const securityInput = await extractSecurity(client$._options.security);
64304
+ const requestSecurity = resolveGlobalSecurity(securityInput);
64305
+ const context = {
64306
+ options: client$._options,
64307
+ baseURL: options?.serverURL ?? client$._baseURL ?? "",
64308
+ operationID: "runSearch",
64309
+ oAuth2Scopes: null,
64310
+ resolvedSecurity: requestSecurity,
64311
+ securitySource: client$._options.security,
64312
+ retryConfig: options?.retries || client$._options.retryConfig || {
64313
+ strategy: "backoff",
64314
+ backoff: {
64315
+ initialInterval: 500,
64316
+ maxInterval: 8000,
64317
+ exponent: 2,
64318
+ maxElapsedTime: 30000
64319
+ },
64320
+ retryConnectionErrors: true
64321
+ },
64322
+ retryCodes: options?.retryCodes || [
64323
+ "408",
64324
+ "429",
64325
+ "5XX"
64326
+ ]
64327
+ };
64328
+ const requestRes = client$._createRequest(context, {
64329
+ security: requestSecurity,
64330
+ method: "POST",
64331
+ baseURL: options?.serverURL,
64332
+ path: path$,
64333
+ headers: headers$,
64334
+ body: body$,
64335
+ userAgent: client$._options.userAgent,
64336
+ timeoutMs: options?.timeoutMs || client$._options.timeoutMs || -1
64337
+ }, options);
64338
+ if (!requestRes.ok) {
64339
+ return [requestRes, { status: "invalid" }];
64340
+ }
64341
+ const req$ = requestRes.value;
64342
+ const doResult = await client$._do(req$, {
64343
+ context,
64344
+ errorCodes: [],
64345
+ retryConfig: context.retryConfig,
64346
+ retryCodes: context.retryCodes
64347
+ });
64348
+ if (!doResult.ok) {
64349
+ return [doResult, { status: "request-error", request: req$ }];
64350
+ }
64351
+ return [doResult, {
64352
+ status: "complete",
64353
+ request: req$,
64354
+ response: doResult.value
64355
+ }];
64356
+ }
64357
+ var init_groupsRunSearch = __esm(() => {
64358
+ init_encodings();
64359
+ init_primitives();
64360
+ init_schemas3();
64361
+ init_security();
64362
+ init_url();
64363
+ init_runsearchop();
64364
+ init_async();
64365
+ });
64366
+
64367
+ // src/mcp-server/tools/groupsRunSearch.ts
64368
+ var args59, tool$groupsRunSearch;
64369
+ var init_groupsRunSearch2 = __esm(() => {
64370
+ init_groupsRunSearch();
64371
+ init_runsearchop();
64372
+ init_tools();
64373
+ args59 = {
64374
+ request: RunSearchRequest$zodSchema
64375
+ };
64376
+ tool$groupsRunSearch = {
64377
+ name: "run_search",
64378
+ description: `Run a counted password or hash search.
64379
+
64380
+ Run a counted password or hash search once you have seen how many breach rows hold the value.`,
64381
+ annotations: {
64382
+ title: "Run a counted password or hash search",
64383
+ destructiveHint: false,
64384
+ idempotentHint: true,
64385
+ openWorldHint: false,
64386
+ readOnlyHint: false
64387
+ },
64388
+ args: args59,
64389
+ tool: async (client, args, ctx) => {
64390
+ const [result] = await groupsRunSearch(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
64391
+ if (!result.ok) {
64392
+ return {
64393
+ content: [{ type: "text", text: result.error.message }],
64394
+ isError: true
64395
+ };
64396
+ }
64397
+ return formatResult(result.value);
64398
+ }
64399
+ };
64400
+ });
64401
+
64148
64402
  // src/models/screeningrequest.ts
64149
64403
  var ScreeningRequest$zodSchema;
64150
64404
  var init_screeningrequest = __esm(() => {
@@ -64202,9 +64456,9 @@ var init_startscreeningop = __esm(() => {
64202
64456
 
64203
64457
  // src/funcs/groupsStartScreening.ts
64204
64458
  function groupsStartScreening(client$, request, options) {
64205
- return new APIPromise($do58(client$, request, options));
64459
+ return new APIPromise($do59(client$, request, options));
64206
64460
  }
64207
- async function $do58(client$, request, options) {
64461
+ async function $do59(client$, request, options) {
64208
64462
  const parsed$ = safeParse2(request, (value$) => StartScreeningRequest$zodSchema.parse(value$), "Input validation failed");
64209
64463
  if (!parsed$.ok) {
64210
64464
  return [parsed$, { status: "invalid" }];
@@ -64296,12 +64550,12 @@ var init_groupsStartScreening = __esm(() => {
64296
64550
  });
64297
64551
 
64298
64552
  // src/mcp-server/tools/groupsStartScreening.ts
64299
- var args59, tool$groupsStartScreening;
64553
+ var args60, tool$groupsStartScreening;
64300
64554
  var init_groupsStartScreening2 = __esm(() => {
64301
64555
  init_groupsStartScreening();
64302
64556
  init_startscreeningop();
64303
64557
  init_tools();
64304
- args59 = {
64558
+ args60 = {
64305
64559
  request: StartScreeningRequest$zodSchema
64306
64560
  };
64307
64561
  tool$groupsStartScreening = {
@@ -64316,7 +64570,7 @@ Start a screening of new people and everyone on watch or escalated, with an Idem
64316
64570
  openWorldHint: false,
64317
64571
  readOnlyHint: false
64318
64572
  },
64319
- args: args59,
64573
+ args: args60,
64320
64574
  tool: async (client, args, ctx) => {
64321
64575
  const [result] = await groupsStartScreening(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
64322
64576
  if (!result.ok) {
@@ -64330,6 +64584,193 @@ Start a screening of new people and everyone on watch or escalated, with an Idem
64330
64584
  };
64331
64585
  });
64332
64586
 
64587
+ // src/models/searchrequest.ts
64588
+ var SearchRequest$zodSchema;
64589
+ var init_searchrequest = __esm(() => {
64590
+ init_zod();
64591
+ SearchRequest$zodSchema = object({
64592
+ field: string2().describe("The name of the record's field whose value to search. Its kind must be email, phone, username, person_name, password, hash or ip."),
64593
+ record_id: string2().describe("One of the person's records: a lookup's, a profile's or one an earlier search found."),
64594
+ table: string2().optional().describe("Search only this breach table, as a remaining entry names it, to fetch the rows an earlier search left out. Not for a phone.")
64595
+ }).describe("The value to search again, named by the record and field that hold it rather than sent again.");
64596
+ });
64597
+
64598
+ // src/models/startsearchop.ts
64599
+ var StartSearchRequest$zodSchema, StartSearchResponseResult$zodSchema, StartSearchResponse$zodSchema;
64600
+ var init_startsearchop = __esm(() => {
64601
+ init_zod();
64602
+ init_authenticationerror();
64603
+ init_badrequesterror();
64604
+ init_conflicterror();
64605
+ init_keyenvironment();
64606
+ init_notfounderror();
64607
+ init_permissiondeniederror();
64608
+ init_ratelimiterror();
64609
+ init_search();
64610
+ init_searchrequest();
64611
+ StartSearchRequest$zodSchema = object({
64612
+ body: SearchRequest$zodSchema,
64613
+ 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."),
64614
+ group_id: string2(),
64615
+ person_id: string2(),
64616
+ 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.")
64617
+ });
64618
+ StartSearchResponseResult$zodSchema = union([
64619
+ Search$zodSchema,
64620
+ BadRequestError$zodSchema,
64621
+ AuthenticationError$zodSchema,
64622
+ PermissionDeniedError$zodSchema,
64623
+ NotFoundError$zodSchema,
64624
+ ConflictError$zodSchema,
64625
+ RateLimitError$zodSchema
64626
+ ]);
64627
+ StartSearchResponse$zodSchema = object({
64628
+ Headers: record(string2(), array(string2())).default({}),
64629
+ Result: union([
64630
+ Search$zodSchema,
64631
+ BadRequestError$zodSchema,
64632
+ AuthenticationError$zodSchema,
64633
+ PermissionDeniedError$zodSchema,
64634
+ NotFoundError$zodSchema,
64635
+ ConflictError$zodSchema,
64636
+ RateLimitError$zodSchema
64637
+ ])
64638
+ });
64639
+ });
64640
+
64641
+ // src/funcs/groupsStartSearch.ts
64642
+ function groupsStartSearch(client$, request, options) {
64643
+ return new APIPromise($do60(client$, request, options));
64644
+ }
64645
+ async function $do60(client$, request, options) {
64646
+ const parsed$ = safeParse2(request, (value$) => StartSearchRequest$zodSchema.parse(value$), "Input validation failed");
64647
+ if (!parsed$.ok) {
64648
+ return [parsed$, { status: "invalid" }];
64649
+ }
64650
+ const payload$ = parsed$.value;
64651
+ const body$ = encodeJSON("body", payload$.body, { explode: true });
64652
+ const pathParams$ = {
64653
+ environment: encodeSimple("environment", payload$.environment, {
64654
+ explode: false,
64655
+ charEncoding: "percent"
64656
+ }),
64657
+ group_id: encodeSimple("group_id", payload$.group_id, {
64658
+ explode: false,
64659
+ charEncoding: "percent"
64660
+ }),
64661
+ person_id: encodeSimple("person_id", payload$.person_id, {
64662
+ explode: false,
64663
+ charEncoding: "percent"
64664
+ }),
64665
+ workspace_id: encodeSimple("workspace_id", payload$.workspace_id, {
64666
+ explode: false,
64667
+ charEncoding: "percent"
64668
+ })
64669
+ };
64670
+ const path$ = pathToFunc("/v1/workspaces/{workspace_id}/groups/{environment}/{group_id}/people/{person_id}/searches")(pathParams$);
64671
+ const headers$ = new Headers(compactMap({
64672
+ "Content-Type": "application/json",
64673
+ Accept: options?.acceptHeaderOverride || "application/json;q=1, application/problem+json;q=0"
64674
+ }));
64675
+ const securityInput = await extractSecurity(client$._options.security);
64676
+ const requestSecurity = resolveGlobalSecurity(securityInput);
64677
+ const context = {
64678
+ options: client$._options,
64679
+ baseURL: options?.serverURL ?? client$._baseURL ?? "",
64680
+ operationID: "startSearch",
64681
+ oAuth2Scopes: null,
64682
+ resolvedSecurity: requestSecurity,
64683
+ securitySource: client$._options.security,
64684
+ retryConfig: options?.retries || client$._options.retryConfig || {
64685
+ strategy: "backoff",
64686
+ backoff: {
64687
+ initialInterval: 500,
64688
+ maxInterval: 8000,
64689
+ exponent: 2,
64690
+ maxElapsedTime: 30000
64691
+ },
64692
+ retryConnectionErrors: true
64693
+ },
64694
+ retryCodes: options?.retryCodes || [
64695
+ "408",
64696
+ "429",
64697
+ "5XX"
64698
+ ]
64699
+ };
64700
+ const requestRes = client$._createRequest(context, {
64701
+ security: requestSecurity,
64702
+ method: "POST",
64703
+ baseURL: options?.serverURL,
64704
+ path: path$,
64705
+ headers: headers$,
64706
+ body: body$,
64707
+ userAgent: client$._options.userAgent,
64708
+ timeoutMs: options?.timeoutMs || client$._options.timeoutMs || -1
64709
+ }, options);
64710
+ if (!requestRes.ok) {
64711
+ return [requestRes, { status: "invalid" }];
64712
+ }
64713
+ const req$ = requestRes.value;
64714
+ const doResult = await client$._do(req$, {
64715
+ context,
64716
+ errorCodes: [],
64717
+ retryConfig: context.retryConfig,
64718
+ retryCodes: context.retryCodes
64719
+ });
64720
+ if (!doResult.ok) {
64721
+ return [doResult, { status: "request-error", request: req$ }];
64722
+ }
64723
+ return [doResult, {
64724
+ status: "complete",
64725
+ request: req$,
64726
+ response: doResult.value
64727
+ }];
64728
+ }
64729
+ var init_groupsStartSearch = __esm(() => {
64730
+ init_encodings();
64731
+ init_primitives();
64732
+ init_schemas3();
64733
+ init_security();
64734
+ init_url();
64735
+ init_startsearchop();
64736
+ init_async();
64737
+ });
64738
+
64739
+ // src/mcp-server/tools/groupsStartSearch.ts
64740
+ var args61, tool$groupsStartSearch;
64741
+ var init_groupsStartSearch2 = __esm(() => {
64742
+ init_groupsStartSearch();
64743
+ init_startsearchop();
64744
+ init_tools();
64745
+ args61 = {
64746
+ request: StartSearchRequest$zodSchema
64747
+ };
64748
+ tool$groupsStartSearch = {
64749
+ name: "start_search",
64750
+ description: `Search again on a value of one of a person's records.
64751
+
64752
+ Search again on the value of one field of one of a person's records, named by the record and field. Nothing searches again by itself. A password or hash search counts its breach rows first and runs only when you run it; read the person to see each search and what it found.`,
64753
+ annotations: {
64754
+ title: "Search again on a value of one of a person's records",
64755
+ destructiveHint: false,
64756
+ idempotentHint: false,
64757
+ openWorldHint: false,
64758
+ readOnlyHint: false
64759
+ },
64760
+ args: args61,
64761
+ tool: async (client, args, ctx) => {
64762
+ const [result] = await groupsStartSearch(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
64763
+ if (!result.ok) {
64764
+ return {
64765
+ content: [{ type: "text", text: result.error.message }],
64766
+ isError: true
64767
+ };
64768
+ }
64769
+ return formatResult(result.value);
64770
+ }
64771
+ };
64772
+ });
64773
+
64333
64774
  // src/models/groupupdate.ts
64334
64775
  var GroupUpdate$zodSchema;
64335
64776
  var init_groupupdate = __esm(() => {
@@ -64391,9 +64832,9 @@ var init_updategroupop = __esm(() => {
64391
64832
 
64392
64833
  // src/funcs/groupsUpdate.ts
64393
64834
  function groupsUpdate(client$, request, options) {
64394
- return new APIPromise($do59(client$, request, options));
64835
+ return new APIPromise($do61(client$, request, options));
64395
64836
  }
64396
- async function $do59(client$, request, options) {
64837
+ async function $do61(client$, request, options) {
64397
64838
  const parsed$ = safeParse2(request, (value$) => UpdateGroupRequest$zodSchema.parse(value$), "Input validation failed");
64398
64839
  if (!parsed$.ok) {
64399
64840
  return [parsed$, { status: "invalid" }];
@@ -64484,12 +64925,12 @@ var init_groupsUpdate = __esm(() => {
64484
64925
  });
64485
64926
 
64486
64927
  // src/mcp-server/tools/groupsUpdate.ts
64487
- var args60, tool$groupsUpdate;
64928
+ var args62, tool$groupsUpdate;
64488
64929
  var init_groupsUpdate2 = __esm(() => {
64489
64930
  init_groupsUpdate();
64490
64931
  init_updategroupop();
64491
64932
  init_tools();
64492
- args60 = {
64933
+ args62 = {
64493
64934
  request: UpdateGroupRequest$zodSchema
64494
64935
  };
64495
64936
  tool$groupsUpdate = {
@@ -64504,7 +64945,7 @@ Change the fields you name. Send expected_version to apply the change only to th
64504
64945
  openWorldHint: false,
64505
64946
  readOnlyHint: false
64506
64947
  },
64507
- args: args60,
64948
+ args: args62,
64508
64949
  tool: async (client, args, ctx) => {
64509
64950
  const [result] = await groupsUpdate(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
64510
64951
  if (!result.ok) {
@@ -64554,9 +64995,9 @@ var init_integrationrequest = __esm(() => {
64554
64995
 
64555
64996
  // src/funcs/integrationsCreate.ts
64556
64997
  function integrationsCreate(client$, request, options) {
64557
- return new APIPromise($do60(client$, request, options));
64998
+ return new APIPromise($do62(client$, request, options));
64558
64999
  }
64559
- async function $do60(client$, request, options) {
65000
+ async function $do62(client$, request, options) {
64560
65001
  const parsed$ = safeParse2(request, (value$) => IntegrationRequest$zodSchema.parse(value$), "Input validation failed");
64561
65002
  if (!parsed$.ok) {
64562
65003
  return [parsed$, { status: "invalid" }];
@@ -64620,12 +65061,12 @@ var init_integrationsCreate = __esm(() => {
64620
65061
  });
64621
65062
 
64622
65063
  // src/mcp-server/tools/integrationsCreate.ts
64623
- var args61, tool$integrationsCreate;
65064
+ var args63, tool$integrationsCreate;
64624
65065
  var init_integrationsCreate2 = __esm(() => {
64625
65066
  init_integrationsCreate();
64626
65067
  init_integrationrequest();
64627
65068
  init_tools();
64628
- args61 = {
65069
+ args63 = {
64629
65070
  request: IntegrationRequest$zodSchema
64630
65071
  };
64631
65072
  tool$integrationsCreate = {
@@ -64640,7 +65081,7 @@ Registers a WorkOS, Auth0 or Supabase integration and returns its hosted endpoin
64640
65081
  openWorldHint: false,
64641
65082
  readOnlyHint: false
64642
65083
  },
64643
- args: args61,
65084
+ args: args63,
64644
65085
  tool: async (client, args, ctx) => {
64645
65086
  const [result] = await integrationsCreate(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
64646
65087
  if (!result.ok) {
@@ -64690,9 +65131,9 @@ var init_deleteintegrationop = __esm(() => {
64690
65131
 
64691
65132
  // src/funcs/integrationsDelete.ts
64692
65133
  function integrationsDelete(client$, request, options) {
64693
- return new APIPromise($do61(client$, request, options));
65134
+ return new APIPromise($do63(client$, request, options));
64694
65135
  }
64695
- async function $do61(client$, request, options) {
65136
+ async function $do63(client$, request, options) {
64696
65137
  const parsed$ = safeParse2(request, (value$) => DeleteIntegrationRequest$zodSchema.parse(value$), "Input validation failed");
64697
65138
  if (!parsed$.ok) {
64698
65139
  return [parsed$, { status: "invalid" }];
@@ -64774,12 +65215,12 @@ var init_integrationsDelete = __esm(() => {
64774
65215
  });
64775
65216
 
64776
65217
  // src/mcp-server/tools/integrationsDelete.ts
64777
- var args62, tool$integrationsDelete;
65218
+ var args64, tool$integrationsDelete;
64778
65219
  var init_integrationsDelete2 = __esm(() => {
64779
65220
  init_integrationsDelete();
64780
65221
  init_deleteintegrationop();
64781
65222
  init_tools();
64782
- args62 = {
65223
+ args64 = {
64783
65224
  request: DeleteIntegrationRequest$zodSchema
64784
65225
  };
64785
65226
  tool$integrationsDelete = {
@@ -64794,7 +65235,7 @@ Removes the integration and its secrets; its endpoint answers 404 from then on,
64794
65235
  openWorldHint: false,
64795
65236
  readOnlyHint: false
64796
65237
  },
64797
- args: args62,
65238
+ args: args64,
64798
65239
  tool: async (client, args, ctx) => {
64799
65240
  const [result] = await integrationsDelete(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
64800
65241
  if (!result.ok) {
@@ -64810,9 +65251,9 @@ Removes the integration and its secrets; its endpoint answers 404 from then on,
64810
65251
 
64811
65252
  // src/funcs/integrationsList.ts
64812
65253
  function integrationsList(client$, options) {
64813
- return new APIPromise($do62(client$, options));
65254
+ return new APIPromise($do64(client$, options));
64814
65255
  }
64815
- async function $do62(client$, options) {
65256
+ async function $do64(client$, options) {
64816
65257
  const path$ = pathToFunc("/v1/integrations")();
64817
65258
  const headers$ = new Headers(compactMap({
64818
65259
  Accept: options?.acceptHeaderOverride || "application/json;q=1, application/problem+json;q=0"
@@ -64975,9 +65416,9 @@ var init_rotateintegrationsecretop = __esm(() => {
64975
65416
 
64976
65417
  // src/funcs/integrationsRotate.ts
64977
65418
  function integrationsRotate(client$, request, options) {
64978
- return new APIPromise($do63(client$, request, options));
65419
+ return new APIPromise($do65(client$, request, options));
64979
65420
  }
64980
- async function $do63(client$, request, options) {
65421
+ async function $do65(client$, request, options) {
64981
65422
  const parsed$ = safeParse2(request, (value$) => RotateIntegrationSecretRequest$zodSchema.parse(value$), "Input validation failed");
64982
65423
  if (!parsed$.ok) {
64983
65424
  return [parsed$, { status: "invalid" }];
@@ -65047,12 +65488,12 @@ var init_integrationsRotate = __esm(() => {
65047
65488
  });
65048
65489
 
65049
65490
  // src/mcp-server/tools/integrationsRotate.ts
65050
- var args63, tool$integrationsRotate;
65491
+ var args65, tool$integrationsRotate;
65051
65492
  var init_integrationsRotate2 = __esm(() => {
65052
65493
  init_integrationsRotate();
65053
65494
  init_rotateintegrationsecretop();
65054
65495
  init_tools();
65055
- args63 = {
65496
+ args65 = {
65056
65497
  request: RotateIntegrationSecretRequest$zodSchema
65057
65498
  };
65058
65499
  tool$integrationsRotate = {
@@ -65067,7 +65508,7 @@ For Auth0, send {} and the answer's secret is the new shared secret, shown once.
65067
65508
  openWorldHint: false,
65068
65509
  readOnlyHint: false
65069
65510
  },
65070
- args: args63,
65511
+ args: args65,
65071
65512
  tool: async (client, args, ctx) => {
65072
65513
  const [result] = await integrationsRotate(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
65073
65514
  if (!result.ok) {
@@ -65175,9 +65616,9 @@ var init_listinvitesop = __esm(() => {
65175
65616
 
65176
65617
  // src/funcs/invitesList.ts
65177
65618
  function invitesList(client$, request, options) {
65178
- return new APIPromise($do64(client$, request, options));
65619
+ return new APIPromise($do66(client$, request, options));
65179
65620
  }
65180
- async function $do64(client$, request, options) {
65621
+ async function $do66(client$, request, options) {
65181
65622
  const parsed$ = safeParse2(request, (value$) => ListInvitesRequest$zodSchema.parse(value$), "Input validation failed");
65182
65623
  if (!parsed$.ok) {
65183
65624
  return [parsed$, { status: "invalid" }];
@@ -65259,12 +65700,12 @@ var init_invitesList = __esm(() => {
65259
65700
  });
65260
65701
 
65261
65702
  // src/mcp-server/tools/invitesList.ts
65262
- var args64, tool$invitesList;
65703
+ var args66, tool$invitesList;
65263
65704
  var init_invitesList2 = __esm(() => {
65264
65705
  init_invitesList();
65265
65706
  init_listinvitesop();
65266
65707
  init_tools();
65267
- args64 = {
65708
+ args66 = {
65268
65709
  request: ListInvitesRequest$zodSchema
65269
65710
  };
65270
65711
  tool$invitesList = {
@@ -65279,7 +65720,7 @@ Read pending workspace invitations with a live members_manage key. Tokens are ex
65279
65720
  openWorldHint: false,
65280
65721
  readOnlyHint: true
65281
65722
  },
65282
- args: args64,
65723
+ args: args66,
65283
65724
  tool: async (client, args, ctx) => {
65284
65725
  const [result] = await invitesList(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
65285
65726
  if (!result.ok) {
@@ -65330,9 +65771,9 @@ var init_revokeinviteop = __esm(() => {
65330
65771
 
65331
65772
  // src/funcs/invitesRevoke.ts
65332
65773
  function invitesRevoke(client$, request, options) {
65333
- return new APIPromise($do65(client$, request, options));
65774
+ return new APIPromise($do67(client$, request, options));
65334
65775
  }
65335
- async function $do65(client$, request, options) {
65776
+ async function $do67(client$, request, options) {
65336
65777
  const parsed$ = safeParse2(request, (value$) => RevokeInviteRequest$zodSchema.parse(value$), "Input validation failed");
65337
65778
  if (!parsed$.ok) {
65338
65779
  return [parsed$, { status: "invalid" }];
@@ -65418,12 +65859,12 @@ var init_invitesRevoke = __esm(() => {
65418
65859
  });
65419
65860
 
65420
65861
  // src/mcp-server/tools/invitesRevoke.ts
65421
- var args65, tool$invitesRevoke;
65862
+ var args67, tool$invitesRevoke;
65422
65863
  var init_invitesRevoke2 = __esm(() => {
65423
65864
  init_invitesRevoke();
65424
65865
  init_revokeinviteop();
65425
65866
  init_tools();
65426
- args65 = {
65867
+ args67 = {
65427
65868
  request: RevokeInviteRequest$zodSchema
65428
65869
  };
65429
65870
  tool$invitesRevoke = {
@@ -65438,7 +65879,7 @@ Revoke a pending invitation with a live members_manage key. A revoked token cann
65438
65879
  openWorldHint: false,
65439
65880
  readOnlyHint: false
65440
65881
  },
65441
- args: args65,
65882
+ args: args67,
65442
65883
  tool: async (client, args, ctx) => {
65443
65884
  const [result] = await invitesRevoke(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
65444
65885
  if (!result.ok) {
@@ -65571,9 +66012,9 @@ var init_listkeysop = __esm(() => {
65571
66012
 
65572
66013
  // src/funcs/keysList.ts
65573
66014
  function keysList(client$, request, options) {
65574
- return new APIPromise($do66(client$, request, options));
66015
+ return new APIPromise($do68(client$, request, options));
65575
66016
  }
65576
- async function $do66(client$, request, options) {
66017
+ async function $do68(client$, request, options) {
65577
66018
  const parsed$ = safeParse2(request, (value$) => ListKeysRequest$zodSchema.parse(value$), "Input validation failed");
65578
66019
  if (!parsed$.ok) {
65579
66020
  return [parsed$, { status: "invalid" }];
@@ -65655,12 +66096,12 @@ var init_keysList = __esm(() => {
65655
66096
  });
65656
66097
 
65657
66098
  // src/mcp-server/tools/keysList.ts
65658
- var args66, tool$keysList;
66099
+ var args68, tool$keysList;
65659
66100
  var init_keysList2 = __esm(() => {
65660
66101
  init_keysList();
65661
66102
  init_listkeysop();
65662
66103
  init_tools();
65663
- args66 = {
66104
+ args68 = {
65664
66105
  request: ListKeysRequest$zodSchema
65665
66106
  };
65666
66107
  tool$keysList = {
@@ -65675,7 +66116,7 @@ Lists the keys of the signing key's environment, newest first, at most 200, revo
65675
66116
  openWorldHint: false,
65676
66117
  readOnlyHint: true
65677
66118
  },
65678
- args: args66,
66119
+ args: args68,
65679
66120
  tool: async (client, args, ctx) => {
65680
66121
  const [result] = await keysList(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
65681
66122
  if (!result.ok) {
@@ -65729,9 +66170,9 @@ var init_revokekeyop = __esm(() => {
65729
66170
 
65730
66171
  // src/funcs/keysRevoke.ts
65731
66172
  function keysRevoke(client$, request, options) {
65732
- return new APIPromise($do67(client$, request, options));
66173
+ return new APIPromise($do69(client$, request, options));
65733
66174
  }
65734
- async function $do67(client$, request, options) {
66175
+ async function $do69(client$, request, options) {
65735
66176
  const parsed$ = safeParse2(request, (value$) => RevokeKeyRequest$zodSchema.parse(value$), "Input validation failed");
65736
66177
  if (!parsed$.ok) {
65737
66178
  return [parsed$, { status: "invalid" }];
@@ -65817,12 +66258,12 @@ var init_keysRevoke = __esm(() => {
65817
66258
  });
65818
66259
 
65819
66260
  // src/mcp-server/tools/keysRevoke.ts
65820
- var args67, tool$keysRevoke;
66261
+ var args69, tool$keysRevoke;
65821
66262
  var init_keysRevoke2 = __esm(() => {
65822
66263
  init_keysRevoke();
65823
66264
  init_revokekeyop();
65824
66265
  init_tools();
65825
- args67 = {
66266
+ args69 = {
65826
66267
  request: RevokeKeyRequest$zodSchema
65827
66268
  };
65828
66269
  tool$keysRevoke = {
@@ -65837,7 +66278,7 @@ Revokes a key of the signing key's environment at once: its next request answers
65837
66278
  openWorldHint: false,
65838
66279
  readOnlyHint: false
65839
66280
  },
65840
- args: args67,
66281
+ args: args69,
65841
66282
  tool: async (client, args, ctx) => {
65842
66283
  const [result] = await keysRevoke(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
65843
66284
  if (!result.ok) {
@@ -65979,9 +66420,9 @@ var init_changelistsop = __esm(() => {
65979
66420
 
65980
66421
  // src/funcs/listsChange.ts
65981
66422
  function listsChange(client$, request, options) {
65982
- return new APIPromise($do68(client$, request, options));
66423
+ return new APIPromise($do70(client$, request, options));
65983
66424
  }
65984
- async function $do68(client$, request, options) {
66425
+ async function $do70(client$, request, options) {
65985
66426
  const parsed$ = safeParse2(request, (value$) => ChangeListsRequest$zodSchema.parse(value$), "Input validation failed");
65986
66427
  if (!parsed$.ok) {
65987
66428
  return [parsed$, { status: "invalid" }];
@@ -66069,12 +66510,12 @@ var init_listsChange = __esm(() => {
66069
66510
  });
66070
66511
 
66071
66512
  // src/mcp-server/tools/listsChange.ts
66072
- var args68, tool$listsChange;
66513
+ var args70, tool$listsChange;
66073
66514
  var init_listsChange2 = __esm(() => {
66074
66515
  init_listsChange();
66075
66516
  init_changelistsop();
66076
66517
  init_tools();
66077
- args68 = {
66518
+ args70 = {
66078
66519
  request: ChangeListsRequest$zodSchema
66079
66520
  };
66080
66521
  tool$listsChange = {
@@ -66089,7 +66530,7 @@ Atomically add and remove a bounded batch of entries with an idempotency key. Re
66089
66530
  openWorldHint: false,
66090
66531
  readOnlyHint: false
66091
66532
  },
66092
- args: args68,
66533
+ args: args70,
66093
66534
  tool: async (client, args, ctx) => {
66094
66535
  const [result] = await listsChange(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
66095
66536
  if (!result.ok) {
@@ -66146,9 +66587,9 @@ var init_createlistentryop = __esm(() => {
66146
66587
 
66147
66588
  // src/funcs/listsCreate.ts
66148
66589
  function listsCreate(client$, request, options) {
66149
- return new APIPromise($do69(client$, request, options));
66590
+ return new APIPromise($do71(client$, request, options));
66150
66591
  }
66151
- async function $do69(client$, request, options) {
66592
+ async function $do71(client$, request, options) {
66152
66593
  const parsed$ = safeParse2(request, (value$) => CreateListEntryRequest$zodSchema.parse(value$), "Input validation failed");
66153
66594
  if (!parsed$.ok) {
66154
66595
  return [parsed$, { status: "invalid" }];
@@ -66235,12 +66676,12 @@ var init_listsCreate = __esm(() => {
66235
66676
  });
66236
66677
 
66237
66678
  // src/mcp-server/tools/listsCreate.ts
66238
- var args69, tool$listsCreate;
66679
+ var args71, tool$listsCreate;
66239
66680
  var init_listsCreate2 = __esm(() => {
66240
66681
  init_listsCreate();
66241
66682
  init_createlistentryop();
66242
66683
  init_tools();
66243
- args69 = {
66684
+ args71 = {
66244
66685
  request: CreateListEntryRequest$zodSchema
66245
66686
  };
66246
66687
  tool$listsCreate = {
@@ -66255,7 +66696,7 @@ Add a canonical email or email-domain override with a reason and optional expiry
66255
66696
  openWorldHint: false,
66256
66697
  readOnlyHint: false
66257
66698
  },
66258
- args: args69,
66699
+ args: args71,
66259
66700
  tool: async (client, args, ctx) => {
66260
66701
  const [result] = await listsCreate(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
66261
66702
  if (!result.ok) {
@@ -66308,9 +66749,9 @@ var init_deletelistentryop = __esm(() => {
66308
66749
 
66309
66750
  // src/funcs/listsDelete.ts
66310
66751
  function listsDelete(client$, request, options) {
66311
- return new APIPromise($do70(client$, request, options));
66752
+ return new APIPromise($do72(client$, request, options));
66312
66753
  }
66313
- async function $do70(client$, request, options) {
66754
+ async function $do72(client$, request, options) {
66314
66755
  const parsed$ = safeParse2(request, (value$) => DeleteListEntryRequest$zodSchema.parse(value$), "Input validation failed");
66315
66756
  if (!parsed$.ok) {
66316
66757
  return [parsed$, { status: "invalid" }];
@@ -66400,12 +66841,12 @@ var init_listsDelete = __esm(() => {
66400
66841
  });
66401
66842
 
66402
66843
  // src/mcp-server/tools/listsDelete.ts
66403
- var args70, tool$listsDelete;
66844
+ var args72, tool$listsDelete;
66404
66845
  var init_listsDelete2 = __esm(() => {
66405
66846
  init_listsDelete();
66406
66847
  init_deletelistentryop();
66407
66848
  init_tools();
66408
- args70 = {
66849
+ args72 = {
66409
66850
  request: DeleteListEntryRequest$zodSchema
66410
66851
  };
66411
66852
  tool$listsDelete = {
@@ -66420,7 +66861,7 @@ Remove an override with settings plus policy_publish, or legacy management. The
66420
66861
  openWorldHint: false,
66421
66862
  readOnlyHint: false
66422
66863
  },
66423
- args: args70,
66864
+ args: args72,
66424
66865
  tool: async (client, args, ctx) => {
66425
66866
  const [result] = await listsDelete(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
66426
66867
  if (!result.ok) {
@@ -66476,9 +66917,9 @@ var init_getlistchangeop = __esm(() => {
66476
66917
 
66477
66918
  // src/funcs/listsGetChange.ts
66478
66919
  function listsGetChange(client$, request, options) {
66479
- return new APIPromise($do71(client$, request, options));
66920
+ return new APIPromise($do73(client$, request, options));
66480
66921
  }
66481
- async function $do71(client$, request, options) {
66922
+ async function $do73(client$, request, options) {
66482
66923
  const parsed$ = safeParse2(request, (value$) => GetListChangeRequest$zodSchema.parse(value$), "Input validation failed");
66483
66924
  if (!parsed$.ok) {
66484
66925
  return [parsed$, { status: "invalid" }];
@@ -66568,12 +67009,12 @@ var init_listsGetChange = __esm(() => {
66568
67009
  });
66569
67010
 
66570
67011
  // src/mcp-server/tools/listsGetChange.ts
66571
- var args71, tool$listsGetChange;
67012
+ var args73, tool$listsGetChange;
66572
67013
  var init_listsGetChange2 = __esm(() => {
66573
67014
  init_listsGetChange();
66574
67015
  init_getlistchangeop();
66575
67016
  init_tools();
66576
- args71 = {
67017
+ args73 = {
66577
67018
  request: GetListChangeRequest$zodSchema
66578
67019
  };
66579
67020
  tool$listsGetChange = {
@@ -66588,7 +67029,7 @@ Read retained propagation progress for a list change with settings or management
66588
67029
  openWorldHint: false,
66589
67030
  readOnlyHint: true
66590
67031
  },
66591
- args: args71,
67032
+ args: args73,
66592
67033
  tool: async (client, args, ctx) => {
66593
67034
  const [result] = await listsGetChange(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
66594
67035
  if (!result.ok) {
@@ -66656,9 +67097,9 @@ var init_listlistentriesop = __esm(() => {
66656
67097
 
66657
67098
  // src/funcs/listsList.ts
66658
67099
  function listsList(client$, request, options) {
66659
- return new APIPromise($do72(client$, request, options));
67100
+ return new APIPromise($do74(client$, request, options));
66660
67101
  }
66661
- async function $do72(client$, request, options) {
67102
+ async function $do74(client$, request, options) {
66662
67103
  const parsed$ = safeParse2(request, (value$) => ListListEntriesRequest$zodSchema.parse(value$), "Input validation failed");
66663
67104
  if (!parsed$.ok) {
66664
67105
  return [parsed$, { status: "invalid" }];
@@ -66749,12 +67190,12 @@ var init_listsList = __esm(() => {
66749
67190
  });
66750
67191
 
66751
67192
  // src/mcp-server/tools/listsList.ts
66752
- var args72, tool$listsList;
67193
+ var args74, tool$listsList;
66753
67194
  var init_listsList2 = __esm(() => {
66754
67195
  init_listsList();
66755
67196
  init_listlistentriesop();
66756
67197
  init_tools();
66757
- args72 = {
67198
+ args74 = {
66758
67199
  request: ListListEntriesRequest$zodSchema
66759
67200
  };
66760
67201
  tool$listsList = {
@@ -66769,7 +67210,7 @@ Page through this environment allow and block entries, with canonical values, re
66769
67210
  openWorldHint: false,
66770
67211
  readOnlyHint: true
66771
67212
  },
66772
- args: args72,
67213
+ args: args74,
66773
67214
  tool: async (client, args, ctx) => {
66774
67215
  const [result] = await listsList(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
66775
67216
  if (!result.ok) {
@@ -66901,9 +67342,9 @@ var init_previewlistop = __esm(() => {
66901
67342
 
66902
67343
  // src/funcs/listsPreview.ts
66903
67344
  function listsPreview(client$, request, options) {
66904
- return new APIPromise($do73(client$, request, options));
67345
+ return new APIPromise($do75(client$, request, options));
66905
67346
  }
66906
- async function $do73(client$, request, options) {
67347
+ async function $do75(client$, request, options) {
66907
67348
  const parsed$ = safeParse2(request, (value$) => PreviewListRequest$zodSchema.parse(value$), "Input validation failed");
66908
67349
  if (!parsed$.ok) {
66909
67350
  return [parsed$, { status: "invalid" }];
@@ -66990,12 +67431,12 @@ var init_listsPreview = __esm(() => {
66990
67431
  });
66991
67432
 
66992
67433
  // src/mcp-server/tools/listsPreview.ts
66993
- var args73, tool$listsPreview;
67434
+ var args75, tool$listsPreview;
66994
67435
  var init_listsPreview2 = __esm(() => {
66995
67436
  init_listsPreview();
66996
67437
  init_previewlistop();
66997
67438
  init_tools();
66998
- args73 = {
67439
+ args75 = {
66999
67440
  request: PreviewListRequest$zodSchema
67000
67441
  };
67001
67442
  tool$listsPreview = {
@@ -67010,7 +67451,7 @@ Preview canonical list matches and current override effects with settings or man
67010
67451
  openWorldHint: false,
67011
67452
  readOnlyHint: true
67012
67453
  },
67013
- args: args73,
67454
+ args: args75,
67014
67455
  tool: async (client, args, ctx) => {
67015
67456
  const [result] = await listsPreview(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
67016
67457
  if (!result.ok) {
@@ -67113,9 +67554,9 @@ var init_listmembersop = __esm(() => {
67113
67554
 
67114
67555
  // src/funcs/membersList.ts
67115
67556
  function membersList(client$, request, options) {
67116
- return new APIPromise($do74(client$, request, options));
67557
+ return new APIPromise($do76(client$, request, options));
67117
67558
  }
67118
- async function $do74(client$, request, options) {
67559
+ async function $do76(client$, request, options) {
67119
67560
  const parsed$ = safeParse2(request, (value$) => ListMembersRequest$zodSchema.parse(value$), "Input validation failed");
67120
67561
  if (!parsed$.ok) {
67121
67562
  return [parsed$, { status: "invalid" }];
@@ -67197,12 +67638,12 @@ var init_membersList = __esm(() => {
67197
67638
  });
67198
67639
 
67199
67640
  // src/mcp-server/tools/membersList.ts
67200
- var args74, tool$membersList;
67641
+ var args76, tool$membersList;
67201
67642
  var init_membersList2 = __esm(() => {
67202
67643
  init_membersList();
67203
67644
  init_listmembersop();
67204
67645
  init_tools();
67205
- args74 = {
67646
+ args76 = {
67206
67647
  request: ListMembersRequest$zodSchema
67207
67648
  };
67208
67649
  tool$membersList = {
@@ -67217,7 +67658,7 @@ Read the workspace directory with a live key carrying members or members_manage.
67217
67658
  openWorldHint: false,
67218
67659
  readOnlyHint: true
67219
67660
  },
67220
- args: args74,
67661
+ args: args76,
67221
67662
  tool: async (client, args, ctx) => {
67222
67663
  const [result] = await membersList(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
67223
67664
  if (!result.ok) {
@@ -67268,9 +67709,9 @@ var init_removememberop = __esm(() => {
67268
67709
 
67269
67710
  // src/funcs/membersRemove.ts
67270
67711
  function membersRemove(client$, request, options) {
67271
- return new APIPromise($do75(client$, request, options));
67712
+ return new APIPromise($do77(client$, request, options));
67272
67713
  }
67273
- async function $do75(client$, request, options) {
67714
+ async function $do77(client$, request, options) {
67274
67715
  const parsed$ = safeParse2(request, (value$) => RemoveMemberRequest$zodSchema.parse(value$), "Input validation failed");
67275
67716
  if (!parsed$.ok) {
67276
67717
  return [parsed$, { status: "invalid" }];
@@ -67356,12 +67797,12 @@ var init_membersRemove = __esm(() => {
67356
67797
  });
67357
67798
 
67358
67799
  // src/mcp-server/tools/membersRemove.ts
67359
- var args75, tool$membersRemove;
67800
+ var args77, tool$membersRemove;
67360
67801
  var init_membersRemove2 = __esm(() => {
67361
67802
  init_membersRemove();
67362
67803
  init_removememberop();
67363
67804
  init_tools();
67364
- args75 = {
67805
+ args77 = {
67365
67806
  request: RemoveMemberRequest$zodSchema
67366
67807
  };
67367
67808
  tool$membersRemove = {
@@ -67376,7 +67817,7 @@ Remove a non-owner member with a live members_manage key. Subsequent access is r
67376
67817
  openWorldHint: false,
67377
67818
  readOnlyHint: false
67378
67819
  },
67379
- args: args75,
67820
+ args: args77,
67380
67821
  tool: async (client, args, ctx) => {
67381
67822
  const [result] = await membersRemove(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
67382
67823
  if (!result.ok) {
@@ -67453,9 +67894,9 @@ var init_updatememberop = __esm(() => {
67453
67894
 
67454
67895
  // src/funcs/membersUpdate.ts
67455
67896
  function membersUpdate(client$, request, options) {
67456
- return new APIPromise($do76(client$, request, options));
67897
+ return new APIPromise($do78(client$, request, options));
67457
67898
  }
67458
- async function $do76(client$, request, options) {
67899
+ async function $do78(client$, request, options) {
67459
67900
  const parsed$ = safeParse2(request, (value$) => UpdateMemberRequest$zodSchema.parse(value$), "Input validation failed");
67460
67901
  if (!parsed$.ok) {
67461
67902
  return [parsed$, { status: "invalid" }];
@@ -67542,12 +67983,12 @@ var init_membersUpdate = __esm(() => {
67542
67983
  });
67543
67984
 
67544
67985
  // src/mcp-server/tools/membersUpdate.ts
67545
- var args76, tool$membersUpdate;
67986
+ var args78, tool$membersUpdate;
67546
67987
  var init_membersUpdate2 = __esm(() => {
67547
67988
  init_membersUpdate();
67548
67989
  init_updatememberop();
67549
67990
  init_tools();
67550
- args76 = {
67991
+ args78 = {
67551
67992
  request: UpdateMemberRequest$zodSchema
67552
67993
  };
67553
67994
  tool$membersUpdate = {
@@ -67562,7 +68003,7 @@ Update a non-owner member role, environment access or sensitive permission exclu
67562
68003
  openWorldHint: false,
67563
68004
  readOnlyHint: false
67564
68005
  },
67565
- args: args76,
68006
+ args: args78,
67566
68007
  tool: async (client, args, ctx) => {
67567
68008
  const [result] = await membersUpdate(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
67568
68009
  if (!result.ok) {
@@ -67739,9 +68180,9 @@ var init_summarizeworkspaceoperationsop = __esm(() => {
67739
68180
 
67740
68181
  // src/funcs/operationsSummarize.ts
67741
68182
  function operationsSummarize(client$, request, options) {
67742
- return new APIPromise($do77(client$, request, options));
68183
+ return new APIPromise($do79(client$, request, options));
67743
68184
  }
67744
- async function $do77(client$, request, options) {
68185
+ async function $do79(client$, request, options) {
67745
68186
  const parsed$ = safeParse2(request, (value$) => SummarizeWorkspaceOperationsRequest$zodSchema.parse(value$), "Input validation failed");
67746
68187
  if (!parsed$.ok) {
67747
68188
  return [parsed$, { status: "invalid" }];
@@ -67824,12 +68265,12 @@ var init_operationsSummarize = __esm(() => {
67824
68265
  });
67825
68266
 
67826
68267
  // src/mcp-server/tools/operationsSummarize.ts
67827
- var args77, tool$operationsSummarize;
68268
+ var args79, tool$operationsSummarize;
67828
68269
  var init_operationsSummarize2 = __esm(() => {
67829
68270
  init_operationsSummarize();
67830
68271
  init_summarizeworkspaceoperationsop();
67831
68272
  init_tools();
67832
- args77 = {
68273
+ args79 = {
67833
68274
  request: SummarizeWorkspaceOperationsRequest$zodSchema
67834
68275
  };
67835
68276
  tool$operationsSummarize = {
@@ -67844,7 +68285,7 @@ Read one retained snapshot of account outcomes, enforcement reports and review s
67844
68285
  openWorldHint: false,
67845
68286
  readOnlyHint: true
67846
68287
  },
67847
- args: args77,
68288
+ args: args79,
67848
68289
  tool: async (client, args, ctx) => {
67849
68290
  const [result] = await operationsSummarize(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
67850
68291
  if (!result.ok) {
@@ -67885,9 +68326,9 @@ var init_requestaggregaterequest = __esm(() => {
67885
68326
 
67886
68327
  // src/funcs/requestsAggregate.ts
67887
68328
  function requestsAggregate(client$, request, options) {
67888
- return new APIPromise($do78(client$, request, options));
68329
+ return new APIPromise($do80(client$, request, options));
67889
68330
  }
67890
- async function $do78(client$, request, options) {
68331
+ async function $do80(client$, request, options) {
67891
68332
  const parsed$ = safeParse2(request, (value$) => RequestAggregateRequest$zodSchema.parse(value$), "Input validation failed");
67892
68333
  if (!parsed$.ok) {
67893
68334
  return [parsed$, { status: "invalid" }];
@@ -67964,12 +68405,12 @@ var init_requestsAggregate = __esm(() => {
67964
68405
  });
67965
68406
 
67966
68407
  // src/mcp-server/tools/requestsAggregate.ts
67967
- var args78, tool$requestsAggregate;
68408
+ var args80, tool$requestsAggregate;
67968
68409
  var init_requestsAggregate2 = __esm(() => {
67969
68410
  init_requestsAggregate();
67970
68411
  init_requestaggregaterequest();
67971
68412
  init_tools();
67972
- args78 = {
68413
+ args80 = {
67973
68414
  request: RequestAggregateRequest$zodSchema
67974
68415
  };
67975
68416
  tool$requestsAggregate = {
@@ -67984,7 +68425,7 @@ Count all retained matching request attempts and latency samples within seven da
67984
68425
  openWorldHint: false,
67985
68426
  readOnlyHint: true
67986
68427
  },
67987
- args: args78,
68428
+ args: args80,
67988
68429
  tool: async (client, args, ctx) => {
67989
68430
  const [result] = await requestsAggregate(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
67990
68431
  if (!result.ok) {
@@ -68055,9 +68496,9 @@ var init_listrequestdiagnosticsop = __esm(() => {
68055
68496
 
68056
68497
  // src/funcs/requestsList.ts
68057
68498
  function requestsList(client$, request, options) {
68058
- return new APIPromise($do79(client$, request, options));
68499
+ return new APIPromise($do81(client$, request, options));
68059
68500
  }
68060
- async function $do79(client$, request, options) {
68501
+ async function $do81(client$, request, options) {
68061
68502
  const parsed$ = safeParse2(request, (value$) => ListRequestDiagnosticsRequest$zodSchema.parse(value$), "Input validation failed");
68062
68503
  if (!parsed$.ok) {
68063
68504
  return [parsed$, { status: "invalid" }];
@@ -68144,12 +68585,12 @@ var init_requestsList = __esm(() => {
68144
68585
  });
68145
68586
 
68146
68587
  // src/mcp-server/tools/requestsList.ts
68147
- var args79, tool$requestsList;
68588
+ var args81, tool$requestsList;
68148
68589
  var init_requestsList2 = __esm(() => {
68149
68590
  init_requestsList();
68150
68591
  init_listrequestdiagnosticsop();
68151
68592
  init_tools();
68152
- args79 = {
68593
+ args81 = {
68153
68594
  request: ListRequestDiagnosticsRequest$zodSchema
68154
68595
  };
68155
68596
  tool$requestsList = {
@@ -68164,7 +68605,7 @@ Search authenticated request attempts by time, route, status or request correlat
68164
68605
  openWorldHint: false,
68165
68606
  readOnlyHint: true
68166
68607
  },
68167
- args: args79,
68608
+ args: args81,
68168
68609
  tool: async (client, args, ctx) => {
68169
68610
  const [result] = await requestsList(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
68170
68611
  if (!result.ok) {
@@ -68279,9 +68720,9 @@ var init_addreviewsubjectop = __esm(() => {
68279
68720
 
68280
68721
  // src/funcs/reviewsAddSubject.ts
68281
68722
  function reviewsAddSubject(client$, request, options) {
68282
- return new APIPromise($do80(client$, request, options));
68723
+ return new APIPromise($do82(client$, request, options));
68283
68724
  }
68284
- async function $do80(client$, request, options) {
68725
+ async function $do82(client$, request, options) {
68285
68726
  const parsed$ = safeParse2(request, (value$) => AddReviewSubjectRequest$zodSchema.parse(value$), "Input validation failed");
68286
68727
  if (!parsed$.ok) {
68287
68728
  return [parsed$, { status: "invalid" }];
@@ -68359,12 +68800,12 @@ var init_reviewsAddSubject = __esm(() => {
68359
68800
  });
68360
68801
 
68361
68802
  // src/mcp-server/tools/reviewsAddSubject.ts
68362
- var args80, tool$reviewsAddSubject;
68803
+ var args82, tool$reviewsAddSubject;
68363
68804
  var init_reviewsAddSubject2 = __esm(() => {
68364
68805
  init_reviewsAddSubject();
68365
68806
  init_addreviewsubjectop();
68366
68807
  init_tools();
68367
- args80 = {
68808
+ args82 = {
68368
68809
  request: AddReviewSubjectRequest$zodSchema
68369
68810
  };
68370
68811
  tool$reviewsAddSubject = {
@@ -68379,7 +68820,7 @@ Link an account, exact assessment revision or issued-key association within this
68379
68820
  openWorldHint: false,
68380
68821
  readOnlyHint: false
68381
68822
  },
68382
- args: args80,
68823
+ args: args82,
68383
68824
  tool: async (client, args, ctx) => {
68384
68825
  const [result] = await reviewsAddSubject(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
68385
68826
  if (!result.ok) {
@@ -68460,9 +68901,9 @@ var init_commentreviewop = __esm(() => {
68460
68901
 
68461
68902
  // src/funcs/reviewsComment.ts
68462
68903
  function reviewsComment(client$, request, options) {
68463
- return new APIPromise($do81(client$, request, options));
68904
+ return new APIPromise($do83(client$, request, options));
68464
68905
  }
68465
- async function $do81(client$, request, options) {
68906
+ async function $do83(client$, request, options) {
68466
68907
  const parsed$ = safeParse2(request, (value$) => CommentReviewRequest$zodSchema.parse(value$), "Input validation failed");
68467
68908
  if (!parsed$.ok) {
68468
68909
  return [parsed$, { status: "invalid" }];
@@ -68540,12 +68981,12 @@ var init_reviewsComment = __esm(() => {
68540
68981
  });
68541
68982
 
68542
68983
  // src/mcp-server/tools/reviewsComment.ts
68543
- var args81, tool$reviewsComment;
68984
+ var args83, tool$reviewsComment;
68544
68985
  var init_reviewsComment2 = __esm(() => {
68545
68986
  init_reviewsComment();
68546
68987
  init_commentreviewop();
68547
68988
  init_tools();
68548
- args81 = {
68989
+ args83 = {
68549
68990
  request: CommentReviewRequest$zodSchema
68550
68991
  };
68551
68992
  tool$reviewsComment = {
@@ -68560,7 +69001,7 @@ Append a comment after checking the expected review version.`,
68560
69001
  openWorldHint: false,
68561
69002
  readOnlyHint: false
68562
69003
  },
68563
- args: args81,
69004
+ args: args83,
68564
69005
  tool: async (client, args, ctx) => {
68565
69006
  const [result] = await reviewsComment(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
68566
69007
  if (!result.ok) {
@@ -68706,9 +69147,9 @@ var init_createreviewop = __esm(() => {
68706
69147
 
68707
69148
  // src/funcs/reviewsCreate.ts
68708
69149
  function reviewsCreate(client$, request, options) {
68709
- return new APIPromise($do82(client$, request, options));
69150
+ return new APIPromise($do84(client$, request, options));
68710
69151
  }
68711
- async function $do82(client$, request, options) {
69152
+ async function $do84(client$, request, options) {
68712
69153
  const parsed$ = safeParse2(request, (value$) => CreateReviewRequest$zodSchema.parse(value$), "Input validation failed");
68713
69154
  if (!parsed$.ok) {
68714
69155
  return [parsed$, { status: "invalid" }];
@@ -68782,12 +69223,12 @@ var init_reviewsCreate = __esm(() => {
68782
69223
  });
68783
69224
 
68784
69225
  // src/mcp-server/tools/reviewsCreate.ts
68785
- var args82, tool$reviewsCreate;
69226
+ var args84, tool$reviewsCreate;
68786
69227
  var init_reviewsCreate2 = __esm(() => {
68787
69228
  init_reviewsCreate();
68788
69229
  init_createreviewop();
68789
69230
  init_tools();
68790
- args82 = {
69231
+ args84 = {
68791
69232
  request: CreateReviewRequest$zodSchema
68792
69233
  };
68793
69234
  tool$reviewsCreate = {
@@ -68802,7 +69243,7 @@ Open a review for one account. An account can have one active review in its envi
68802
69243
  openWorldHint: false,
68803
69244
  readOnlyHint: false
68804
69245
  },
68805
- args: args82,
69246
+ args: args84,
68806
69247
  tool: async (client, args, ctx) => {
68807
69248
  const [result] = await reviewsCreate(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
68808
69249
  if (!result.ok) {
@@ -68918,9 +69359,9 @@ var init_createreviewviewop = __esm(() => {
68918
69359
 
68919
69360
  // src/funcs/reviewsCreateView.ts
68920
69361
  function reviewsCreateView(client$, request, options) {
68921
- return new APIPromise($do83(client$, request, options));
69362
+ return new APIPromise($do85(client$, request, options));
68922
69363
  }
68923
- async function $do83(client$, request, options) {
69364
+ async function $do85(client$, request, options) {
68924
69365
  const parsed$ = safeParse2(request, (value$) => CreateReviewViewRequest$zodSchema.parse(value$), "Input validation failed");
68925
69366
  if (!parsed$.ok) {
68926
69367
  return [parsed$, { status: "invalid" }];
@@ -68994,12 +69435,12 @@ var init_reviewsCreateView = __esm(() => {
68994
69435
  });
68995
69436
 
68996
69437
  // src/mcp-server/tools/reviewsCreateView.ts
68997
- var args83, tool$reviewsCreateView;
69438
+ var args85, tool$reviewsCreateView;
68998
69439
  var init_reviewsCreateView2 = __esm(() => {
68999
69440
  init_reviewsCreateView();
69000
69441
  init_createreviewviewop();
69001
69442
  init_tools();
69002
- args83 = {
69443
+ args85 = {
69003
69444
  request: CreateReviewViewRequest$zodSchema
69004
69445
  };
69005
69446
  tool$reviewsCreateView = {
@@ -69014,7 +69455,7 @@ Save a private or shared review filter.`,
69014
69455
  openWorldHint: false,
69015
69456
  readOnlyHint: false
69016
69457
  },
69017
- args: args83,
69458
+ args: args85,
69018
69459
  tool: async (client, args, ctx) => {
69019
69460
  const [result] = await reviewsCreateView(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
69020
69461
  if (!result.ok) {
@@ -69082,9 +69523,9 @@ var init_deletereviewsubjectop = __esm(() => {
69082
69523
 
69083
69524
  // src/funcs/reviewsDeleteSubject.ts
69084
69525
  function reviewsDeleteSubject(client$, request, options) {
69085
- return new APIPromise($do84(client$, request, options));
69526
+ return new APIPromise($do86(client$, request, options));
69086
69527
  }
69087
- async function $do84(client$, request, options) {
69528
+ async function $do86(client$, request, options) {
69088
69529
  const parsed$ = safeParse2(request, (value$) => DeleteReviewSubjectRequest$zodSchema.parse(value$), "Input validation failed");
69089
69530
  if (!parsed$.ok) {
69090
69531
  return [parsed$, { status: "invalid" }];
@@ -69179,12 +69620,12 @@ var init_reviewsDeleteSubject = __esm(() => {
69179
69620
  });
69180
69621
 
69181
69622
  // src/mcp-server/tools/reviewsDeleteSubject.ts
69182
- var args84, tool$reviewsDeleteSubject;
69623
+ var args86, tool$reviewsDeleteSubject;
69183
69624
  var init_reviewsDeleteSubject2 = __esm(() => {
69184
69625
  init_reviewsDeleteSubject();
69185
69626
  init_deletereviewsubjectop();
69186
69627
  init_tools();
69187
- args84 = {
69628
+ args86 = {
69188
69629
  request: DeleteReviewSubjectRequest$zodSchema
69189
69630
  };
69190
69631
  tool$reviewsDeleteSubject = {
@@ -69199,7 +69640,7 @@ Remove a subject link with the expected review version. The linked account, asse
69199
69640
  openWorldHint: false,
69200
69641
  readOnlyHint: false
69201
69642
  },
69202
- args: args84,
69643
+ args: args86,
69203
69644
  tool: async (client, args, ctx) => {
69204
69645
  const [result] = await reviewsDeleteSubject(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
69205
69646
  if (!result.ok) {
@@ -69254,9 +69695,9 @@ var init_deletereviewviewop = __esm(() => {
69254
69695
 
69255
69696
  // src/funcs/reviewsDeleteView.ts
69256
69697
  function reviewsDeleteView(client$, request, options) {
69257
- return new APIPromise($do85(client$, request, options));
69698
+ return new APIPromise($do87(client$, request, options));
69258
69699
  }
69259
- async function $do85(client$, request, options) {
69700
+ async function $do87(client$, request, options) {
69260
69701
  const parsed$ = safeParse2(request, (value$) => DeleteReviewViewRequest$zodSchema.parse(value$), "Input validation failed");
69261
69702
  if (!parsed$.ok) {
69262
69703
  return [parsed$, { status: "invalid" }];
@@ -69347,12 +69788,12 @@ var init_reviewsDeleteView = __esm(() => {
69347
69788
  });
69348
69789
 
69349
69790
  // src/mcp-server/tools/reviewsDeleteView.ts
69350
- var args85, tool$reviewsDeleteView;
69791
+ var args87, tool$reviewsDeleteView;
69351
69792
  var init_reviewsDeleteView2 = __esm(() => {
69352
69793
  init_reviewsDeleteView();
69353
69794
  init_deletereviewviewop();
69354
69795
  init_tools();
69355
- args85 = {
69796
+ args87 = {
69356
69797
  request: DeleteReviewViewRequest$zodSchema
69357
69798
  };
69358
69799
  tool$reviewsDeleteView = {
@@ -69367,7 +69808,7 @@ Delete your saved review filter after checking its expected version.`,
69367
69808
  openWorldHint: false,
69368
69809
  readOnlyHint: false
69369
69810
  },
69370
- args: args85,
69811
+ args: args87,
69371
69812
  tool: async (client, args, ctx) => {
69372
69813
  const [result] = await reviewsDeleteView(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
69373
69814
  if (!result.ok) {
@@ -69440,9 +69881,9 @@ var init_exportreviewop = __esm(() => {
69440
69881
 
69441
69882
  // src/funcs/reviewsExport.ts
69442
69883
  function reviewsExport(client$, request, options) {
69443
- return new APIPromise($do86(client$, request, options));
69884
+ return new APIPromise($do88(client$, request, options));
69444
69885
  }
69445
- async function $do86(client$, request, options) {
69886
+ async function $do88(client$, request, options) {
69446
69887
  const parsed$ = safeParse2(request, (value$) => ExportReviewRequest$zodSchema.parse(value$), "Input validation failed");
69447
69888
  if (!parsed$.ok) {
69448
69889
  return [parsed$, { status: "invalid" }];
@@ -69532,12 +69973,12 @@ var init_reviewsExport = __esm(() => {
69532
69973
  });
69533
69974
 
69534
69975
  // src/mcp-server/tools/reviewsExport.ts
69535
- var args86, tool$reviewsExport;
69976
+ var args88, tool$reviewsExport;
69536
69977
  var init_reviewsExport2 = __esm(() => {
69537
69978
  init_reviewsExport();
69538
69979
  init_exportreviewop();
69539
69980
  init_tools();
69540
- args86 = {
69981
+ args88 = {
69541
69982
  request: ExportReviewRequest$zodSchema
69542
69983
  };
69543
69984
  tool$reviewsExport = {
@@ -69552,7 +69993,7 @@ Export retained review details, comments, resolutions and linked subjects. Requi
69552
69993
  openWorldHint: false,
69553
69994
  readOnlyHint: true
69554
69995
  },
69555
- args: args86,
69996
+ args: args88,
69556
69997
  tool: async (client, args, ctx) => {
69557
69998
  const [result] = await reviewsExport(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
69558
69999
  if (!result.ok) {
@@ -69608,9 +70049,9 @@ var init_getreviewop = __esm(() => {
69608
70049
 
69609
70050
  // src/funcs/reviewsGet.ts
69610
70051
  function reviewsGet(client$, request, options) {
69611
- return new APIPromise($do87(client$, request, options));
70052
+ return new APIPromise($do89(client$, request, options));
69612
70053
  }
69613
- async function $do87(client$, request, options) {
70054
+ async function $do89(client$, request, options) {
69614
70055
  const parsed$ = safeParse2(request, (value$) => GetReviewRequest$zodSchema.parse(value$), "Input validation failed");
69615
70056
  if (!parsed$.ok) {
69616
70057
  return [parsed$, { status: "invalid" }];
@@ -69700,12 +70141,12 @@ var init_reviewsGet = __esm(() => {
69700
70141
  });
69701
70142
 
69702
70143
  // src/mcp-server/tools/reviewsGet.ts
69703
- var args87, tool$reviewsGet;
70144
+ var args89, tool$reviewsGet;
69704
70145
  var init_reviewsGet2 = __esm(() => {
69705
70146
  init_reviewsGet();
69706
70147
  init_getreviewop();
69707
70148
  init_tools();
69708
- args87 = {
70149
+ args89 = {
69709
70150
  request: GetReviewRequest$zodSchema
69710
70151
  };
69711
70152
  tool$reviewsGet = {
@@ -69720,7 +70161,7 @@ Read a retained review and its current version.`,
69720
70161
  openWorldHint: false,
69721
70162
  readOnlyHint: true
69722
70163
  },
69723
- args: args87,
70164
+ args: args89,
69724
70165
  tool: async (client, args, ctx) => {
69725
70166
  const [result] = await reviewsGet(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
69726
70167
  if (!result.ok) {
@@ -69795,9 +70236,9 @@ var init_listreviewsop = __esm(() => {
69795
70236
 
69796
70237
  // src/funcs/reviewsList.ts
69797
70238
  function reviewsList(client$, request, options) {
69798
- return new APIPromise($do88(client$, request, options));
70239
+ return new APIPromise($do90(client$, request, options));
69799
70240
  }
69800
- async function $do88(client$, request, options) {
70241
+ async function $do90(client$, request, options) {
69801
70242
  const parsed$ = safeParse2(request, (value$) => ListReviewsRequest$zodSchema.parse(value$), "Input validation failed");
69802
70243
  if (!parsed$.ok) {
69803
70244
  return [parsed$, { status: "invalid" }];
@@ -69893,12 +70334,12 @@ var init_reviewsList = __esm(() => {
69893
70334
  });
69894
70335
 
69895
70336
  // src/mcp-server/tools/reviewsList.ts
69896
- var args88, tool$reviewsList;
70337
+ var args90, tool$reviewsList;
69897
70338
  var init_reviewsList2 = __esm(() => {
69898
70339
  init_reviewsList();
69899
70340
  init_listreviewsop();
69900
70341
  init_tools();
69901
- args88 = {
70342
+ args90 = {
69902
70343
  request: ListReviewsRequest$zodSchema
69903
70344
  };
69904
70345
  tool$reviewsList = {
@@ -69913,7 +70354,7 @@ List retained investigation reviews using filters and an authenticated cursor. U
69913
70354
  openWorldHint: false,
69914
70355
  readOnlyHint: true
69915
70356
  },
69916
- args: args88,
70357
+ args: args90,
69917
70358
  tool: async (client, args, ctx) => {
69918
70359
  const [result] = await reviewsList(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
69919
70360
  if (!result.ok) {
@@ -69982,9 +70423,9 @@ var init_listreviewcommentsop = __esm(() => {
69982
70423
 
69983
70424
  // src/funcs/reviewsListComments.ts
69984
70425
  function reviewsListComments(client$, request, options) {
69985
- return new APIPromise($do89(client$, request, options));
70426
+ return new APIPromise($do91(client$, request, options));
69986
70427
  }
69987
- async function $do89(client$, request, options) {
70428
+ async function $do91(client$, request, options) {
69988
70429
  const parsed$ = safeParse2(request, (value$) => ListReviewCommentsRequest$zodSchema.parse(value$), "Input validation failed");
69989
70430
  if (!parsed$.ok) {
69990
70431
  return [parsed$, { status: "invalid" }];
@@ -70079,12 +70520,12 @@ var init_reviewsListComments = __esm(() => {
70079
70520
  });
70080
70521
 
70081
70522
  // src/mcp-server/tools/reviewsListComments.ts
70082
- var args89, tool$reviewsListComments;
70523
+ var args91, tool$reviewsListComments;
70083
70524
  var init_reviewsListComments2 = __esm(() => {
70084
70525
  init_reviewsListComments();
70085
70526
  init_listreviewcommentsop();
70086
70527
  init_tools();
70087
- args89 = {
70528
+ args91 = {
70088
70529
  request: ListReviewCommentsRequest$zodSchema
70089
70530
  };
70090
70531
  tool$reviewsListComments = {
@@ -70099,7 +70540,7 @@ Page through retained review comments.`,
70099
70540
  openWorldHint: false,
70100
70541
  readOnlyHint: true
70101
70542
  },
70102
- args: args89,
70543
+ args: args91,
70103
70544
  tool: async (client, args, ctx) => {
70104
70545
  const [result] = await reviewsListComments(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
70105
70546
  if (!result.ok) {
@@ -70168,9 +70609,9 @@ var init_listreviewresolutionsop = __esm(() => {
70168
70609
 
70169
70610
  // src/funcs/reviewsListResolutions.ts
70170
70611
  function reviewsListResolutions(client$, request, options) {
70171
- return new APIPromise($do90(client$, request, options));
70612
+ return new APIPromise($do92(client$, request, options));
70172
70613
  }
70173
- async function $do90(client$, request, options) {
70614
+ async function $do92(client$, request, options) {
70174
70615
  const parsed$ = safeParse2(request, (value$) => ListReviewResolutionsRequest$zodSchema.parse(value$), "Input validation failed");
70175
70616
  if (!parsed$.ok) {
70176
70617
  return [parsed$, { status: "invalid" }];
@@ -70265,12 +70706,12 @@ var init_reviewsListResolutions = __esm(() => {
70265
70706
  });
70266
70707
 
70267
70708
  // src/mcp-server/tools/reviewsListResolutions.ts
70268
- var args90, tool$reviewsListResolutions;
70709
+ var args92, tool$reviewsListResolutions;
70269
70710
  var init_reviewsListResolutions2 = __esm(() => {
70270
70711
  init_reviewsListResolutions();
70271
70712
  init_listreviewresolutionsop();
70272
70713
  init_tools();
70273
- args90 = {
70714
+ args92 = {
70274
70715
  request: ListReviewResolutionsRequest$zodSchema
70275
70716
  };
70276
70717
  tool$reviewsListResolutions = {
@@ -70285,7 +70726,7 @@ Page through immutable review resolutions.`,
70285
70726
  openWorldHint: false,
70286
70727
  readOnlyHint: true
70287
70728
  },
70288
- args: args90,
70729
+ args: args92,
70289
70730
  tool: async (client, args, ctx) => {
70290
70731
  const [result] = await reviewsListResolutions(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
70291
70732
  if (!result.ok) {
@@ -70352,9 +70793,9 @@ var init_listreviewsubjectsop = __esm(() => {
70352
70793
 
70353
70794
  // src/funcs/reviewsListSubjects.ts
70354
70795
  function reviewsListSubjects(client$, request, options) {
70355
- return new APIPromise($do91(client$, request, options));
70796
+ return new APIPromise($do93(client$, request, options));
70356
70797
  }
70357
- async function $do91(client$, request, options) {
70798
+ async function $do93(client$, request, options) {
70358
70799
  const parsed$ = safeParse2(request, (value$) => ListReviewSubjectsRequest$zodSchema.parse(value$), "Input validation failed");
70359
70800
  if (!parsed$.ok) {
70360
70801
  return [parsed$, { status: "invalid" }];
@@ -70444,12 +70885,12 @@ var init_reviewsListSubjects = __esm(() => {
70444
70885
  });
70445
70886
 
70446
70887
  // src/mcp-server/tools/reviewsListSubjects.ts
70447
- var args91, tool$reviewsListSubjects;
70888
+ var args93, tool$reviewsListSubjects;
70448
70889
  var init_reviewsListSubjects2 = __esm(() => {
70449
70890
  init_reviewsListSubjects();
70450
70891
  init_listreviewsubjectsop();
70451
70892
  init_tools();
70452
- args91 = {
70893
+ args93 = {
70453
70894
  request: ListReviewSubjectsRequest$zodSchema
70454
70895
  };
70455
70896
  tool$reviewsListSubjects = {
@@ -70464,7 +70905,7 @@ List retained subjects linked to this review. A link supplies investigation cont
70464
70905
  openWorldHint: false,
70465
70906
  readOnlyHint: true
70466
70907
  },
70467
- args: args91,
70908
+ args: args93,
70468
70909
  tool: async (client, args, ctx) => {
70469
70910
  const [result] = await reviewsListSubjects(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
70470
70911
  if (!result.ok) {
@@ -70529,9 +70970,9 @@ var init_listreviewviewsop = __esm(() => {
70529
70970
 
70530
70971
  // src/funcs/reviewsListViews.ts
70531
70972
  function reviewsListViews(client$, request, options) {
70532
- return new APIPromise($do92(client$, request, options));
70973
+ return new APIPromise($do94(client$, request, options));
70533
70974
  }
70534
- async function $do92(client$, request, options) {
70975
+ async function $do94(client$, request, options) {
70535
70976
  const parsed$ = safeParse2(request, (value$) => ListReviewViewsRequest$zodSchema.parse(value$), "Input validation failed");
70536
70977
  if (!parsed$.ok) {
70537
70978
  return [parsed$, { status: "invalid" }];
@@ -70617,12 +71058,12 @@ var init_reviewsListViews = __esm(() => {
70617
71058
  });
70618
71059
 
70619
71060
  // src/mcp-server/tools/reviewsListViews.ts
70620
- var args92, tool$reviewsListViews;
71061
+ var args94, tool$reviewsListViews;
70621
71062
  var init_reviewsListViews2 = __esm(() => {
70622
71063
  init_reviewsListViews();
70623
71064
  init_listreviewviewsop();
70624
71065
  init_tools();
70625
- args92 = {
71066
+ args94 = {
70626
71067
  request: ListReviewViewsRequest$zodSchema
70627
71068
  };
70628
71069
  tool$reviewsListViews = {
@@ -70637,7 +71078,7 @@ List private and shared saved review filters visible to you.`,
70637
71078
  openWorldHint: false,
70638
71079
  readOnlyHint: true
70639
71080
  },
70640
- args: args92,
71081
+ args: args94,
70641
71082
  tool: async (client, args, ctx) => {
70642
71083
  const [result] = await reviewsListViews(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
70643
71084
  if (!result.ok) {
@@ -70712,9 +71153,9 @@ var init_queryreviewsop = __esm(() => {
70712
71153
 
70713
71154
  // src/funcs/reviewsQuery.ts
70714
71155
  function reviewsQuery(client$, request, options) {
70715
- return new APIPromise($do93(client$, request, options));
71156
+ return new APIPromise($do95(client$, request, options));
70716
71157
  }
70717
- async function $do93(client$, request, options) {
71158
+ async function $do95(client$, request, options) {
70718
71159
  const parsed$ = safeParse2(request, (value$) => QueryReviewsRequest$zodSchema.parse(value$), "Input validation failed");
70719
71160
  if (!parsed$.ok) {
70720
71161
  return [parsed$, { status: "invalid" }];
@@ -70801,12 +71242,12 @@ var init_reviewsQuery = __esm(() => {
70801
71242
  });
70802
71243
 
70803
71244
  // src/mcp-server/tools/reviewsQuery.ts
70804
- var args93, tool$reviewsQuery;
71245
+ var args95, tool$reviewsQuery;
70805
71246
  var init_reviewsQuery2 = __esm(() => {
70806
71247
  init_reviewsQuery();
70807
71248
  init_queryreviewsop();
70808
71249
  init_tools();
70809
- args93 = {
71250
+ args95 = {
70810
71251
  request: QueryReviewsRequest$zodSchema
70811
71252
  };
70812
71253
  tool$reviewsQuery = {
@@ -70821,7 +71262,7 @@ Query retained investigation reviews using a JSON body, including an exact accou
70821
71262
  openWorldHint: false,
70822
71263
  readOnlyHint: true
70823
71264
  },
70824
- args: args93,
71265
+ args: args95,
70825
71266
  tool: async (client, args, ctx) => {
70826
71267
  const [result] = await reviewsQuery(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
70827
71268
  if (!result.ok) {
@@ -70892,9 +71333,9 @@ var init_resolvereviewop = __esm(() => {
70892
71333
 
70893
71334
  // src/funcs/reviewsResolve.ts
70894
71335
  function reviewsResolve(client$, request, options) {
70895
- return new APIPromise($do94(client$, request, options));
71336
+ return new APIPromise($do96(client$, request, options));
70896
71337
  }
70897
- async function $do94(client$, request, options) {
71338
+ async function $do96(client$, request, options) {
70898
71339
  const parsed$ = safeParse2(request, (value$) => ResolveReviewRequest$zodSchema.parse(value$), "Input validation failed");
70899
71340
  if (!parsed$.ok) {
70900
71341
  return [parsed$, { status: "invalid" }];
@@ -70972,12 +71413,12 @@ var init_reviewsResolve = __esm(() => {
70972
71413
  });
70973
71414
 
70974
71415
  // src/mcp-server/tools/reviewsResolve.ts
70975
- var args94, tool$reviewsResolve;
71416
+ var args96, tool$reviewsResolve;
70976
71417
  var init_reviewsResolve2 = __esm(() => {
70977
71418
  init_reviewsResolve();
70978
71419
  init_resolvereviewop();
70979
71420
  init_tools();
70980
- args94 = {
71421
+ args96 = {
70981
71422
  request: ResolveReviewRequest$zodSchema
70982
71423
  };
70983
71424
  tool$reviewsResolve = {
@@ -70992,7 +71433,7 @@ Resolve a review against the exact current review and account decision versions.
70992
71433
  openWorldHint: false,
70993
71434
  readOnlyHint: false
70994
71435
  },
70995
- args: args94,
71436
+ args: args96,
70996
71437
  tool: async (client, args, ctx) => {
70997
71438
  const [result] = await reviewsResolve(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
70998
71439
  if (!result.ok) {
@@ -71074,9 +71515,9 @@ var init_updatereviewop = __esm(() => {
71074
71515
 
71075
71516
  // src/funcs/reviewsUpdate.ts
71076
71517
  function reviewsUpdate(client$, request, options) {
71077
- return new APIPromise($do95(client$, request, options));
71518
+ return new APIPromise($do97(client$, request, options));
71078
71519
  }
71079
- async function $do95(client$, request, options) {
71520
+ async function $do97(client$, request, options) {
71080
71521
  const parsed$ = safeParse2(request, (value$) => UpdateReviewRequest$zodSchema.parse(value$), "Input validation failed");
71081
71522
  if (!parsed$.ok) {
71082
71523
  return [parsed$, { status: "invalid" }];
@@ -71154,12 +71595,12 @@ var init_reviewsUpdate = __esm(() => {
71154
71595
  });
71155
71596
 
71156
71597
  // src/mcp-server/tools/reviewsUpdate.ts
71157
- var args95, tool$reviewsUpdate;
71598
+ var args97, tool$reviewsUpdate;
71158
71599
  var init_reviewsUpdate2 = __esm(() => {
71159
71600
  init_reviewsUpdate();
71160
71601
  init_updatereviewop();
71161
71602
  init_tools();
71162
- args95 = {
71603
+ args97 = {
71163
71604
  request: UpdateReviewRequest$zodSchema
71164
71605
  };
71165
71606
  tool$reviewsUpdate = {
@@ -71174,7 +71615,7 @@ Change review status, priority or assignment after checking the expected version
71174
71615
  openWorldHint: false,
71175
71616
  readOnlyHint: false
71176
71617
  },
71177
- args: args95,
71618
+ args: args97,
71178
71619
  tool: async (client, args, ctx) => {
71179
71620
  const [result] = await reviewsUpdate(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
71180
71621
  if (!result.ok) {
@@ -71232,9 +71673,9 @@ var init_updatereviewviewop = __esm(() => {
71232
71673
 
71233
71674
  // src/funcs/reviewsUpdateView.ts
71234
71675
  function reviewsUpdateView(client$, request, options) {
71235
- return new APIPromise($do96(client$, request, options));
71676
+ return new APIPromise($do98(client$, request, options));
71236
71677
  }
71237
- async function $do96(client$, request, options) {
71678
+ async function $do98(client$, request, options) {
71238
71679
  const parsed$ = safeParse2(request, (value$) => UpdateReviewViewRequest$zodSchema.parse(value$), "Input validation failed");
71239
71680
  if (!parsed$.ok) {
71240
71681
  return [parsed$, { status: "invalid" }];
@@ -71312,12 +71753,12 @@ var init_reviewsUpdateView = __esm(() => {
71312
71753
  });
71313
71754
 
71314
71755
  // src/mcp-server/tools/reviewsUpdateView.ts
71315
- var args96, tool$reviewsUpdateView;
71756
+ var args98, tool$reviewsUpdateView;
71316
71757
  var init_reviewsUpdateView2 = __esm(() => {
71317
71758
  init_reviewsUpdateView();
71318
71759
  init_updatereviewviewop();
71319
71760
  init_tools();
71320
- args96 = {
71761
+ args98 = {
71321
71762
  request: UpdateReviewViewRequest$zodSchema
71322
71763
  };
71323
71764
  tool$reviewsUpdateView = {
@@ -71332,7 +71773,7 @@ Update your saved review filter after checking its expected version.`,
71332
71773
  openWorldHint: false,
71333
71774
  readOnlyHint: false
71334
71775
  },
71335
- args: args96,
71776
+ args: args98,
71336
71777
  tool: async (client, args, ctx) => {
71337
71778
  const [result] = await reviewsUpdateView(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
71338
71779
  if (!result.ok) {
@@ -71387,9 +71828,9 @@ var init_getsettingsop = __esm(() => {
71387
71828
 
71388
71829
  // src/funcs/settingsGet.ts
71389
71830
  function settingsGet(client$, request, options) {
71390
- return new APIPromise($do97(client$, request, options));
71831
+ return new APIPromise($do99(client$, request, options));
71391
71832
  }
71392
- async function $do97(client$, request, options) {
71833
+ async function $do99(client$, request, options) {
71393
71834
  const parsed$ = safeParse2(request, (value$) => GetSettingsRequest$zodSchema.parse(value$), "Input validation failed");
71394
71835
  if (!parsed$.ok) {
71395
71836
  return [parsed$, { status: "invalid" }];
@@ -71475,12 +71916,12 @@ var init_settingsGet = __esm(() => {
71475
71916
  });
71476
71917
 
71477
71918
  // src/mcp-server/tools/settingsGet.ts
71478
- var args97, tool$settingsGet;
71919
+ var args99, tool$settingsGet;
71479
71920
  var init_settingsGet2 = __esm(() => {
71480
71921
  init_settingsGet();
71481
71922
  init_getsettingsop();
71482
71923
  init_tools();
71483
- args97 = {
71924
+ args99 = {
71484
71925
  request: GetSettingsRequest$zodSchema
71485
71926
  };
71486
71927
  tool$settingsGet = {
@@ -71495,7 +71936,7 @@ Read this environment retention, source selection, daily screening cap and effec
71495
71936
  openWorldHint: false,
71496
71937
  readOnlyHint: true
71497
71938
  },
71498
- args: args97,
71939
+ args: args99,
71499
71940
  tool: async (client, args, ctx) => {
71500
71941
  const [result] = await settingsGet(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
71501
71942
  if (!result.ok) {
@@ -71598,9 +72039,9 @@ var init_listpolicyhistoryop = __esm(() => {
71598
72039
 
71599
72040
  // src/funcs/settingsListHistory.ts
71600
72041
  function settingsListHistory(client$, request, options) {
71601
- return new APIPromise($do98(client$, request, options));
72042
+ return new APIPromise($do100(client$, request, options));
71602
72043
  }
71603
- async function $do98(client$, request, options) {
72044
+ async function $do100(client$, request, options) {
71604
72045
  const parsed$ = safeParse2(request, (value$) => ListPolicyHistoryRequest$zodSchema.parse(value$), "Input validation failed");
71605
72046
  if (!parsed$.ok) {
71606
72047
  return [parsed$, { status: "invalid" }];
@@ -71691,12 +72132,12 @@ var init_settingsListHistory = __esm(() => {
71691
72132
  });
71692
72133
 
71693
72134
  // src/mcp-server/tools/settingsListHistory.ts
71694
- var args98, tool$settingsListHistory;
72135
+ var args100, tool$settingsListHistory;
71695
72136
  var init_settingsListHistory2 = __esm(() => {
71696
72137
  init_settingsListHistory();
71697
72138
  init_listpolicyhistoryop();
71698
72139
  init_tools();
71699
- args98 = {
72140
+ args100 = {
71700
72141
  request: ListPolicyHistoryRequest$zodSchema
71701
72142
  };
71702
72143
  tool$settingsListHistory = {
@@ -71711,7 +72152,7 @@ Read immutable configuration versions in one environment with settings or manage
71711
72152
  openWorldHint: false,
71712
72153
  readOnlyHint: true
71713
72154
  },
71714
- args: args98,
72155
+ args: args100,
71715
72156
  tool: async (client, args, ctx) => {
71716
72157
  const [result] = await settingsListHistory(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
71717
72158
  if (!result.ok) {
@@ -71890,9 +72331,9 @@ var init_previewpolicyop = __esm(() => {
71890
72331
 
71891
72332
  // src/funcs/settingsPreview.ts
71892
72333
  function settingsPreview(client$, request, options) {
71893
- return new APIPromise($do99(client$, request, options));
72334
+ return new APIPromise($do101(client$, request, options));
71894
72335
  }
71895
- async function $do99(client$, request, options) {
72336
+ async function $do101(client$, request, options) {
71896
72337
  const parsed$ = safeParse2(request, (value$) => PreviewPolicyRequest$zodSchema.parse(value$), "Input validation failed");
71897
72338
  if (!parsed$.ok) {
71898
72339
  return [parsed$, { status: "invalid" }];
@@ -71979,12 +72420,12 @@ var init_settingsPreview = __esm(() => {
71979
72420
  });
71980
72421
 
71981
72422
  // src/mcp-server/tools/settingsPreview.ts
71982
- var args99, tool$settingsPreview;
72423
+ var args101, tool$settingsPreview;
71983
72424
  var init_settingsPreview2 = __esm(() => {
71984
72425
  init_settingsPreview();
71985
72426
  init_previewpolicyop();
71986
72427
  init_tools();
71987
- args99 = {
72428
+ args101 = {
71988
72429
  request: PreviewPolicyRequest$zodSchema
71989
72430
  };
71990
72431
  tool$settingsPreview = {
@@ -71999,7 +72440,7 @@ Compare proposed policy with bounded retained first answers, including baseline,
71999
72440
  openWorldHint: false,
72000
72441
  readOnlyHint: true
72001
72442
  },
72002
- args: args99,
72443
+ args: args101,
72003
72444
  tool: async (client, args, ctx) => {
72004
72445
  const [result] = await settingsPreview(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
72005
72446
  if (!result.ok) {
@@ -72067,9 +72508,9 @@ var init_restorepolicyop = __esm(() => {
72067
72508
 
72068
72509
  // src/funcs/settingsRestore.ts
72069
72510
  function settingsRestore(client$, request, options) {
72070
- return new APIPromise($do100(client$, request, options));
72511
+ return new APIPromise($do102(client$, request, options));
72071
72512
  }
72072
- async function $do100(client$, request, options) {
72513
+ async function $do102(client$, request, options) {
72073
72514
  const parsed$ = safeParse2(request, (value$) => RestorePolicyRequest$zodSchema.parse(value$), "Input validation failed");
72074
72515
  if (!parsed$.ok) {
72075
72516
  return [parsed$, { status: "invalid" }];
@@ -72143,12 +72584,12 @@ var init_settingsRestore = __esm(() => {
72143
72584
  });
72144
72585
 
72145
72586
  // src/mcp-server/tools/settingsRestore.ts
72146
- var args100, tool$settingsRestore;
72587
+ var args102, tool$settingsRestore;
72147
72588
  var init_settingsRestore2 = __esm(() => {
72148
72589
  init_settingsRestore();
72149
72590
  init_restorepolicyop();
72150
72591
  init_tools();
72151
- args100 = {
72592
+ args102 = {
72152
72593
  request: RestorePolicyRequest$zodSchema
72153
72594
  };
72154
72595
  tool$settingsRestore = {
@@ -72163,7 +72604,7 @@ Restore a retained configuration as a fresh version with the expected current ve
72163
72604
  openWorldHint: false,
72164
72605
  readOnlyHint: false
72165
72606
  },
72166
- args: args100,
72607
+ args: args102,
72167
72608
  tool: async (client, args, ctx) => {
72168
72609
  const [result] = await settingsRestore(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
72169
72610
  if (!result.ok) {
@@ -72269,9 +72710,9 @@ var init_updatesettingsop = __esm(() => {
72269
72710
 
72270
72711
  // src/funcs/settingsUpdate.ts
72271
72712
  function settingsUpdate(client$, request, options) {
72272
- return new APIPromise($do101(client$, request, options));
72713
+ return new APIPromise($do103(client$, request, options));
72273
72714
  }
72274
- async function $do101(client$, request, options) {
72715
+ async function $do103(client$, request, options) {
72275
72716
  const parsed$ = safeParse2(request, (value$) => UpdateSettingsRequest$zodSchema.parse(value$), "Input validation failed");
72276
72717
  if (!parsed$.ok) {
72277
72718
  return [parsed$, { status: "invalid" }];
@@ -72358,12 +72799,12 @@ var init_settingsUpdate = __esm(() => {
72358
72799
  });
72359
72800
 
72360
72801
  // src/mcp-server/tools/settingsUpdate.ts
72361
- var args101, tool$settingsUpdate;
72802
+ var args103, tool$settingsUpdate;
72362
72803
  var init_settingsUpdate2 = __esm(() => {
72363
72804
  init_settingsUpdate();
72364
72805
  init_updatesettingsop();
72365
72806
  init_tools();
72366
- args101 = {
72807
+ args103 = {
72367
72808
  request: UpdateSettingsRequest$zodSchema
72368
72809
  };
72369
72810
  tool$settingsUpdate = {
@@ -72378,7 +72819,7 @@ Change named retention, screening cap, source or flow settings in one transactio
72378
72819
  openWorldHint: false,
72379
72820
  readOnlyHint: false
72380
72821
  },
72381
- args: args101,
72822
+ args: args103,
72382
72823
  tool: async (client, args, ctx) => {
72383
72824
  const [result] = await settingsUpdate(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
72384
72825
  if (!result.ok) {
@@ -72500,9 +72941,9 @@ var init_getusageop = __esm(() => {
72500
72941
 
72501
72942
  // src/funcs/usageGet.ts
72502
72943
  function usageGet(client$, request, options) {
72503
- return new APIPromise($do102(client$, request, options));
72944
+ return new APIPromise($do104(client$, request, options));
72504
72945
  }
72505
- async function $do102(client$, request, options) {
72946
+ async function $do104(client$, request, options) {
72506
72947
  const parsed$ = safeParse2(request, (value$) => GetUsageRequest$zodSchema.parse(value$), "Input validation failed");
72507
72948
  if (!parsed$.ok) {
72508
72949
  return [parsed$, { status: "invalid" }];
@@ -72589,12 +73030,12 @@ var init_usageGet = __esm(() => {
72589
73030
  });
72590
73031
 
72591
73032
  // src/mcp-server/tools/usageGet.ts
72592
- var args102, tool$usageGet;
73033
+ var args104, tool$usageGet;
72593
73034
  var init_usageGet2 = __esm(() => {
72594
73035
  init_usageGet();
72595
73036
  init_getusageop();
72596
73037
  init_tools();
72597
- args102 = {
73038
+ args104 = {
72598
73039
  request: GetUsageRequest$zodSchema
72599
73040
  };
72600
73041
  tool$usageGet = {
@@ -72609,7 +73050,7 @@ Read daily usage units, screenings included, for the environments you can access
72609
73050
  openWorldHint: false,
72610
73051
  readOnlyHint: true
72611
73052
  },
72612
- args: args102,
73053
+ args: args104,
72613
73054
  tool: async (client, args, ctx) => {
72614
73055
  const [result] = await usageGet(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
72615
73056
  if (!result.ok) {
@@ -72639,9 +73080,9 @@ var init_webhookaggregaterequest = __esm(() => {
72639
73080
 
72640
73081
  // src/funcs/webhookEndpointsAggregate.ts
72641
73082
  function webhookEndpointsAggregate(client$, request, options) {
72642
- return new APIPromise($do103(client$, request, options));
73083
+ return new APIPromise($do105(client$, request, options));
72643
73084
  }
72644
- async function $do103(client$, request, options) {
73085
+ async function $do105(client$, request, options) {
72645
73086
  const parsed$ = safeParse2(request, (value$) => WebhookAggregateRequest$zodSchema.parse(value$), "Input validation failed");
72646
73087
  if (!parsed$.ok) {
72647
73088
  return [parsed$, { status: "invalid" }];
@@ -72718,12 +73159,12 @@ var init_webhookEndpointsAggregate = __esm(() => {
72718
73159
  });
72719
73160
 
72720
73161
  // src/mcp-server/tools/webhookEndpointsAggregate.ts
72721
- var args103, tool$webhookEndpointsAggregate;
73162
+ var args105, tool$webhookEndpointsAggregate;
72722
73163
  var init_webhookEndpointsAggregate2 = __esm(() => {
72723
73164
  init_webhookEndpointsAggregate();
72724
73165
  init_webhookaggregaterequest();
72725
73166
  init_tools();
72726
- args103 = {
73167
+ args105 = {
72727
73168
  request: WebhookAggregateRequest$zodSchema
72728
73169
  };
72729
73170
  tool$webhookEndpointsAggregate = {
@@ -72738,7 +73179,7 @@ Count retained webhook delivery attempts within thirty days and report current r
72738
73179
  openWorldHint: false,
72739
73180
  readOnlyHint: true
72740
73181
  },
72741
- args: args103,
73182
+ args: args105,
72742
73183
  tool: async (client, args, ctx) => {
72743
73184
  const [result] = await webhookEndpointsAggregate(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
72744
73185
  if (!result.ok) {
@@ -72765,9 +73206,9 @@ var init_webhookendpointrequest = __esm(() => {
72765
73206
 
72766
73207
  // src/funcs/webhookEndpointsCreate.ts
72767
73208
  function webhookEndpointsCreate(client$, request, options) {
72768
- return new APIPromise($do104(client$, request, options));
73209
+ return new APIPromise($do106(client$, request, options));
72769
73210
  }
72770
- async function $do104(client$, request, options) {
73211
+ async function $do106(client$, request, options) {
72771
73212
  const parsed$ = safeParse2(request, (value$) => WebhookEndpointRequest$zodSchema.parse(value$), "Input validation failed");
72772
73213
  if (!parsed$.ok) {
72773
73214
  return [parsed$, { status: "invalid" }];
@@ -72831,12 +73272,12 @@ var init_webhookEndpointsCreate = __esm(() => {
72831
73272
  });
72832
73273
 
72833
73274
  // src/mcp-server/tools/webhookEndpointsCreate.ts
72834
- var args104, tool$webhookEndpointsCreate;
73275
+ var args106, tool$webhookEndpointsCreate;
72835
73276
  var init_webhookEndpointsCreate2 = __esm(() => {
72836
73277
  init_webhookEndpointsCreate();
72837
73278
  init_webhookendpointrequest();
72838
73279
  init_tools();
72839
- args104 = {
73280
+ args106 = {
72840
73281
  request: WebhookEndpointRequest$zodSchema
72841
73282
  };
72842
73283
  tool$webhookEndpointsCreate = {
@@ -72851,7 +73292,7 @@ Registers a webhook endpoint and returns it with its first signing secret, shown
72851
73292
  openWorldHint: false,
72852
73293
  readOnlyHint: false
72853
73294
  },
72854
- args: args104,
73295
+ args: args106,
72855
73296
  tool: async (client, args, ctx) => {
72856
73297
  const [result] = await webhookEndpointsCreate(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
72857
73298
  if (!result.ok) {
@@ -72901,9 +73342,9 @@ var init_deletewebhookendpointop = __esm(() => {
72901
73342
 
72902
73343
  // src/funcs/webhookEndpointsDelete.ts
72903
73344
  function webhookEndpointsDelete(client$, request, options) {
72904
- return new APIPromise($do105(client$, request, options));
73345
+ return new APIPromise($do107(client$, request, options));
72905
73346
  }
72906
- async function $do105(client$, request, options) {
73347
+ async function $do107(client$, request, options) {
72907
73348
  const parsed$ = safeParse2(request, (value$) => DeleteWebhookEndpointRequest$zodSchema.parse(value$), "Input validation failed");
72908
73349
  if (!parsed$.ok) {
72909
73350
  return [parsed$, { status: "invalid" }];
@@ -72985,12 +73426,12 @@ var init_webhookEndpointsDelete = __esm(() => {
72985
73426
  });
72986
73427
 
72987
73428
  // src/mcp-server/tools/webhookEndpointsDelete.ts
72988
- var args105, tool$webhookEndpointsDelete;
73429
+ var args107, tool$webhookEndpointsDelete;
72989
73430
  var init_webhookEndpointsDelete2 = __esm(() => {
72990
73431
  init_webhookEndpointsDelete();
72991
73432
  init_deletewebhookendpointop();
72992
73433
  init_tools();
72993
- args105 = {
73434
+ args107 = {
72994
73435
  request: DeleteWebhookEndpointRequest$zodSchema
72995
73436
  };
72996
73437
  tool$webhookEndpointsDelete = {
@@ -73005,7 +73446,7 @@ Deletes the endpoint and its signing keys. Deliveries still queued for it are dr
73005
73446
  openWorldHint: false,
73006
73447
  readOnlyHint: false
73007
73448
  },
73008
- args: args105,
73449
+ args: args107,
73009
73450
  tool: async (client, args, ctx) => {
73010
73451
  const [result] = await webhookEndpointsDelete(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
73011
73452
  if (!result.ok) {
@@ -73021,9 +73462,9 @@ Deletes the endpoint and its signing keys. Deliveries still queued for it are dr
73021
73462
 
73022
73463
  // src/funcs/webhookEndpointsList.ts
73023
73464
  function webhookEndpointsList(client$, options) {
73024
- return new APIPromise($do106(client$, options));
73465
+ return new APIPromise($do108(client$, options));
73025
73466
  }
73026
- async function $do106(client$, options) {
73467
+ async function $do108(client$, options) {
73027
73468
  const path$ = pathToFunc("/v1/webhooks")();
73028
73469
  const headers$ = new Headers(compactMap({
73029
73470
  Accept: options?.acceptHeaderOverride || "application/json;q=1, application/problem+json;q=0"
@@ -73217,9 +73658,9 @@ var init_listwebhookdeliveriesop = __esm(() => {
73217
73658
 
73218
73659
  // src/funcs/webhookEndpointsListDeliveries.ts
73219
73660
  function webhookEndpointsListDeliveries(client$, request, options) {
73220
- return new APIPromise($do107(client$, request, options));
73661
+ return new APIPromise($do109(client$, request, options));
73221
73662
  }
73222
- async function $do107(client$, request, options) {
73663
+ async function $do109(client$, request, options) {
73223
73664
  const parsed$ = safeParse2(request, (value$) => ListWebhookDeliveriesRequest$zodSchema.parse(value$), "Input validation failed");
73224
73665
  if (!parsed$.ok) {
73225
73666
  return [parsed$, { status: "invalid" }];
@@ -73306,12 +73747,12 @@ var init_webhookEndpointsListDeliveries = __esm(() => {
73306
73747
  });
73307
73748
 
73308
73749
  // src/mcp-server/tools/webhookEndpointsListDeliveries.ts
73309
- var args106, tool$webhookEndpointsListDeliveries;
73750
+ var args108, tool$webhookEndpointsListDeliveries;
73310
73751
  var init_webhookEndpointsListDeliveries2 = __esm(() => {
73311
73752
  init_webhookEndpointsListDeliveries();
73312
73753
  init_listwebhookdeliveriesop();
73313
73754
  init_tools();
73314
- args106 = {
73755
+ args108 = {
73315
73756
  request: ListWebhookDeliveriesRequest$zodSchema
73316
73757
  };
73317
73758
  tool$webhookEndpointsListDeliveries = {
@@ -73326,7 +73767,7 @@ Every POST the endpoint received, newest first: the event id and type, which att
73326
73767
  openWorldHint: false,
73327
73768
  readOnlyHint: true
73328
73769
  },
73329
- args: args106,
73770
+ args: args108,
73330
73771
  tool: async (client, args, ctx) => {
73331
73772
  const [result] = await webhookEndpointsListDeliveries(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
73332
73773
  if (!result.ok) {
@@ -73400,9 +73841,9 @@ var init_replaywebhookdeliveryop = __esm(() => {
73400
73841
 
73401
73842
  // src/funcs/webhookEndpointsReplayDelivery.ts
73402
73843
  function webhookEndpointsReplayDelivery(client$, request, options) {
73403
- return new APIPromise($do108(client$, request, options));
73844
+ return new APIPromise($do110(client$, request, options));
73404
73845
  }
73405
- async function $do108(client$, request, options) {
73846
+ async function $do110(client$, request, options) {
73406
73847
  const parsed$ = safeParse2(request, (value$) => ReplayWebhookDeliveryRequest$zodSchema.parse(value$), "Input validation failed");
73407
73848
  if (!parsed$.ok) {
73408
73849
  return [parsed$, { status: "invalid" }];
@@ -73476,12 +73917,12 @@ var init_webhookEndpointsReplayDelivery = __esm(() => {
73476
73917
  });
73477
73918
 
73478
73919
  // src/mcp-server/tools/webhookEndpointsReplayDelivery.ts
73479
- var args107, tool$webhookEndpointsReplayDelivery;
73920
+ var args109, tool$webhookEndpointsReplayDelivery;
73480
73921
  var init_webhookEndpointsReplayDelivery2 = __esm(() => {
73481
73922
  init_webhookEndpointsReplayDelivery();
73482
73923
  init_replaywebhookdeliveryop();
73483
73924
  init_tools();
73484
- args107 = {
73925
+ args109 = {
73485
73926
  request: ReplayWebhookDeliveryRequest$zodSchema
73486
73927
  };
73487
73928
  tool$webhookEndpointsReplayDelivery = {
@@ -73496,7 +73937,7 @@ Queues the event for the endpoint again: the same event id and body it received,
73496
73937
  openWorldHint: false,
73497
73938
  readOnlyHint: false
73498
73939
  },
73499
- args: args107,
73940
+ args: args109,
73500
73941
  tool: async (client, args, ctx) => {
73501
73942
  const [result] = await webhookEndpointsReplayDelivery(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
73502
73943
  if (!result.ok) {
@@ -73582,9 +74023,9 @@ var init_rotatewebhooksigningkeyop = __esm(() => {
73582
74023
 
73583
74024
  // src/funcs/webhookEndpointsRotateSigningKey.ts
73584
74025
  function webhookEndpointsRotateSigningKey(client$, request, options) {
73585
- return new APIPromise($do109(client$, request, options));
74026
+ return new APIPromise($do111(client$, request, options));
73586
74027
  }
73587
- async function $do109(client$, request, options) {
74028
+ async function $do111(client$, request, options) {
73588
74029
  const parsed$ = safeParse2(request, (value$) => RotateWebhookSigningKeyRequest$zodSchema.parse(value$), "Input validation failed");
73589
74030
  if (!parsed$.ok) {
73590
74031
  return [parsed$, { status: "invalid" }];
@@ -73654,12 +74095,12 @@ var init_webhookEndpointsRotateSigningKey = __esm(() => {
73654
74095
  });
73655
74096
 
73656
74097
  // src/mcp-server/tools/webhookEndpointsRotateSigningKey.ts
73657
- var args108, tool$webhookEndpointsRotateSigningKey;
74098
+ var args110, tool$webhookEndpointsRotateSigningKey;
73658
74099
  var init_webhookEndpointsRotateSigningKey2 = __esm(() => {
73659
74100
  init_webhookEndpointsRotateSigningKey();
73660
74101
  init_rotatewebhooksigningkeyop();
73661
74102
  init_tools();
73662
- args108 = {
74103
+ args110 = {
73663
74104
  request: RotateWebhookSigningKeyRequest$zodSchema
73664
74105
  };
73665
74106
  tool$webhookEndpointsRotateSigningKey = {
@@ -73674,7 +74115,7 @@ Issues a new signing key for the endpoint and returns its secret once. Every del
73674
74115
  openWorldHint: false,
73675
74116
  readOnlyHint: false
73676
74117
  },
73677
- args: args108,
74118
+ args: args110,
73678
74119
  tool: async (client, args, ctx) => {
73679
74120
  const [result] = await webhookEndpointsRotateSigningKey(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
73680
74121
  if (!result.ok) {
@@ -73764,9 +74205,9 @@ var init_sendwebhooktesteventop = __esm(() => {
73764
74205
 
73765
74206
  // src/funcs/webhookEndpointsSendTestEvent.ts
73766
74207
  function webhookEndpointsSendTestEvent(client$, request, options) {
73767
- return new APIPromise($do110(client$, request, options));
74208
+ return new APIPromise($do112(client$, request, options));
73768
74209
  }
73769
- async function $do110(client$, request, options) {
74210
+ async function $do112(client$, request, options) {
73770
74211
  const parsed$ = safeParse2(request, (value$) => SendWebhookTestEventRequest$zodSchema.parse(value$), "Input validation failed");
73771
74212
  if (!parsed$.ok) {
73772
74213
  return [parsed$, { status: "invalid" }];
@@ -73836,12 +74277,12 @@ var init_webhookEndpointsSendTestEvent = __esm(() => {
73836
74277
  });
73837
74278
 
73838
74279
  // src/mcp-server/tools/webhookEndpointsSendTestEvent.ts
73839
- var args109, tool$webhookEndpointsSendTestEvent;
74280
+ var args111, tool$webhookEndpointsSendTestEvent;
73840
74281
  var init_webhookEndpointsSendTestEvent2 = __esm(() => {
73841
74282
  init_webhookEndpointsSendTestEvent();
73842
74283
  init_sendwebhooktesteventop();
73843
74284
  init_tools();
73844
- args109 = {
74285
+ args111 = {
73845
74286
  request: SendWebhookTestEventRequest$zodSchema
73846
74287
  };
73847
74288
  tool$webhookEndpointsSendTestEvent = {
@@ -73856,7 +74297,7 @@ endpoint.verification sends a signed challenge now and answers whether the endpo
73856
74297
  openWorldHint: false,
73857
74298
  readOnlyHint: false
73858
74299
  },
73859
- args: args109,
74300
+ args: args111,
73860
74301
  tool: async (client, args, ctx) => {
73861
74302
  const [result] = await webhookEndpointsSendTestEvent(client, args.request, { fetchOptions: { signal: ctx.mcpReq.signal } }).$inspect();
73862
74303
  if (!result.ok) {
@@ -73874,7 +74315,7 @@ endpoint.verification sends a signed challenge now and answers whether the endpo
73874
74315
  function createMCPServer(deps) {
73875
74316
  const server = new McpServer({
73876
74317
  name: "NoResponse",
73877
- version: "0.13.7"
74318
+ version: "0.13.8"
73878
74319
  });
73879
74320
  const getClient = deps.getSDK || (() => new NoResponseCore({
73880
74321
  security: deps.security,
@@ -73999,6 +74440,8 @@ function createMCPServer(deps) {
73999
74440
  tool(tool$groupsGetPerson);
74000
74441
  tool(tool$groupsReviewPerson);
74001
74442
  tool(tool$groupsJudgeRecord);
74443
+ tool(tool$groupsStartSearch);
74444
+ tool(tool$groupsRunSearch);
74002
74445
  tool(tool$groupsListScreenings);
74003
74446
  tool(tool$groupsStartScreening);
74004
74447
  tool(tool$groupsGetScreening);
@@ -74073,7 +74516,9 @@ var init_server = __esm(() => {
74073
74516
  init_groupsListPeople2();
74074
74517
  init_groupsListScreenings2();
74075
74518
  init_groupsReviewPerson2();
74519
+ init_groupsRunSearch2();
74076
74520
  init_groupsStartScreening2();
74521
+ init_groupsStartSearch2();
74077
74522
  init_groupsUpdate2();
74078
74523
  init_integrationsCreate2();
74079
74524
  init_integrationsDelete2();
@@ -74767,6 +75212,18 @@ Record a cleared, watch or escalated decision with a note. The latest decision i
74767
75212
  description: `Join one of a person's records to them, or reject it.
74768
75213
 
74769
75214
  Join one of a person's lookup records to them whatever its likelihood, or reject it so it stays a lead. The verdict sticks while lookups find the same record.`
75215
+ },
75216
+ {
75217
+ name: "start_search",
75218
+ description: `Search again on a value of one of a person's records.
75219
+
75220
+ Search again on the value of one field of one of a person's records, named by the record and field. Nothing searches again by itself. A password or hash search counts its breach rows first and runs only when you run it; read the person to see each search and what it found.`
75221
+ },
75222
+ {
75223
+ name: "run_search",
75224
+ description: `Run a counted password or hash search.
75225
+
75226
+ Run a counted password or hash search once you have seen how many breach rows hold the value.`
74770
75227
  },
74771
75228
  {
74772
75229
  name: "list_screenings",
@@ -83291,7 +83748,7 @@ var routes = buildRouteMap({
83291
83748
  var app = buildApplication(routes, {
83292
83749
  name: "mcp",
83293
83750
  versionInfo: {
83294
- currentVersion: "0.13.7"
83751
+ currentVersion: "0.13.8"
83295
83752
  }
83296
83753
  });
83297
83754
  run(app, process3.argv.slice(2), buildContext(process3));
@@ -83299,5 +83756,5 @@ export {
83299
83756
  app
83300
83757
  };
83301
83758
 
83302
- //# debugId=798F3F99D6878D0A64756E2164756E21
83759
+ //# debugId=688FF41CFF1E753D64756E2164756E21
83303
83760
  //# sourceMappingURL=mcp-server.js.map