syllable-sdk 1.0.7-rc.4 → 1.0.7-rc.5

package/bin/mcp-server.js

@@ -34419,9 +34419,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "0.0.2",
-    sdkVersion: "1.0.7-rc.4",
+    sdkVersion: "1.0.7-rc.5",
     genVersion: "2.731.4",
-    userAgent: "speakeasy-sdk/typescript 1.0.7-rc.4 2.731.4 0.0.2 syllable-sdk"
+    userAgent: "speakeasy-sdk/typescript 1.0.7-rc.5 2.731.4 0.0.2 syllable-sdk"
   };
 });
 
@@ -39416,6 +39416,22 @@ var init_directorymemberproperties = __esm(() => {
   })(DirectoryMemberProperties$ ||= {});
 });
 
+// src/models/components/directorymembertestresponse.ts
+var DirectoryMemberTestResponse$inboundSchema, DirectoryMemberTestResponse$outboundSchema, DirectoryMemberTestResponse$;
+var init_directorymembertestresponse = __esm(() => {
+  init_v3();
+  DirectoryMemberTestResponse$inboundSchema = objectType({
+    extension: nullableType(stringType()).optional()
+  });
+  DirectoryMemberTestResponse$outboundSchema = objectType({
+    extension: nullableType(stringType()).optional()
+  });
+  ((DirectoryMemberTestResponse$) => {
+    DirectoryMemberTestResponse$.inboundSchema = DirectoryMemberTestResponse$inboundSchema;
+    DirectoryMemberTestResponse$.outboundSchema = DirectoryMemberTestResponse$outboundSchema;
+  })(DirectoryMemberTestResponse$ ||= {});
+});
+
 // src/models/components/event.ts
 var Attributes$inboundSchema, Attributes$outboundSchema, Attributes$, Event$inboundSchema, Event$outboundSchema, Event$;
 var init_event = __esm(() => {
@@ -44534,6 +44550,7 @@ var init_components = __esm(() => {
   init_directorymember();
   init_directorymembercreate();
   init_directorymemberproperties();
+  init_directorymembertestresponse();
   init_event();
   init_eventproperties();
   init_folderdetails();
@@ -45817,6 +45834,38 @@ var init_directorymemberlist = __esm(() => {
   })(DirectoryMemberListRequest$ ||= {});
 });
 
+// src/models/operations/directorymembertestextension.ts
+var DirectoryMemberTestExtensionRequest$inboundSchema, DirectoryMemberTestExtensionRequest$outboundSchema, DirectoryMemberTestExtensionRequest$;
+var init_directorymembertestextension = __esm(() => {
+  init_v3();
+  init_primitives();
+  init_components();
+  DirectoryMemberTestExtensionRequest$inboundSchema = objectType({
+    member_id: numberType().int(),
+    timestamp: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
+    language_code: nullableType(LanguageCode$inboundSchema).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      member_id: "memberId",
+      language_code: "languageCode"
+    });
+  });
+  DirectoryMemberTestExtensionRequest$outboundSchema = objectType({
+    memberId: numberType().int(),
+    timestamp: dateType().transform((v2) => v2.toISOString()),
+    languageCode: nullableType(LanguageCode$outboundSchema).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      memberId: "member_id",
+      languageCode: "language_code"
+    });
+  });
+  ((DirectoryMemberTestExtensionRequest$) => {
+    DirectoryMemberTestExtensionRequest$.inboundSchema = DirectoryMemberTestExtensionRequest$inboundSchema;
+    DirectoryMemberTestExtensionRequest$.outboundSchema = DirectoryMemberTestExtensionRequest$outboundSchema;
+  })(DirectoryMemberTestExtensionRequest$ ||= {});
+});
+
 // src/models/operations/directorymemberupdate.ts
 var DirectoryMemberUpdateRequest$inboundSchema, DirectoryMemberUpdateRequest$outboundSchema, DirectoryMemberUpdateRequest$;
 var init_directorymemberupdate = __esm(() => {
@@ -48337,6 +48386,7 @@ var init_operations = __esm(() => {
   init_directorymemberdelete();
   init_directorymembergetbyid();
   init_directorymemberlist();
+  init_directorymembertestextension();
   init_directorymemberupdate();
   init_eventslist();
   init_generatesessionrecordingurls();
@@ -52842,11 +52892,125 @@ Download the entire directory as a JSON file.`,
   };
 });
 
-// src/funcs/directoryGetById.ts
-function directoryGetById(client, request, options) {
+// src/funcs/directoryDirectoryMemberTestExtension.ts
+function directoryDirectoryMemberTestExtension(client, request, options) {
   return new APIPromise($do44(client, request, options));
 }
 async function $do44(client, request, options) {
+  const parsed = safeParse(request, (value) => DirectoryMemberTestExtensionRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    member_id: encodeSimple("member_id", payload.member_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/api/v1/directory_members/{member_id}/test")(pathParams);
+  const query = encodeFormQuery({
+    language_code: payload.language_code,
+    timestamp: payload.timestamp
+  });
+  const headers = new Headers(compactMap({
+    Accept: "application/json"
+  }));
+  const secConfig = await extractSecurity(client._options.apiKeyHeader);
+  const securityInput = secConfig == null ? {} : { apiKeyHeader: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "directory_member_test_extension",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.apiKeyHeader,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["422", "4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, DirectoryMemberTestResponse$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_directoryDirectoryMemberTestExtension = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors2();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/directoryDirectoryMemberTestExtension.ts
+var args38, tool$directoryDirectoryMemberTestExtension;
+var init_directoryDirectoryMemberTestExtension2 = __esm(() => {
+  init_directoryDirectoryMemberTestExtension();
+  init_operations();
+  init_tools();
+  args38 = {
+    request: DirectoryMemberTestExtensionRequest$inboundSchema
+  };
+  tool$directoryDirectoryMemberTestExtension = {
+    name: "directory-directory-member-test-extension",
+    description: `Test Directory Member Extension
+
+Test directory member extension at a specific timestamp and language.`,
+    args: args38,
+    tool: async (client, args39, ctx) => {
+      const [result, apiCall] = await directoryDirectoryMemberTestExtension(client, args39.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/directoryGetById.ts
+function directoryGetById(client, request, options) {
+  return new APIPromise($do45(client, request, options));
+}
+async function $do45(client, request, options) {
   const parsed = safeParse(request, (value) => DirectoryMemberGetByIdRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -52923,12 +53087,12 @@ var init_directoryGetById = __esm(() => {
 });
 
 // src/mcp-server/tools/directoryGetById.ts
-var args38, tool$directoryGetById;
+var args39, tool$directoryGetById;
 var init_directoryGetById2 = __esm(() => {
   init_directoryGetById();
   init_operations();
   init_tools();
-  args38 = {
+  args39 = {
     request: DirectoryMemberGetByIdRequest$inboundSchema
   };
   tool$directoryGetById = {
@@ -52936,9 +53100,9 @@ var init_directoryGetById2 = __esm(() => {
     description: `Get Directory Member By Id
 
 Get a DirectoryMember by ID.`,
-    args: args38,
-    tool: async (client, args39, ctx) => {
-      const [result, apiCall] = await directoryGetById(client, args39.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args39,
+    tool: async (client, args40, ctx) => {
+      const [result, apiCall] = await directoryGetById(client, args40.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -52953,9 +53117,9 @@ Get a DirectoryMember by ID.`,
 
 // src/funcs/directoryList.ts
 function directoryList(client, request, options) {
-  return new APIPromise($do45(client, request, options));
+  return new APIPromise($do46(client, request, options));
 }
-async function $do45(client, request, options) {
+async function $do46(client, request, options) {
   const parsed = safeParse(request, (value) => DirectoryMemberListRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -53038,12 +53202,12 @@ var init_directoryList = __esm(() => {
 });
 
 // src/mcp-server/tools/directoryList.ts
-var args39, tool$directoryList;
+var args40, tool$directoryList;
 var init_directoryList2 = __esm(() => {
   init_directoryList();
   init_operations();
   init_tools();
-  args39 = {
+  args40 = {
     request: DirectoryMemberListRequest$inboundSchema
   };
   tool$directoryList = {
@@ -53051,9 +53215,9 @@ var init_directoryList2 = __esm(() => {
     description: `Directory Member List
 
 List the existing directory_members`,
-    args: args39,
-    tool: async (client, args40, ctx) => {
-      const [result, apiCall] = await directoryList(client, args40.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args40,
+    tool: async (client, args41, ctx) => {
+      const [result, apiCall] = await directoryList(client, args41.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -53068,9 +53232,9 @@ List the existing directory_members`,
 
 // src/funcs/directoryUpdate.ts
 function directoryUpdate(client, request, options) {
-  return new APIPromise($do46(client, request, options));
+  return new APIPromise($do47(client, request, options));
 }
-async function $do46(client, request, options) {
+async function $do47(client, request, options) {
   const parsed = safeParse(request, (value) => DirectoryMemberUpdateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -53148,12 +53312,12 @@ var init_directoryUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/directoryUpdate.ts
-var args40, tool$directoryUpdate;
+var args41, tool$directoryUpdate;
 var init_directoryUpdate2 = __esm(() => {
   init_directoryUpdate();
   init_operations();
   init_tools();
-  args40 = {
+  args41 = {
     request: DirectoryMemberUpdateRequest$inboundSchema
   };
   tool$directoryUpdate = {
@@ -53161,9 +53325,9 @@ var init_directoryUpdate2 = __esm(() => {
     description: `Update Directory Member
 
 Update a DirectoryMember.`,
-    args: args40,
-    tool: async (client, args41, ctx) => {
-      const [result, apiCall] = await directoryUpdate(client, args41.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args41,
+    tool: async (client, args42, ctx) => {
+      const [result, apiCall] = await directoryUpdate(client, args42.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -53178,9 +53342,9 @@ Update a DirectoryMember.`,
 
 // src/funcs/eventsList.ts
 function eventsList(client, request, options) {
-  return new APIPromise($do47(client, request, options));
+  return new APIPromise($do48(client, request, options));
 }
-async function $do47(client, request, options) {
+async function $do48(client, request, options) {
   const parsed = safeParse(request, (value) => EventsListRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -53263,20 +53427,20 @@ var init_eventsList = __esm(() => {
 });
 
 // src/mcp-server/tools/eventsList.ts
-var args41, tool$eventsList;
+var args42, tool$eventsList;
 var init_eventsList2 = __esm(() => {
   init_eventsList();
   init_operations();
   init_tools();
-  args41 = {
+  args42 = {
     request: EventsListRequest$inboundSchema
   };
   tool$eventsList = {
     name: "events-list",
     description: `Events List`,
-    args: args41,
-    tool: async (client, args42, ctx) => {
-      const [result, apiCall] = await eventsList(client, args42.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args42,
+    tool: async (client, args43, ctx) => {
+      const [result, apiCall] = await eventsList(client, args43.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -53291,9 +53455,9 @@ var init_eventsList2 = __esm(() => {
 
 // src/funcs/incidentsCreate.ts
 function incidentsCreate(client, request, options) {
-  return new APIPromise($do48(client, request, options));
+  return new APIPromise($do49(client, request, options));
 }
-async function $do48(client, request, options) {
+async function $do49(client, request, options) {
   const parsed = safeParse(request, (value) => IncidentCreateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -53364,12 +53528,12 @@ var init_incidentsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/incidentsCreate.ts
-var args42, tool$incidentsCreate;
+var args43, tool$incidentsCreate;
 var init_incidentsCreate2 = __esm(() => {
   init_incidentsCreate();
   init_components();
   init_tools();
-  args42 = {
+  args43 = {
     request: IncidentCreateRequest$inboundSchema
   };
   tool$incidentsCreate = {
@@ -53377,9 +53541,9 @@ var init_incidentsCreate2 = __esm(() => {
     description: `Create Incident
 
 Create a new incident`,
-    args: args42,
-    tool: async (client, args43, ctx) => {
-      const [result, apiCall] = await incidentsCreate(client, args43.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args43,
+    tool: async (client, args44, ctx) => {
+      const [result, apiCall] = await incidentsCreate(client, args44.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -53394,9 +53558,9 @@ Create a new incident`,
 
 // src/funcs/incidentsDelete.ts
 function incidentsDelete(client, request, options) {
-  return new APIPromise($do49(client, request, options));
+  return new APIPromise($do50(client, request, options));
 }
-async function $do49(client, request, options) {
+async function $do50(client, request, options) {
   const parsed = safeParse(request, (value) => IncidentDeleteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -53477,12 +53641,12 @@ var init_incidentsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/incidentsDelete.ts
-var args43, tool$incidentsDelete;
+var args44, tool$incidentsDelete;
 var init_incidentsDelete2 = __esm(() => {
   init_incidentsDelete();
   init_operations();
   init_tools();
-  args43 = {
+  args44 = {
     request: IncidentDeleteRequest$inboundSchema
   };
   tool$incidentsDelete = {
@@ -53490,9 +53654,9 @@ var init_incidentsDelete2 = __esm(() => {
     description: `Delete Incident
 
 Delete an incident by ID`,
-    args: args43,
-    tool: async (client, args44, ctx) => {
-      const [result, apiCall] = await incidentsDelete(client, args44.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args44,
+    tool: async (client, args45, ctx) => {
+      const [result, apiCall] = await incidentsDelete(client, args45.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -53507,9 +53671,9 @@ Delete an incident by ID`,
 
 // src/funcs/incidentsGetById.ts
 function incidentsGetById(client, request, options) {
-  return new APIPromise($do50(client, request, options));
+  return new APIPromise($do51(client, request, options));
 }
-async function $do50(client, request, options) {
+async function $do51(client, request, options) {
   const parsed = safeParse(request, (value) => IncidentGetByIdRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -53586,12 +53750,12 @@ var init_incidentsGetById = __esm(() => {
 });
 
 // src/mcp-server/tools/incidentsGetById.ts
-var args44, tool$incidentsGetById;
+var args45, tool$incidentsGetById;
 var init_incidentsGetById2 = __esm(() => {
   init_incidentsGetById();
   init_operations();
   init_tools();
-  args44 = {
+  args45 = {
     request: IncidentGetByIdRequest$inboundSchema
   };
   tool$incidentsGetById = {
@@ -53599,9 +53763,9 @@ var init_incidentsGetById2 = __esm(() => {
     description: `Get Incident By Id
 
 Get incident by ID`,
-    args: args44,
-    tool: async (client, args45, ctx) => {
-      const [result, apiCall] = await incidentsGetById(client, args45.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args45,
+    tool: async (client, args46, ctx) => {
+      const [result, apiCall] = await incidentsGetById(client, args46.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -53616,9 +53780,9 @@ Get incident by ID`,
 
 // src/funcs/incidentsIncidentGetOrganizations.ts
 function incidentsIncidentGetOrganizations(client, options) {
-  return new APIPromise($do51(client, options));
+  return new APIPromise($do52(client, options));
 }
-async function $do51(client, options) {
+async function $do52(client, options) {
   const path = pathToFunc("/api/v1/incidents/organizations")();
   const headers = new Headers(compactMap({
     Accept: "application/json"
@@ -53701,9 +53865,9 @@ Get all organizations`,
 
 // src/funcs/incidentsList.ts
 function incidentsList(client, request, options) {
-  return new APIPromise($do52(client, request, options));
+  return new APIPromise($do53(client, request, options));
 }
-async function $do52(client, request, options) {
+async function $do53(client, request, options) {
   const parsed = safeParse(request, (value) => IncidentListRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -53786,12 +53950,12 @@ var init_incidentsList = __esm(() => {
 });
 
 // src/mcp-server/tools/incidentsList.ts
-var args45, tool$incidentsList;
+var args46, tool$incidentsList;
 var init_incidentsList2 = __esm(() => {
   init_incidentsList();
   init_operations();
   init_tools();
-  args45 = {
+  args46 = {
     request: IncidentListRequest$inboundSchema
   };
   tool$incidentsList = {
@@ -53799,9 +53963,9 @@ var init_incidentsList2 = __esm(() => {
     description: `List Incidents
 
 List service incidents with pagination and filtering`,
-    args: args45,
-    tool: async (client, args46, ctx) => {
-      const [result, apiCall] = await incidentsList(client, args46.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args46,
+    tool: async (client, args47, ctx) => {
+      const [result, apiCall] = await incidentsList(client, args47.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -53816,9 +53980,9 @@ List service incidents with pagination and filtering`,
 
 // src/funcs/incidentsUpdate.ts
 function incidentsUpdate(client, request, options) {
-  return new APIPromise($do53(client, request, options));
+  return new APIPromise($do54(client, request, options));
 }
-async function $do53(client, request, options) {
+async function $do54(client, request, options) {
   const parsed = safeParse(request, (value) => IncidentUpdateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -53889,12 +54053,12 @@ var init_incidentsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/incidentsUpdate.ts
-var args46, tool$incidentsUpdate;
+var args47, tool$incidentsUpdate;
 var init_incidentsUpdate2 = __esm(() => {
   init_incidentsUpdate();
   init_components();
   init_tools();
-  args46 = {
+  args47 = {
     request: IncidentUpdateRequest$inboundSchema
   };
   tool$incidentsUpdate = {
@@ -53902,9 +54066,9 @@ var init_incidentsUpdate2 = __esm(() => {
     description: `Update Incident
 
 Update an existing incident`,
-    args: args46,
-    tool: async (client, args47, ctx) => {
-      const [result, apiCall] = await incidentsUpdate(client, args47.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args47,
+    tool: async (client, args48, ctx) => {
+      const [result, apiCall] = await incidentsUpdate(client, args48.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -53919,9 +54083,9 @@ Update an existing incident`,
 
 // src/funcs/insightsFoldersCreate.ts
 function insightsFoldersCreate(client, request, options) {
-  return new APIPromise($do54(client, request, options));
+  return new APIPromise($do55(client, request, options));
 }
-async function $do54(client, request, options) {
+async function $do55(client, request, options) {
   const parsed = safeParse(request, (value) => InsightsFolderInput$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -53992,20 +54156,20 @@ var init_insightsFoldersCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/insightsFoldersCreate.ts
-var args47, tool$insightsFoldersCreate;
+var args48, tool$insightsFoldersCreate;
 var init_insightsFoldersCreate2 = __esm(() => {
   init_insightsFoldersCreate();
   init_components();
   init_tools();
-  args47 = {
+  args48 = {
     request: InsightsFolderInput$inboundSchema
   };
   tool$insightsFoldersCreate = {
     name: "insights-folders-create",
     description: `Create Insights Upload Folder`,
-    args: args47,
-    tool: async (client, args48, ctx) => {
-      const [result, apiCall] = await insightsFoldersCreate(client, args48.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args48,
+    tool: async (client, args49, ctx) => {
+      const [result, apiCall] = await insightsFoldersCreate(client, args49.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54020,9 +54184,9 @@ var init_insightsFoldersCreate2 = __esm(() => {
 
 // src/funcs/insightsFoldersDelete.ts
 function insightsFoldersDelete(client, request, options) {
-  return new APIPromise($do55(client, request, options));
+  return new APIPromise($do56(client, request, options));
 }
-async function $do55(client, request, options) {
+async function $do56(client, request, options) {
   const parsed = safeParse(request, (value) => InsightsFolderDeleteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -54099,20 +54263,20 @@ var init_insightsFoldersDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/insightsFoldersDelete.ts
-var args48, tool$insightsFoldersDelete;
+var args49, tool$insightsFoldersDelete;
 var init_insightsFoldersDelete2 = __esm(() => {
   init_insightsFoldersDelete();
   init_operations();
   init_tools();
-  args48 = {
+  args49 = {
     request: InsightsFolderDeleteRequest$inboundSchema
   };
   tool$insightsFoldersDelete = {
     name: "insights-folders-delete",
     description: `Delete Insights Folder`,
-    args: args48,
-    tool: async (client, args49, ctx) => {
-      const [result, apiCall] = await insightsFoldersDelete(client, args49.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args49,
+    tool: async (client, args50, ctx) => {
+      const [result, apiCall] = await insightsFoldersDelete(client, args50.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54127,9 +54291,9 @@ var init_insightsFoldersDelete2 = __esm(() => {
 
 // src/funcs/insightsFoldersGetById.ts
 function insightsFoldersGetById(client, request, options) {
-  return new APIPromise($do56(client, request, options));
+  return new APIPromise($do57(client, request, options));
 }
-async function $do56(client, request, options) {
+async function $do57(client, request, options) {
   const parsed = safeParse(request, (value) => InsightsFolderGetByIdRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -54206,20 +54370,20 @@ var init_insightsFoldersGetById = __esm(() => {
 });
 
 // src/mcp-server/tools/insightsFoldersGetById.ts
-var args49, tool$insightsFoldersGetById;
+var args50, tool$insightsFoldersGetById;
 var init_insightsFoldersGetById2 = __esm(() => {
   init_insightsFoldersGetById();
   init_operations();
   init_tools();
-  args49 = {
+  args50 = {
     request: InsightsFolderGetByIdRequest$inboundSchema
   };
   tool$insightsFoldersGetById = {
     name: "insights-folders-get-by-id",
     description: `Get Insights Folder Details`,
-    args: args49,
-    tool: async (client, args50, ctx) => {
-      const [result, apiCall] = await insightsFoldersGetById(client, args50.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args50,
+    tool: async (client, args51, ctx) => {
+      const [result, apiCall] = await insightsFoldersGetById(client, args51.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54234,9 +54398,9 @@ var init_insightsFoldersGetById2 = __esm(() => {
 
 // src/funcs/insightsFoldersList.ts
 function insightsFoldersList(client, request, options) {
-  return new APIPromise($do57(client, request, options));
+  return new APIPromise($do58(client, request, options));
 }
-async function $do57(client, request, options) {
+async function $do58(client, request, options) {
   const parsed = safeParse(request, (value) => InsightsFolderListRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -54319,20 +54483,20 @@ var init_insightsFoldersList = __esm(() => {
 });
 
 // src/mcp-server/tools/insightsFoldersList.ts
-var args50, tool$insightsFoldersList;
+var args51, tool$insightsFoldersList;
 var init_insightsFoldersList2 = __esm(() => {
   init_insightsFoldersList();
   init_operations();
   init_tools();
-  args50 = {
+  args51 = {
     request: InsightsFolderListRequest$inboundSchema
   };
   tool$insightsFoldersList = {
     name: "insights-folders-list",
     description: `List Insights Upload Folders`,
-    args: args50,
-    tool: async (client, args51, ctx) => {
-      const [result, apiCall] = await insightsFoldersList(client, args51.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args51,
+    tool: async (client, args52, ctx) => {
+      const [result, apiCall] = await insightsFoldersList(client, args52.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54347,9 +54511,9 @@ var init_insightsFoldersList2 = __esm(() => {
 
 // src/funcs/insightsFoldersListFiles.ts
 function insightsFoldersListFiles(client, request, options) {
-  return new APIPromise($do58(client, request, options));
+  return new APIPromise($do59(client, request, options));
 }
-async function $do58(client, request, options) {
+async function $do59(client, request, options) {
   const parsed = safeParse(request, (value) => InsightsUploadListFilesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -54438,20 +54602,20 @@ var init_insightsFoldersListFiles = __esm(() => {
 });
 
 // src/mcp-server/tools/insightsFoldersListFiles.ts
-var args51, tool$insightsFoldersListFiles;
+var args52, tool$insightsFoldersListFiles;
 var init_insightsFoldersListFiles2 = __esm(() => {
   init_insightsFoldersListFiles();
   init_operations();
   init_tools();
-  args51 = {
+  args52 = {
     request: InsightsUploadListFilesRequest$inboundSchema
   };
   tool$insightsFoldersListFiles = {
     name: "insights-folders-list-files",
     description: `Fetch Insights Upload Files`,
-    args: args51,
-    tool: async (client, args52, ctx) => {
-      const [result, apiCall] = await insightsFoldersListFiles(client, args52.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args52,
+    tool: async (client, args53, ctx) => {
+      const [result, apiCall] = await insightsFoldersListFiles(client, args53.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54466,9 +54630,9 @@ var init_insightsFoldersListFiles2 = __esm(() => {
 
 // src/funcs/insightsFoldersMoveFiles.ts
 function insightsFoldersMoveFiles(client, request, options) {
-  return new APIPromise($do59(client, request, options));
+  return new APIPromise($do60(client, request, options));
 }
-async function $do59(client, request, options) {
+async function $do60(client, request, options) {
   const parsed = safeParse(request, (value) => InsightsUploadMoveFilesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -54549,20 +54713,20 @@ var init_insightsFoldersMoveFiles = __esm(() => {
 });
 
 // src/mcp-server/tools/insightsFoldersMoveFiles.ts
-var args52, tool$insightsFoldersMoveFiles;
+var args53, tool$insightsFoldersMoveFiles;
 var init_insightsFoldersMoveFiles2 = __esm(() => {
   init_insightsFoldersMoveFiles();
   init_operations();
   init_tools();
-  args52 = {
+  args53 = {
     request: InsightsUploadMoveFilesRequest$inboundSchema
   };
   tool$insightsFoldersMoveFiles = {
     name: "insights-folders-move-files",
     description: `Move Insights Upload Files`,
-    args: args52,
-    tool: async (client, args53, ctx) => {
-      const [result, apiCall] = await insightsFoldersMoveFiles(client, args53.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args53,
+    tool: async (client, args54, ctx) => {
+      const [result, apiCall] = await insightsFoldersMoveFiles(client, args54.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54577,9 +54741,9 @@ var init_insightsFoldersMoveFiles2 = __esm(() => {
 
 // src/funcs/insightsFoldersUpdate.ts
 function insightsFoldersUpdate(client, request, options) {
-  return new APIPromise($do60(client, request, options));
+  return new APIPromise($do61(client, request, options));
 }
-async function $do60(client, request, options) {
+async function $do61(client, request, options) {
   const parsed = safeParse(request, (value) => InsightsFolderUpdateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -54659,20 +54823,20 @@ var init_insightsFoldersUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/insightsFoldersUpdate.ts
-var args53, tool$insightsFoldersUpdate;
+var args54, tool$insightsFoldersUpdate;
 var init_insightsFoldersUpdate2 = __esm(() => {
   init_insightsFoldersUpdate();
   init_operations();
   init_tools();
-  args53 = {
+  args54 = {
     request: InsightsFolderUpdateRequest$inboundSchema
   };
   tool$insightsFoldersUpdate = {
     name: "insights-folders-update",
     description: `Update Insights Folder`,
-    args: args53,
-    tool: async (client, args54, ctx) => {
-      const [result, apiCall] = await insightsFoldersUpdate(client, args54.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args54,
+    tool: async (client, args55, ctx) => {
+      const [result, apiCall] = await insightsFoldersUpdate(client, args55.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54687,9 +54851,9 @@ var init_insightsFoldersUpdate2 = __esm(() => {
 
 // src/funcs/insightsFoldersUploadFile.ts
 function insightsFoldersUploadFile(client, request, options) {
-  return new APIPromise($do61(client, request, options));
+  return new APIPromise($do62(client, request, options));
 }
-async function $do61(client, request, options) {
+async function $do62(client, request, options) {
   const parsed = safeParse(request, (value) => InsightsFolderUploadFileRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -54794,20 +54958,20 @@ var init_insightsFoldersUploadFile = __esm(() => {
 });
 
 // src/mcp-server/tools/insightsFoldersUploadFile.ts
-var args54, tool$insightsFoldersUploadFile;
+var args55, tool$insightsFoldersUploadFile;
 var init_insightsFoldersUploadFile2 = __esm(() => {
   init_insightsFoldersUploadFile();
   init_operations();
   init_tools();
-  args54 = {
+  args55 = {
     request: InsightsFolderUploadFileRequest$inboundSchema
   };
   tool$insightsFoldersUploadFile = {
     name: "insights-folders-upload-file",
     description: `Upload Insights  Upload Folder`,
-    args: args54,
-    tool: async (client, args55, ctx) => {
-      const [result, apiCall] = await insightsFoldersUploadFile(client, args55.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args55,
+    tool: async (client, args56, ctx) => {
+      const [result, apiCall] = await insightsFoldersUploadFile(client, args56.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54822,9 +54986,9 @@ var init_insightsFoldersUploadFile2 = __esm(() => {
 
 // src/funcs/insightsList.ts
 function insightsList(client, request, options) {
-  return new APIPromise($do62(client, request, options));
+  return new APIPromise($do63(client, request, options));
 }
-async function $do62(client, request, options) {
+async function $do63(client, request, options) {
   const parsed = safeParse(request, (value) => InsightsListRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -54907,12 +55071,12 @@ var init_insightsList = __esm(() => {
 });
 
 // src/mcp-server/tools/insightsList.ts
-var args55, tool$insightsList;
+var args56, tool$insightsList;
 var init_insightsList2 = __esm(() => {
   init_insightsList();
   init_operations();
   init_tools();
-  args55 = {
+  args56 = {
     request: InsightsListRequest$inboundSchema
   };
   tool$insightsList = {
@@ -54920,9 +55084,9 @@ var init_insightsList2 = __esm(() => {
     description: `Insights List
 
 List the evaluated insights for sessions.`,
-    args: args55,
-    tool: async (client, args56, ctx) => {
-      const [result, apiCall] = await insightsList(client, args56.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args56,
+    tool: async (client, args57, ctx) => {
+      const [result, apiCall] = await insightsList(client, args57.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54937,9 +55101,9 @@ List the evaluated insights for sessions.`,
 
 // src/funcs/insightsToolsCreate.ts
 function insightsToolsCreate(client, request, options) {
-  return new APIPromise($do63(client, request, options));
+  return new APIPromise($do64(client, request, options));
 }
-async function $do63(client, request, options) {
+async function $do64(client, request, options) {
   const parsed = safeParse(request, (value) => InsightToolInput$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -55010,12 +55174,12 @@ var init_insightsToolsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/insightsToolsCreate.ts
-var args56, tool$insightsToolsCreate;
+var args57, tool$insightsToolsCreate;
 var init_insightsToolsCreate2 = __esm(() => {
   init_insightsToolsCreate();
   init_components();
   init_tools();
-  args56 = {
+  args57 = {
     request: InsightToolInput$inboundSchema
   };
   tool$insightsToolsCreate = {
@@ -55023,9 +55187,9 @@ var init_insightsToolsCreate2 = __esm(() => {
     description: `Create Insight Tool Configuration
 
 Create a new insight tool.`,
-    args: args56,
-    tool: async (client, args57, ctx) => {
-      const [result, apiCall] = await insightsToolsCreate(client, args57.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args57,
+    tool: async (client, args58, ctx) => {
+      const [result, apiCall] = await insightsToolsCreate(client, args58.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55040,9 +55204,9 @@ Create a new insight tool.`,
 
 // src/funcs/insightsToolsDelete.ts
 function insightsToolsDelete(client, request, options) {
-  return new APIPromise($do64(client, request, options));
+  return new APIPromise($do65(client, request, options));
 }
-async function $do64(client, request, options) {
+async function $do65(client, request, options) {
   const parsed = safeParse(request, (value) => InsightsToolDeleteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -55119,12 +55283,12 @@ var init_insightsToolsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/insightsToolsDelete.ts
-var args57, tool$insightsToolsDelete;
+var args58, tool$insightsToolsDelete;
 var init_insightsToolsDelete2 = __esm(() => {
   init_insightsToolsDelete();
   init_operations();
   init_tools();
-  args57 = {
+  args58 = {
     request: InsightsToolDeleteRequest$inboundSchema
   };
   tool$insightsToolsDelete = {
@@ -55132,9 +55296,9 @@ var init_insightsToolsDelete2 = __esm(() => {
     description: `Delete Insight Tool Configuration
 
 Delete an Insights tool configuration.`,
-    args: args57,
-    tool: async (client, args58, ctx) => {
-      const [result, apiCall] = await insightsToolsDelete(client, args58.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args58,
+    tool: async (client, args59, ctx) => {
+      const [result, apiCall] = await insightsToolsDelete(client, args59.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55149,9 +55313,9 @@ Delete an Insights tool configuration.`,
 
 // src/funcs/insightsToolsGetById.ts
 function insightsToolsGetById(client, request, options) {
-  return new APIPromise($do65(client, request, options));
+  return new APIPromise($do66(client, request, options));
 }
-async function $do65(client, request, options) {
+async function $do66(client, request, options) {
   const parsed = safeParse(request, (value) => InsightToolGetByIdRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -55228,12 +55392,12 @@ var init_insightsToolsGetById = __esm(() => {
 });
 
 // src/mcp-server/tools/insightsToolsGetById.ts
-var args58, tool$insightsToolsGetById;
+var args59, tool$insightsToolsGetById;
 var init_insightsToolsGetById2 = __esm(() => {
   init_insightsToolsGetById();
   init_operations();
   init_tools();
-  args58 = {
+  args59 = {
     request: InsightToolGetByIdRequest$inboundSchema
   };
   tool$insightsToolsGetById = {
@@ -55241,9 +55405,9 @@ var init_insightsToolsGetById2 = __esm(() => {
     description: `Get Insight Tool Config By Id
 
 Get a InsightTool by Name.`,
-    args: args58,
-    tool: async (client, args59, ctx) => {
-      const [result, apiCall] = await insightsToolsGetById(client, args59.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args59,
+    tool: async (client, args60, ctx) => {
+      const [result, apiCall] = await insightsToolsGetById(client, args60.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55258,9 +55422,9 @@ Get a InsightTool by Name.`,
 
 // src/funcs/insightsToolsInsightsToolTest.ts
 function insightsToolsInsightsToolTest(client, request, options) {
-  return new APIPromise($do66(client, request, options));
+  return new APIPromise($do67(client, request, options));
 }
-async function $do66(client, request, options) {
+async function $do67(client, request, options) {
   const parsed = safeParse(request, (value) => InsightToolTestInput$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -55332,12 +55496,12 @@ var init_insightsToolsInsightsToolTest = __esm(() => {
 });
 
 // src/mcp-server/tools/insightsToolsInsightsToolTest.ts
-var args59, tool$insightsToolsInsightsToolTest;
+var args60, tool$insightsToolsInsightsToolTest;
 var init_insightsToolsInsightsToolTest2 = __esm(() => {
   init_insightsToolsInsightsToolTest();
   init_components();
   init_tools();
-  args59 = {
+  args60 = {
     request: InsightToolTestInput$inboundSchema
   };
   tool$insightsToolsInsightsToolTest = {
@@ -55345,9 +55509,9 @@ var init_insightsToolsInsightsToolTest2 = __esm(() => {
     description: `Test Insights Tool
 
 Manually run the given insight tool against a session and return the response.`,
-    args: args59,
-    tool: async (client, args60, ctx) => {
-      const [result, apiCall] = await insightsToolsInsightsToolTest(client, args60.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args60,
+    tool: async (client, args61, ctx) => {
+      const [result, apiCall] = await insightsToolsInsightsToolTest(client, args61.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55362,9 +55526,9 @@ Manually run the given insight tool against a session and return the response.`,
 
 // src/funcs/insightsToolsInsightToolGetDefinitions.ts
 function insightsToolsInsightToolGetDefinitions(client, options) {
-  return new APIPromise($do67(client, options));
+  return new APIPromise($do68(client, options));
 }
-async function $do67(client, options) {
+async function $do68(client, options) {
   const path = pathToFunc("/api/v1/insights/tool-definitions")();
   const headers = new Headers(compactMap({
     Accept: "application/json"
@@ -55447,9 +55611,9 @@ Get a InsightTool by Name.`,
 
 // src/funcs/insightsToolsList.ts
 function insightsToolsList(client, request, options) {
-  return new APIPromise($do68(client, request, options));
+  return new APIPromise($do69(client, request, options));
 }
-async function $do68(client, request, options) {
+async function $do69(client, request, options) {
   const parsed = safeParse(request, (value) => InsightToolListRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -55532,12 +55696,12 @@ var init_insightsToolsList = __esm(() => {
 });
 
 // src/mcp-server/tools/insightsToolsList.ts
-var args60, tool$insightsToolsList;
+var args61, tool$insightsToolsList;
 var init_insightsToolsList2 = __esm(() => {
   init_insightsToolsList();
   init_operations();
   init_tools();
-  args60 = {
+  args61 = {
     request: InsightToolListRequest$inboundSchema
   };
   tool$insightsToolsList = {
@@ -55545,9 +55709,9 @@ var init_insightsToolsList2 = __esm(() => {
     description: `List Insight Tool Configurations
 
 List the existing insight_tools`,
-    args: args60,
-    tool: async (client, args61, ctx) => {
-      const [result, apiCall] = await insightsToolsList(client, args61.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args61,
+    tool: async (client, args62, ctx) => {
+      const [result, apiCall] = await insightsToolsList(client, args62.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55562,9 +55726,9 @@ List the existing insight_tools`,
 
 // src/funcs/insightsToolsUpdate.ts
 function insightsToolsUpdate(client, request, options) {
-  return new APIPromise($do69(client, request, options));
+  return new APIPromise($do70(client, request, options));
 }
-async function $do69(client, request, options) {
+async function $do70(client, request, options) {
   const parsed = safeParse(request, (value) => InsightsToolUpdateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -55642,12 +55806,12 @@ var init_insightsToolsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/insightsToolsUpdate.ts
-var args61, tool$insightsToolsUpdate;
+var args62, tool$insightsToolsUpdate;
 var init_insightsToolsUpdate2 = __esm(() => {
   init_insightsToolsUpdate();
   init_operations();
   init_tools();
-  args61 = {
+  args62 = {
     request: InsightsToolUpdateRequest$inboundSchema
   };
   tool$insightsToolsUpdate = {
@@ -55655,9 +55819,9 @@ var init_insightsToolsUpdate2 = __esm(() => {
     description: `Update Insights Tool Configuration
 
 Update an Insights tool.`,
-    args: args61,
-    tool: async (client, args62, ctx) => {
-      const [result, apiCall] = await insightsToolsUpdate(client, args62.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args62,
+    tool: async (client, args63, ctx) => {
+      const [result, apiCall] = await insightsToolsUpdate(client, args63.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55672,9 +55836,9 @@ Update an Insights tool.`,
 
 // src/funcs/insightsWorkflowsActivate.ts
 function insightsWorkflowsActivate(client, request, options) {
-  return new APIPromise($do70(client, request, options));
+  return new APIPromise($do71(client, request, options));
 }
-async function $do70(client, request, options) {
+async function $do71(client, request, options) {
   const parsed = safeParse(request, (value) => InsightsWorkflowActivateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -55754,12 +55918,12 @@ var init_insightsWorkflowsActivate = __esm(() => {
 });
 
 // src/mcp-server/tools/insightsWorkflowsActivate.ts
-var args62, tool$insightsWorkflowsActivate;
+var args63, tool$insightsWorkflowsActivate;
 var init_insightsWorkflowsActivate2 = __esm(() => {
   init_insightsWorkflowsActivate();
   init_operations();
   init_tools();
-  args62 = {
+  args63 = {
     request: InsightsWorkflowActivateRequest$inboundSchema
   };
   tool$insightsWorkflowsActivate = {
@@ -55767,9 +55931,9 @@ var init_insightsWorkflowsActivate2 = __esm(() => {
     description: `Activate Insights Workflow
 
 Activate an InsightWorkflow.`,
-    args: args62,
-    tool: async (client, args63, ctx) => {
-      const [result, apiCall] = await insightsWorkflowsActivate(client, args63.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args63,
+    tool: async (client, args64, ctx) => {
+      const [result, apiCall] = await insightsWorkflowsActivate(client, args64.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55784,9 +55948,9 @@ Activate an InsightWorkflow.`,
 
 // src/funcs/insightsWorkflowsCreate.ts
 function insightsWorkflowsCreate(client, request, options) {
-  return new APIPromise($do71(client, request, options));
+  return new APIPromise($do72(client, request, options));
 }
-async function $do71(client, request, options) {
+async function $do72(client, request, options) {
   const parsed = safeParse(request, (value) => InsightWorkflowInput$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -55857,12 +56021,12 @@ var init_insightsWorkflowsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/insightsWorkflowsCreate.ts
-var args63, tool$insightsWorkflowsCreate;
+var args64, tool$insightsWorkflowsCreate;
 var init_insightsWorkflowsCreate2 = __esm(() => {
   init_insightsWorkflowsCreate();
   init_components();
   init_tools();
-  args63 = {
+  args64 = {
     request: InsightWorkflowInput$inboundSchema
   };
   tool$insightsWorkflowsCreate = {
@@ -55870,9 +56034,9 @@ var init_insightsWorkflowsCreate2 = __esm(() => {
     description: `Create Insight Workflow
 
 Create a new tool in the insights`,
-    args: args63,
-    tool: async (client, args64, ctx) => {
-      const [result, apiCall] = await insightsWorkflowsCreate(client, args64.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args64,
+    tool: async (client, args65, ctx) => {
+      const [result, apiCall] = await insightsWorkflowsCreate(client, args65.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55887,9 +56051,9 @@ Create a new tool in the insights`,
 
 // src/funcs/insightsWorkflowsDelete.ts
 function insightsWorkflowsDelete(client, request, options) {
-  return new APIPromise($do72(client, request, options));
+  return new APIPromise($do73(client, request, options));
 }
-async function $do72(client, request, options) {
+async function $do73(client, request, options) {
   const parsed = safeParse(request, (value) => InsightsWorkflowDeleteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -55966,12 +56130,12 @@ var init_insightsWorkflowsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/insightsWorkflowsDelete.ts
-var args64, tool$insightsWorkflowsDelete;
+var args65, tool$insightsWorkflowsDelete;
 var init_insightsWorkflowsDelete2 = __esm(() => {
   init_insightsWorkflowsDelete();
   init_operations();
   init_tools();
-  args64 = {
+  args65 = {
     request: InsightsWorkflowDeleteRequest$inboundSchema
   };
   tool$insightsWorkflowsDelete = {
@@ -55979,9 +56143,9 @@ var init_insightsWorkflowsDelete2 = __esm(() => {
     description: `Delete Insights Workflow
 
 Delete an Insights workflow.`,
-    args: args64,
-    tool: async (client, args65, ctx) => {
-      const [result, apiCall] = await insightsWorkflowsDelete(client, args65.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args65,
+    tool: async (client, args66, ctx) => {
+      const [result, apiCall] = await insightsWorkflowsDelete(client, args66.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55996,9 +56160,9 @@ Delete an Insights workflow.`,
 
 // src/funcs/insightsWorkflowsGetById.ts
 function insightsWorkflowsGetById(client, request, options) {
-  return new APIPromise($do73(client, request, options));
+  return new APIPromise($do74(client, request, options));
 }
-async function $do73(client, request, options) {
+async function $do74(client, request, options) {
   const parsed = safeParse(request, (value) => InsightsWorkflowGetByIdRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -56075,12 +56239,12 @@ var init_insightsWorkflowsGetById = __esm(() => {
 });
 
 // src/mcp-server/tools/insightsWorkflowsGetById.ts
-var args65, tool$insightsWorkflowsGetById;
+var args66, tool$insightsWorkflowsGetById;
 var init_insightsWorkflowsGetById2 = __esm(() => {
   init_insightsWorkflowsGetById();
   init_operations();
   init_tools();
-  args65 = {
+  args66 = {
     request: InsightsWorkflowGetByIdRequest$inboundSchema
   };
   tool$insightsWorkflowsGetById = {
@@ -56088,9 +56252,9 @@ var init_insightsWorkflowsGetById2 = __esm(() => {
     description: `Get Insight Workflow By Id
 
 Get a InsightWorkflow by ID.`,
-    args: args65,
-    tool: async (client, args66, ctx) => {
-      const [result, apiCall] = await insightsWorkflowsGetById(client, args66.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args66,
+    tool: async (client, args67, ctx) => {
+      const [result, apiCall] = await insightsWorkflowsGetById(client, args67.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -56105,9 +56269,9 @@ Get a InsightWorkflow by ID.`,
 
 // src/funcs/insightsWorkflowsInactivate.ts
 function insightsWorkflowsInactivate(client, request, options) {
-  return new APIPromise($do74(client, request, options));
+  return new APIPromise($do75(client, request, options));
 }
-async function $do74(client, request, options) {
+async function $do75(client, request, options) {
   const parsed = safeParse(request, (value) => InsightsWorkflowInactivateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -56184,12 +56348,12 @@ var init_insightsWorkflowsInactivate = __esm(() => {
 });
 
 // src/mcp-server/tools/insightsWorkflowsInactivate.ts
-var args66, tool$insightsWorkflowsInactivate;
+var args67, tool$insightsWorkflowsInactivate;
 var init_insightsWorkflowsInactivate2 = __esm(() => {
   init_insightsWorkflowsInactivate();
   init_operations();
   init_tools();
-  args66 = {
+  args67 = {
     request: InsightsWorkflowInactivateRequest$inboundSchema
   };
   tool$insightsWorkflowsInactivate = {
@@ -56197,9 +56361,9 @@ var init_insightsWorkflowsInactivate2 = __esm(() => {
     description: `Inactivate Insights Workflow
 
 Inactivate an InsightWorkflow.`,
-    args: args66,
-    tool: async (client, args67, ctx) => {
-      const [result, apiCall] = await insightsWorkflowsInactivate(client, args67.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args67,
+    tool: async (client, args68, ctx) => {
+      const [result, apiCall] = await insightsWorkflowsInactivate(client, args68.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -56214,9 +56378,9 @@ Inactivate an InsightWorkflow.`,
 
 // src/funcs/insightsWorkflowsList.ts
 function insightsWorkflowsList(client, request, options) {
-  return new APIPromise($do75(client, request, options));
+  return new APIPromise($do76(client, request, options));
 }
-async function $do75(client, request, options) {
+async function $do76(client, request, options) {
   const parsed = safeParse(request, (value) => InsightsWorkflowListRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -56299,12 +56463,12 @@ var init_insightsWorkflowsList = __esm(() => {
 });
 
 // src/mcp-server/tools/insightsWorkflowsList.ts
-var args67, tool$insightsWorkflowsList;
+var args68, tool$insightsWorkflowsList;
 var init_insightsWorkflowsList2 = __esm(() => {
   init_insightsWorkflowsList();
   init_operations();
   init_tools();
-  args67 = {
+  args68 = {
     request: InsightsWorkflowListRequest$inboundSchema
   };
   tool$insightsWorkflowsList = {
@@ -56312,9 +56476,9 @@ var init_insightsWorkflowsList2 = __esm(() => {
     description: `Insight Workflow List
 
 List the existing insight_workflows`,
-    args: args67,
-    tool: async (client, args68, ctx) => {
-      const [result, apiCall] = await insightsWorkflowsList(client, args68.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args68,
+    tool: async (client, args69, ctx) => {
+      const [result, apiCall] = await insightsWorkflowsList(client, args69.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -56329,9 +56493,9 @@ List the existing insight_workflows`,
 
 // src/funcs/insightsWorkflowsQueueWork.ts
 function insightsWorkflowsQueueWork(client, request, options) {
-  return new APIPromise($do76(client, request, options));
+  return new APIPromise($do77(client, request, options));
 }
-async function $do76(client, request, options) {
+async function $do77(client, request, options) {
   const parsed = safeParse(request, (value) => InsightsWorkflowQueueSession$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -56403,12 +56567,12 @@ var init_insightsWorkflowsQueueWork = __esm(() => {
 });
 
 // src/mcp-server/tools/insightsWorkflowsQueueWork.ts
-var args68, tool$insightsWorkflowsQueueWork;
+var args69, tool$insightsWorkflowsQueueWork;
 var init_insightsWorkflowsQueueWork2 = __esm(() => {
   init_insightsWorkflowsQueueWork();
   init_components();
   init_tools();
-  args68 = {
+  args69 = {
     request: InsightsWorkflowQueueSession$inboundSchema
   };
   tool$insightsWorkflowsQueueWork = {
@@ -56416,9 +56580,9 @@ var init_insightsWorkflowsQueueWork2 = __esm(() => {
     description: `Queue Insights Workflow For Sessions/Files
 
 Manually queue sessions for insights workflow evaluation.`,
-    args: args68,
-    tool: async (client, args69, ctx) => {
-      const [result, apiCall] = await insightsWorkflowsQueueWork(client, args69.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args69,
+    tool: async (client, args70, ctx) => {
+      const [result, apiCall] = await insightsWorkflowsQueueWork(client, args70.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -56433,9 +56597,9 @@ Manually queue sessions for insights workflow evaluation.`,
 
 // src/funcs/insightsWorkflowsUpdate.ts
 function insightsWorkflowsUpdate(client, request, options) {
-  return new APIPromise($do77(client, request, options));
+  return new APIPromise($do78(client, request, options));
 }
-async function $do77(client, request, options) {
+async function $do78(client, request, options) {
   const parsed = safeParse(request, (value) => InsightsWorkflowUpdateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -56515,12 +56679,12 @@ var init_insightsWorkflowsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/insightsWorkflowsUpdate.ts
-var args69, tool$insightsWorkflowsUpdate;
+var args70, tool$insightsWorkflowsUpdate;
 var init_insightsWorkflowsUpdate2 = __esm(() => {
   init_insightsWorkflowsUpdate();
   init_operations();
   init_tools();
-  args69 = {
+  args70 = {
     request: InsightsWorkflowUpdateRequest$inboundSchema
   };
   tool$insightsWorkflowsUpdate = {
@@ -56528,9 +56692,9 @@ var init_insightsWorkflowsUpdate2 = __esm(() => {
     description: `Update Insights Workflow
 
 Update a InsightWorkflow.`,
-    args: args69,
-    tool: async (client, args70, ctx) => {
-      const [result, apiCall] = await insightsWorkflowsUpdate(client, args70.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args70,
+    tool: async (client, args71, ctx) => {
+      const [result, apiCall] = await insightsWorkflowsUpdate(client, args71.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -56545,9 +56709,9 @@ Update a InsightWorkflow.`,
 
 // src/funcs/languageGroupsCreate.ts
 function languageGroupsCreate(client, request, options) {
-  return new APIPromise($do78(client, request, options));
+  return new APIPromise($do79(client, request, options));
 }
-async function $do78(client, request, options) {
+async function $do79(client, request, options) {
   const parsed = safeParse(request, (value) => LanguageGroupCreateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -56618,12 +56782,12 @@ var init_languageGroupsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/languageGroupsCreate.ts
-var args70, tool$languageGroupsCreate;
+var args71, tool$languageGroupsCreate;
 var init_languageGroupsCreate2 = __esm(() => {
   init_languageGroupsCreate();
   init_components();
   init_tools();
-  args70 = {
+  args71 = {
     request: LanguageGroupCreateRequest$inboundSchema
   };
   tool$languageGroupsCreate = {
@@ -56631,9 +56795,9 @@ var init_languageGroupsCreate2 = __esm(() => {
     description: `Create Language Group
 
 Deprecated alias for \`POST /api/v1/voice_groups/\`.`,
-    args: args70,
-    tool: async (client, args71, ctx) => {
-      const [result, apiCall] = await languageGroupsCreate(client, args71.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args71,
+    tool: async (client, args72, ctx) => {
+      const [result, apiCall] = await languageGroupsCreate(client, args72.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -56648,9 +56812,9 @@ Deprecated alias for \`POST /api/v1/voice_groups/\`.`,
 
 // src/funcs/languageGroupsDelete.ts
 function languageGroupsDelete(client, request, options) {
-  return new APIPromise($do79(client, request, options));
+  return new APIPromise($do80(client, request, options));
 }
-async function $do79(client, request, options) {
+async function $do80(client, request, options) {
   const parsed = safeParse(request, (value) => LanguageGroupsDeleteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -56728,12 +56892,12 @@ var init_languageGroupsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/languageGroupsDelete.ts
-var args71, tool$languageGroupsDelete;
+var args72, tool$languageGroupsDelete;
 var init_languageGroupsDelete2 = __esm(() => {
   init_languageGroupsDelete();
   init_operations();
   init_tools();
-  args71 = {
+  args72 = {
     request: LanguageGroupsDeleteRequest$inboundSchema
   };
   tool$languageGroupsDelete = {
@@ -56741,9 +56905,9 @@ var init_languageGroupsDelete2 = __esm(() => {
     description: `Delete Language Group
 
 Deprecated alias for \`DELETE /api/v1/voice_groups/{voice_group_id}\`.`,
-    args: args71,
-    tool: async (client, args72, ctx) => {
-      const [result, apiCall] = await languageGroupsDelete(client, args72.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args72,
+    tool: async (client, args73, ctx) => {
+      const [result, apiCall] = await languageGroupsDelete(client, args73.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -56758,9 +56922,9 @@ Deprecated alias for \`DELETE /api/v1/voice_groups/{voice_group_id}\`.`,
 
 // src/funcs/languageGroupsGetById.ts
 function languageGroupsGetById(client, request, options) {
-  return new APIPromise($do80(client, request, options));
+  return new APIPromise($do81(client, request, options));
 }
-async function $do80(client, request, options) {
+async function $do81(client, request, options) {
   const parsed = safeParse(request, (value) => LanguageGroupsGetByIdRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -56834,12 +56998,12 @@ var init_languageGroupsGetById = __esm(() => {
 });
 
 // src/mcp-server/tools/languageGroupsGetById.ts
-var args72, tool$languageGroupsGetById;
+var args73, tool$languageGroupsGetById;
 var init_languageGroupsGetById2 = __esm(() => {
   init_languageGroupsGetById();
   init_operations();
   init_tools();
-  args72 = {
+  args73 = {
     request: LanguageGroupsGetByIdRequest$inboundSchema
   };
   tool$languageGroupsGetById = {
@@ -56847,9 +57011,9 @@ var init_languageGroupsGetById2 = __esm(() => {
     description: `Get Language Group
 
 Deprecated alias for \`GET /api/v1/voice_groups/{voice_group_id}\`.`,
-    args: args72,
-    tool: async (client, args73, ctx) => {
-      const [result, apiCall] = await languageGroupsGetById(client, args73.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args73,
+    tool: async (client, args74, ctx) => {
+      const [result, apiCall] = await languageGroupsGetById(client, args74.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -56864,9 +57028,9 @@ Deprecated alias for \`GET /api/v1/voice_groups/{voice_group_id}\`.`,
 
 // src/funcs/languageGroupsLanguageGroupsCreateVoiceSample.ts
 function languageGroupsLanguageGroupsCreateVoiceSample(client, request, options) {
-  return new APIPromise($do81(client, request, options));
+  return new APIPromise($do82(client, request, options));
 }
-async function $do81(client, request, options) {
+async function $do82(client, request, options) {
   const parsed = safeParse(request, (value) => LanguageSampleCreateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -56938,12 +57102,12 @@ var init_languageGroupsLanguageGroupsCreateVoiceSample = __esm(() => {
 });
 
 // src/mcp-server/tools/languageGroupsLanguageGroupsCreateVoiceSample.ts
-var args73, tool$languageGroupsLanguageGroupsCreateVoiceSample;
+var args74, tool$languageGroupsLanguageGroupsCreateVoiceSample;
 var init_languageGroupsLanguageGroupsCreateVoiceSample2 = __esm(() => {
   init_languageGroupsLanguageGroupsCreateVoiceSample();
   init_components();
   init_tools();
-  args73 = {
+  args74 = {
     request: LanguageSampleCreateRequest$inboundSchema
   };
   tool$languageGroupsLanguageGroupsCreateVoiceSample = {
@@ -56951,9 +57115,9 @@ var init_languageGroupsLanguageGroupsCreateVoiceSample2 = __esm(() => {
     description: `Create Voice Sample
 
 Deprecated alias for \`POST /api/v1/voice_groups/voices/sample\`.`,
-    args: args73,
-    tool: async (client, args74, ctx) => {
-      const [result, apiCall] = await languageGroupsLanguageGroupsCreateVoiceSample(client, args74.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args74,
+    tool: async (client, args75, ctx) => {
+      const [result, apiCall] = await languageGroupsLanguageGroupsCreateVoiceSample(client, args75.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -56968,9 +57132,9 @@ Deprecated alias for \`POST /api/v1/voice_groups/voices/sample\`.`,
 
 // src/funcs/languageGroupsList.ts
 function languageGroupsList(client, request, options) {
-  return new APIPromise($do82(client, request, options));
+  return new APIPromise($do83(client, request, options));
 }
-async function $do82(client, request, options) {
+async function $do83(client, request, options) {
   const parsed = safeParse(request, (value) => LanguageGroupsListRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -57053,12 +57217,12 @@ var init_languageGroupsList = __esm(() => {
 });
 
 // src/mcp-server/tools/languageGroupsList.ts
-var args74, tool$languageGroupsList;
+var args75, tool$languageGroupsList;
 var init_languageGroupsList2 = __esm(() => {
   init_languageGroupsList();
   init_operations();
   init_tools();
-  args74 = {
+  args75 = {
     request: LanguageGroupsListRequest$inboundSchema
   };
   tool$languageGroupsList = {
@@ -57066,9 +57230,9 @@ var init_languageGroupsList2 = __esm(() => {
     description: `List Language Groups
 
 Deprecated alias for \`GET /api/v1/voice_groups/\`.`,
-    args: args74,
-    tool: async (client, args75, ctx) => {
-      const [result, apiCall] = await languageGroupsList(client, args75.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args75,
+    tool: async (client, args76, ctx) => {
+      const [result, apiCall] = await languageGroupsList(client, args76.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -57083,9 +57247,9 @@ Deprecated alias for \`GET /api/v1/voice_groups/\`.`,
 
 // src/funcs/languageGroupsUpdate.ts
 function languageGroupsUpdate(client, request, options) {
-  return new APIPromise($do83(client, request, options));
+  return new APIPromise($do84(client, request, options));
 }
-async function $do83(client, request, options) {
+async function $do84(client, request, options) {
   const parsed = safeParse(request, (value) => LanguageGroupUpdateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -57156,12 +57320,12 @@ var init_languageGroupsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/languageGroupsUpdate.ts
-var args75, tool$languageGroupsUpdate;
+var args76, tool$languageGroupsUpdate;
 var init_languageGroupsUpdate2 = __esm(() => {
   init_languageGroupsUpdate();
   init_components();
   init_tools();
-  args75 = {
+  args76 = {
     request: LanguageGroupUpdateRequest$inboundSchema
   };
   tool$languageGroupsUpdate = {
@@ -57169,9 +57333,9 @@ var init_languageGroupsUpdate2 = __esm(() => {
     description: `Update Language Group
 
 Deprecated alias for \`PUT /api/v1/voice_groups/\`.`,
-    args: args75,
-    tool: async (client, args76, ctx) => {
-      const [result, apiCall] = await languageGroupsUpdate(client, args76.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args76,
+    tool: async (client, args77, ctx) => {
+      const [result, apiCall] = await languageGroupsUpdate(client, args77.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -57186,9 +57350,9 @@ Deprecated alias for \`PUT /api/v1/voice_groups/\`.`,
 
 // src/funcs/organizationsCreate.ts
 function organizationsCreate(client, request, options) {
-  return new APIPromise($do84(client, request, options));
+  return new APIPromise($do85(client, request, options));
 }
-async function $do84(client, request, options) {
+async function $do85(client, request, options) {
   const parsed = safeParse(request, (value) => BodyOrganizationsCreate$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -57280,12 +57444,12 @@ var init_organizationsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/organizationsCreate.ts
-var args76, tool$organizationsCreate;
+var args77, tool$organizationsCreate;
 var init_organizationsCreate2 = __esm(() => {
   init_organizationsCreate();
   init_components();
   init_tools();
-  args76 = {
+  args77 = {
     request: BodyOrganizationsCreate$inboundSchema
   };
   tool$organizationsCreate = {
@@ -57293,9 +57457,9 @@ var init_organizationsCreate2 = __esm(() => {
     description: `Create Organization
 
 Create a new organization.`,
-    args: args76,
-    tool: async (client, args77, ctx) => {
-      const [result, apiCall] = await organizationsCreate(client, args77.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args77,
+    tool: async (client, args78, ctx) => {
+      const [result, apiCall] = await organizationsCreate(client, args78.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -57310,9 +57474,9 @@ Create a new organization.`,
 
 // src/funcs/organizationsDelete.ts
 function organizationsDelete(client, request, options) {
-  return new APIPromise($do85(client, request, options));
+  return new APIPromise($do86(client, request, options));
 }
-async function $do85(client, request, options) {
+async function $do86(client, request, options) {
   const parsed = safeParse(request, (value) => BodyOrganizationsDelete$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -57386,12 +57550,12 @@ var init_organizationsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/organizationsDelete.ts
-var args77, tool$organizationsDelete;
+var args78, tool$organizationsDelete;
 var init_organizationsDelete2 = __esm(() => {
   init_organizationsDelete();
   init_components();
   init_tools();
-  args77 = {
+  args78 = {
     request: BodyOrganizationsDelete$inboundSchema.optional()
   };
   tool$organizationsDelete = {
@@ -57399,9 +57563,9 @@ var init_organizationsDelete2 = __esm(() => {
     description: `Delete Current Organization
 
 Delete the current organization and all its users.`,
-    args: args77,
-    tool: async (client, args78, ctx) => {
-      const [result, apiCall] = await organizationsDelete(client, args78.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args78,
+    tool: async (client, args79, ctx) => {
+      const [result, apiCall] = await organizationsDelete(client, args79.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -57416,9 +57580,9 @@ Delete the current organization and all its users.`,
 
 // src/funcs/organizationsOrganizationsGet.ts
 function organizationsOrganizationsGet(client, options) {
-  return new APIPromise($do86(client, options));
+  return new APIPromise($do87(client, options));
 }
-async function $do86(client, options) {
+async function $do87(client, options) {
   const path = pathToFunc("/api/v1/organizations/")();
   const headers = new Headers(compactMap({
     Accept: "application/json"
@@ -57500,9 +57664,9 @@ Fetch the current organization.`,
 
 // src/funcs/organizationsUpdate.ts
 function organizationsUpdate(client, request, options) {
-  return new APIPromise($do87(client, request, options));
+  return new APIPromise($do88(client, request, options));
 }
-async function $do87(client, request, options) {
+async function $do88(client, request, options) {
   const parsed = safeParse(request, (value) => BodyOrganizationsUpdate$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -57599,12 +57763,12 @@ var init_organizationsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/organizationsUpdate.ts
-var args78, tool$organizationsUpdate;
+var args79, tool$organizationsUpdate;
 var init_organizationsUpdate2 = __esm(() => {
   init_organizationsUpdate();
   init_components();
   init_tools();
-  args78 = {
+  args79 = {
     request: BodyOrganizationsUpdate$inboundSchema
   };
   tool$organizationsUpdate = {
@@ -57612,9 +57776,9 @@ var init_organizationsUpdate2 = __esm(() => {
     description: `Update Current Organization
 
 Update the current organization.`,
-    args: args78,
-    tool: async (client, args79, ctx) => {
-      const [result, apiCall] = await organizationsUpdate(client, args79.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args79,
+    tool: async (client, args80, ctx) => {
+      const [result, apiCall] = await organizationsUpdate(client, args80.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -57629,9 +57793,9 @@ Update the current organization.`,
 
 // src/funcs/outboundBatchesAdd.ts
 function outboundBatchesAdd(client, request, options) {
-  return new APIPromise($do88(client, request, options));
+  return new APIPromise($do89(client, request, options));
 }
-async function $do88(client, request, options) {
+async function $do89(client, request, options) {
   const parsed = safeParse(request, (value) => OutboundBatchAddRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -57711,20 +57875,20 @@ var init_outboundBatchesAdd = __esm(() => {
 });
 
 // src/mcp-server/tools/outboundBatchesAdd.ts
-var args79, tool$outboundBatchesAdd;
+var args80, tool$outboundBatchesAdd;
 var init_outboundBatchesAdd2 = __esm(() => {
   init_outboundBatchesAdd();
   init_operations();
   init_tools();
-  args79 = {
+  args80 = {
     request: OutboundBatchAddRequest$inboundSchema
   };
   tool$outboundBatchesAdd = {
     name: "outbound-batches-add",
     description: `Create Outbound Communication Request`,
-    args: args79,
-    tool: async (client, args80, ctx) => {
-      const [result, apiCall] = await outboundBatchesAdd(client, args80.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args80,
+    tool: async (client, args81, ctx) => {
+      const [result, apiCall] = await outboundBatchesAdd(client, args81.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -57739,9 +57903,9 @@ var init_outboundBatchesAdd2 = __esm(() => {
 
 // src/funcs/outboundBatchesCreate.ts
 function outboundBatchesCreate(client, request, options) {
-  return new APIPromise($do89(client, request, options));
+  return new APIPromise($do90(client, request, options));
 }
-async function $do89(client, request, options) {
+async function $do90(client, request, options) {
   const parsed = safeParse(request, (value) => CommunicationBatchInput$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -57812,20 +57976,20 @@ var init_outboundBatchesCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/outboundBatchesCreate.ts
-var args80, tool$outboundBatchesCreate;
+var args81, tool$outboundBatchesCreate;
 var init_outboundBatchesCreate2 = __esm(() => {
   init_outboundBatchesCreate();
   init_components();
   init_tools();
-  args80 = {
+  args81 = {
     request: CommunicationBatchInput$inboundSchema
   };
   tool$outboundBatchesCreate = {
     name: "outbound-batches-create",
     description: `Create Outbound Communication Batch`,
-    args: args80,
-    tool: async (client, args81, ctx) => {
-      const [result, apiCall] = await outboundBatchesCreate(client, args81.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args81,
+    tool: async (client, args82, ctx) => {
+      const [result, apiCall] = await outboundBatchesCreate(client, args82.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -57840,9 +58004,9 @@ var init_outboundBatchesCreate2 = __esm(() => {
 
 // src/funcs/outboundBatchesDelete.ts
 function outboundBatchesDelete(client, request, options) {
-  return new APIPromise($do90(client, request, options));
+  return new APIPromise($do91(client, request, options));
 }
-async function $do90(client, request, options) {
+async function $do91(client, request, options) {
   const parsed = safeParse(request, (value) => OutboundBatchDeleteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -57922,20 +58086,20 @@ var init_outboundBatchesDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/outboundBatchesDelete.ts
-var args81, tool$outboundBatchesDelete;
+var args82, tool$outboundBatchesDelete;
 var init_outboundBatchesDelete2 = __esm(() => {
   init_outboundBatchesDelete();
   init_operations();
   init_tools();
-  args81 = {
+  args82 = {
     request: OutboundBatchDeleteRequest$inboundSchema
   };
   tool$outboundBatchesDelete = {
     name: "outbound-batches-delete",
     description: `Delete Outbound Communication Batch`,
-    args: args81,
-    tool: async (client, args82, ctx) => {
-      const [result, apiCall] = await outboundBatchesDelete(client, args82.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args82,
+    tool: async (client, args83, ctx) => {
+      const [result, apiCall] = await outboundBatchesDelete(client, args83.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -57950,9 +58114,9 @@ var init_outboundBatchesDelete2 = __esm(() => {
 
 // src/funcs/outboundBatchesGetById.ts
 function outboundBatchesGetById(client, request, options) {
-  return new APIPromise($do91(client, request, options));
+  return new APIPromise($do92(client, request, options));
 }
-async function $do91(client, request, options) {
+async function $do92(client, request, options) {
   const parsed = safeParse(request, (value) => OutboundBatchGetByIdRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -58029,20 +58193,20 @@ var init_outboundBatchesGetById = __esm(() => {
 });
 
 // src/mcp-server/tools/outboundBatchesGetById.ts
-var args82, tool$outboundBatchesGetById;
+var args83, tool$outboundBatchesGetById;
 var init_outboundBatchesGetById2 = __esm(() => {
   init_outboundBatchesGetById();
   init_operations();
   init_tools();
-  args82 = {
+  args83 = {
     request: OutboundBatchGetByIdRequest$inboundSchema
   };
   tool$outboundBatchesGetById = {
     name: "outbound-batches-get-by-id",
     description: `Get Outbound Communication Batch`,
-    args: args82,
-    tool: async (client, args83, ctx) => {
-      const [result, apiCall] = await outboundBatchesGetById(client, args83.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args83,
+    tool: async (client, args84, ctx) => {
+      const [result, apiCall] = await outboundBatchesGetById(client, args84.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -58057,9 +58221,9 @@ var init_outboundBatchesGetById2 = __esm(() => {
 
 // src/funcs/outboundBatchesList.ts
 function outboundBatchesList(client, request, options) {
-  return new APIPromise($do92(client, request, options));
+  return new APIPromise($do93(client, request, options));
 }
-async function $do92(client, request, options) {
+async function $do93(client, request, options) {
   const parsed = safeParse(request, (value) => OutboundBatchListRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -58142,20 +58306,20 @@ var init_outboundBatchesList = __esm(() => {
 });
 
 // src/mcp-server/tools/outboundBatchesList.ts
-var args83, tool$outboundBatchesList;
+var args84, tool$outboundBatchesList;
 var init_outboundBatchesList2 = __esm(() => {
   init_outboundBatchesList();
   init_operations();
   init_tools();
-  args83 = {
+  args84 = {
     request: OutboundBatchListRequest$inboundSchema
   };
   tool$outboundBatchesList = {
     name: "outbound-batches-list",
     description: `List Outbound Communication Batches`,
-    args: args83,
-    tool: async (client, args84, ctx) => {
-      const [result, apiCall] = await outboundBatchesList(client, args84.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args84,
+    tool: async (client, args85, ctx) => {
+      const [result, apiCall] = await outboundBatchesList(client, args85.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -58170,9 +58334,9 @@ var init_outboundBatchesList2 = __esm(() => {
 
 // src/funcs/outboundBatchesRemove.ts
 function outboundBatchesRemove(client, request, options) {
-  return new APIPromise($do93(client, request, options));
+  return new APIPromise($do94(client, request, options));
 }
-async function $do93(client, request, options) {
+async function $do94(client, request, options) {
   const parsed = safeParse(request, (value) => OutboundBatchRemoveRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -58250,20 +58414,20 @@ var init_outboundBatchesRemove = __esm(() => {
 });
 
 // src/mcp-server/tools/outboundBatchesRemove.ts
-var args84, tool$outboundBatchesRemove;
+var args85, tool$outboundBatchesRemove;
 var init_outboundBatchesRemove2 = __esm(() => {
   init_outboundBatchesRemove();
   init_operations();
   init_tools();
-  args84 = {
+  args85 = {
     request: OutboundBatchRemoveRequest$inboundSchema
   };
   tool$outboundBatchesRemove = {
     name: "outbound-batches-remove",
     description: `Delete Requests By List Of Reference Ids`,
-    args: args84,
-    tool: async (client, args85, ctx) => {
-      const [result, apiCall] = await outboundBatchesRemove(client, args85.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args85,
+    tool: async (client, args86, ctx) => {
+      const [result, apiCall] = await outboundBatchesRemove(client, args86.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -58278,9 +58442,9 @@ var init_outboundBatchesRemove2 = __esm(() => {
 
 // src/funcs/outboundBatchesResults.ts
 function outboundBatchesResults(client, request, options) {
-  return new APIPromise($do94(client, request, options));
+  return new APIPromise($do95(client, request, options));
 }
-async function $do94(client, request, options) {
+async function $do95(client, request, options) {
   const parsed = safeParse(request, (value) => OutboundBatchResultsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -58364,20 +58528,20 @@ var init_outboundBatchesResults = __esm(() => {
 });
 
 // src/mcp-server/tools/outboundBatchesResults.ts
-var args85, tool$outboundBatchesResults;
+var args86, tool$outboundBatchesResults;
 var init_outboundBatchesResults2 = __esm(() => {
   init_outboundBatchesResults();
   init_operations();
   init_tools();
-  args85 = {
+  args86 = {
     request: OutboundBatchResultsRequest$inboundSchema
   };
   tool$outboundBatchesResults = {
     name: "outbound-batches-results",
     description: `Fetch Outbound Communication Batch Results`,
-    args: args85,
-    tool: async (client, args86, ctx) => {
-      const [result, apiCall] = await outboundBatchesResults(client, args86.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args86,
+    tool: async (client, args87, ctx) => {
+      const [result, apiCall] = await outboundBatchesResults(client, args87.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -58392,9 +58556,9 @@ var init_outboundBatchesResults2 = __esm(() => {
 
 // src/funcs/outboundBatchesUpdate.ts
 function outboundBatchesUpdate(client, request, options) {
-  return new APIPromise($do95(client, request, options));
+  return new APIPromise($do96(client, request, options));
 }
-async function $do95(client, request, options) {
+async function $do96(client, request, options) {
   const parsed = safeParse(request, (value) => OutboundBatchUpdateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -58474,20 +58638,20 @@ var init_outboundBatchesUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/outboundBatchesUpdate.ts
-var args86, tool$outboundBatchesUpdate;
+var args87, tool$outboundBatchesUpdate;
 var init_outboundBatchesUpdate2 = __esm(() => {
   init_outboundBatchesUpdate();
   init_operations();
   init_tools();
-  args86 = {
+  args87 = {
     request: OutboundBatchUpdateRequest$inboundSchema
   };
   tool$outboundBatchesUpdate = {
     name: "outbound-batches-update",
     description: `Update Outbound Communication Batch`,
-    args: args86,
-    tool: async (client, args87, ctx) => {
-      const [result, apiCall] = await outboundBatchesUpdate(client, args87.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args87,
+    tool: async (client, args88, ctx) => {
+      const [result, apiCall] = await outboundBatchesUpdate(client, args88.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -58502,9 +58666,9 @@ var init_outboundBatchesUpdate2 = __esm(() => {
 
 // src/funcs/outboundBatchesUpload.ts
 function outboundBatchesUpload(client, request, options) {
-  return new APIPromise($do96(client, request, options));
+  return new APIPromise($do97(client, request, options));
 }
-async function $do96(client, request, options) {
+async function $do97(client, request, options) {
   const parsed = safeParse(request, (value) => OutboundBatchUploadRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -58599,20 +58763,20 @@ var init_outboundBatchesUpload = __esm(() => {
 });
 
 // src/mcp-server/tools/outboundBatchesUpload.ts
-var args87, tool$outboundBatchesUpload;
+var args88, tool$outboundBatchesUpload;
 var init_outboundBatchesUpload2 = __esm(() => {
   init_outboundBatchesUpload();
   init_operations();
   init_tools();
-  args87 = {
+  args88 = {
     request: OutboundBatchUploadRequest$inboundSchema
   };
   tool$outboundBatchesUpload = {
     name: "outbound-batches-upload",
     description: `Upload Outbound Communication Batch`,
-    args: args87,
-    tool: async (client, args88, ctx) => {
-      const [result, apiCall] = await outboundBatchesUpload(client, args88.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args88,
+    tool: async (client, args89, ctx) => {
+      const [result, apiCall] = await outboundBatchesUpload(client, args89.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -58627,9 +58791,9 @@ var init_outboundBatchesUpload2 = __esm(() => {
 
 // src/funcs/outboundCampaignsCreate.ts
 function outboundCampaignsCreate(client, request, options) {
-  return new APIPromise($do97(client, request, options));
+  return new APIPromise($do98(client, request, options));
 }
-async function $do97(client, request, options) {
+async function $do98(client, request, options) {
   const parsed = safeParse(request, (value) => OutboundCampaignInput$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -58700,20 +58864,20 @@ var init_outboundCampaignsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/outboundCampaignsCreate.ts
-var args88, tool$outboundCampaignsCreate;
+var args89, tool$outboundCampaignsCreate;
 var init_outboundCampaignsCreate2 = __esm(() => {
   init_outboundCampaignsCreate();
   init_components();
   init_tools();
-  args88 = {
+  args89 = {
     request: OutboundCampaignInput$inboundSchema
   };
   tool$outboundCampaignsCreate = {
     name: "outbound-campaigns-create",
     description: `Create Outbound Communication Campaign`,
-    args: args88,
-    tool: async (client, args89, ctx) => {
-      const [result, apiCall] = await outboundCampaignsCreate(client, args89.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args89,
+    tool: async (client, args90, ctx) => {
+      const [result, apiCall] = await outboundCampaignsCreate(client, args90.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -58728,9 +58892,9 @@ var init_outboundCampaignsCreate2 = __esm(() => {
 
 // src/funcs/outboundCampaignsDelete.ts
 function outboundCampaignsDelete(client, request, options) {
-  return new APIPromise($do98(client, request, options));
+  return new APIPromise($do99(client, request, options));
 }
-async function $do98(client, request, options) {
+async function $do99(client, request, options) {
   const parsed = safeParse(request, (value) => OutboundCampaignDeleteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -58807,20 +58971,20 @@ var init_outboundCampaignsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/outboundCampaignsDelete.ts
-var args89, tool$outboundCampaignsDelete;
+var args90, tool$outboundCampaignsDelete;
 var init_outboundCampaignsDelete2 = __esm(() => {
   init_outboundCampaignsDelete();
   init_operations();
   init_tools();
-  args89 = {
+  args90 = {
     request: OutboundCampaignDeleteRequest$inboundSchema
   };
   tool$outboundCampaignsDelete = {
     name: "outbound-campaigns-delete",
     description: `Delete Outbound Communication Campaign`,
-    args: args89,
-    tool: async (client, args90, ctx) => {
-      const [result, apiCall] = await outboundCampaignsDelete(client, args90.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args90,
+    tool: async (client, args91, ctx) => {
+      const [result, apiCall] = await outboundCampaignsDelete(client, args91.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -58835,9 +58999,9 @@ var init_outboundCampaignsDelete2 = __esm(() => {
 
 // src/funcs/outboundCampaignsGetById.ts
 function outboundCampaignsGetById(client, request, options) {
-  return new APIPromise($do99(client, request, options));
+  return new APIPromise($do100(client, request, options));
 }
-async function $do99(client, request, options) {
+async function $do100(client, request, options) {
   const parsed = safeParse(request, (value) => OutboundCampaignGetByIdRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -58914,20 +59078,20 @@ var init_outboundCampaignsGetById = __esm(() => {
 });
 
 // src/mcp-server/tools/outboundCampaignsGetById.ts
-var args90, tool$outboundCampaignsGetById;
+var args91, tool$outboundCampaignsGetById;
 var init_outboundCampaignsGetById2 = __esm(() => {
   init_outboundCampaignsGetById();
   init_operations();
   init_tools();
-  args90 = {
+  args91 = {
     request: OutboundCampaignGetByIdRequest$inboundSchema
   };
   tool$outboundCampaignsGetById = {
     name: "outbound-campaigns-get-by-id",
     description: `Get Outbound Communication Campaign`,
-    args: args90,
-    tool: async (client, args91, ctx) => {
-      const [result, apiCall] = await outboundCampaignsGetById(client, args91.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args91,
+    tool: async (client, args92, ctx) => {
+      const [result, apiCall] = await outboundCampaignsGetById(client, args92.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -58942,9 +59106,9 @@ var init_outboundCampaignsGetById2 = __esm(() => {
 
 // src/funcs/outboundCampaignsList.ts
 function outboundCampaignsList(client, request, options) {
-  return new APIPromise($do100(client, request, options));
+  return new APIPromise($do101(client, request, options));
 }
-async function $do100(client, request, options) {
+async function $do101(client, request, options) {
   const parsed = safeParse(request, (value) => OutboundCampaignListRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -59027,20 +59191,20 @@ var init_outboundCampaignsList = __esm(() => {
 });
 
 // src/mcp-server/tools/outboundCampaignsList.ts
-var args91, tool$outboundCampaignsList;
+var args92, tool$outboundCampaignsList;
 var init_outboundCampaignsList2 = __esm(() => {
   init_outboundCampaignsList();
   init_operations();
   init_tools();
-  args91 = {
+  args92 = {
     request: OutboundCampaignListRequest$inboundSchema
   };
   tool$outboundCampaignsList = {
     name: "outbound-campaigns-list",
     description: `List Outbound Communication Campaigns`,
-    args: args91,
-    tool: async (client, args92, ctx) => {
-      const [result, apiCall] = await outboundCampaignsList(client, args92.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args92,
+    tool: async (client, args93, ctx) => {
+      const [result, apiCall] = await outboundCampaignsList(client, args93.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -59055,9 +59219,9 @@ var init_outboundCampaignsList2 = __esm(() => {
 
 // src/funcs/outboundCampaignsUpdate.ts
 function outboundCampaignsUpdate(client, request, options) {
-  return new APIPromise($do101(client, request, options));
+  return new APIPromise($do102(client, request, options));
 }
-async function $do101(client, request, options) {
+async function $do102(client, request, options) {
   const parsed = safeParse(request, (value) => OutboundCampaignUpdateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -59137,20 +59301,20 @@ var init_outboundCampaignsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/outboundCampaignsUpdate.ts
-var args92, tool$outboundCampaignsUpdate;
+var args93, tool$outboundCampaignsUpdate;
 var init_outboundCampaignsUpdate2 = __esm(() => {
   init_outboundCampaignsUpdate();
   init_operations();
   init_tools();
-  args92 = {
+  args93 = {
     request: OutboundCampaignUpdateRequest$inboundSchema
   };
   tool$outboundCampaignsUpdate = {
     name: "outbound-campaigns-update",
     description: `Update Outbound Communication Campaign`,
-    args: args92,
-    tool: async (client, args93, ctx) => {
-      const [result, apiCall] = await outboundCampaignsUpdate(client, args93.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args93,
+    tool: async (client, args94, ctx) => {
+      const [result, apiCall] = await outboundCampaignsUpdate(client, args94.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -59165,9 +59329,9 @@ var init_outboundCampaignsUpdate2 = __esm(() => {
 
 // src/funcs/permissionsList.ts
 function permissionsList(client, options) {
-  return new APIPromise($do102(client, options));
+  return new APIPromise($do103(client, options));
 }
-async function $do102(client, options) {
+async function $do103(client, options) {
   const path = pathToFunc("/api/v1/permissions/")();
   const headers = new Headers(compactMap({
     Accept: "application/json"
@@ -59250,9 +59414,9 @@ Get all available permissions in the system.`,
 
 // src/funcs/promptsCreate.ts
 function promptsCreate(client, request, options) {
-  return new APIPromise($do103(client, request, options));
+  return new APIPromise($do104(client, request, options));
 }
-async function $do103(client, request, options) {
+async function $do104(client, request, options) {
   const parsed = safeParse(request, (value) => PromptCreateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -59323,12 +59487,12 @@ var init_promptsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/promptsCreate.ts
-var args93, tool$promptsCreate;
+var args94, tool$promptsCreate;
 var init_promptsCreate2 = __esm(() => {
   init_promptsCreate();
   init_components();
   init_tools();
-  args93 = {
+  args94 = {
     request: PromptCreateRequest$inboundSchema
   };
   tool$promptsCreate = {
@@ -59336,9 +59500,9 @@ var init_promptsCreate2 = __esm(() => {
     description: `Create Prompt
 
 Create a new prompt`,
-    args: args93,
-    tool: async (client, args94, ctx) => {
-      const [result, apiCall] = await promptsCreate(client, args94.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args94,
+    tool: async (client, args95, ctx) => {
+      const [result, apiCall] = await promptsCreate(client, args95.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -59353,9 +59517,9 @@ Create a new prompt`,
 
 // src/funcs/promptsDelete.ts
 function promptsDelete(client, request, options) {
-  return new APIPromise($do104(client, request, options));
+  return new APIPromise($do105(client, request, options));
 }
-async function $do104(client, request, options) {
+async function $do105(client, request, options) {
   const parsed = safeParse(request, (value) => PromptsDeleteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -59436,12 +59600,12 @@ var init_promptsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/promptsDelete.ts
-var args94, tool$promptsDelete;
+var args95, tool$promptsDelete;
 var init_promptsDelete2 = __esm(() => {
   init_promptsDelete();
   init_operations();
   init_tools();
-  args94 = {
+  args95 = {
     request: PromptsDeleteRequest$inboundSchema
   };
   tool$promptsDelete = {
@@ -59449,9 +59613,9 @@ var init_promptsDelete2 = __esm(() => {
     description: `Delete Prompt
 
 Delete a prompt`,
-    args: args94,
-    tool: async (client, args95, ctx) => {
-      const [result, apiCall] = await promptsDelete(client, args95.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args95,
+    tool: async (client, args96, ctx) => {
+      const [result, apiCall] = await promptsDelete(client, args96.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -59466,9 +59630,9 @@ Delete a prompt`,
 
 // src/funcs/promptsGetById.ts
 function promptsGetById(client, request, options) {
-  return new APIPromise($do105(client, request, options));
+  return new APIPromise($do106(client, request, options));
 }
-async function $do105(client, request, options) {
+async function $do106(client, request, options) {
   const parsed = safeParse(request, (value) => PromptsGetByIdRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -59545,12 +59709,12 @@ var init_promptsGetById = __esm(() => {
 });
 
 // src/mcp-server/tools/promptsGetById.ts
-var args95, tool$promptsGetById;
+var args96, tool$promptsGetById;
 var init_promptsGetById2 = __esm(() => {
   init_promptsGetById();
   init_operations();
   init_tools();
-  args95 = {
+  args96 = {
     request: PromptsGetByIdRequest$inboundSchema
   };
   tool$promptsGetById = {
@@ -59558,9 +59722,9 @@ var init_promptsGetById2 = __esm(() => {
     description: `Get Prompt By Id
 
 Get a prompt by ID`,
-    args: args95,
-    tool: async (client, args96, ctx) => {
-      const [result, apiCall] = await promptsGetById(client, args96.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args96,
+    tool: async (client, args97, ctx) => {
+      const [result, apiCall] = await promptsGetById(client, args97.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -59575,9 +59739,9 @@ Get a prompt by ID`,
 
 // src/funcs/promptsList.ts
 function promptsList(client, request, options) {
-  return new APIPromise($do106(client, request, options));
+  return new APIPromise($do107(client, request, options));
 }
-async function $do106(client, request, options) {
+async function $do107(client, request, options) {
   const parsed = safeParse(request, (value) => PromptsListRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -59660,12 +59824,12 @@ var init_promptsList = __esm(() => {
 });
 
 // src/mcp-server/tools/promptsList.ts
-var args96, tool$promptsList;
+var args97, tool$promptsList;
 var init_promptsList2 = __esm(() => {
   init_promptsList();
   init_operations();
   init_tools();
-  args96 = {
+  args97 = {
     request: PromptsListRequest$inboundSchema
   };
   tool$promptsList = {
@@ -59673,9 +59837,9 @@ var init_promptsList2 = __esm(() => {
     description: `Prompt List
 
 List the existing prompts`,
-    args: args96,
-    tool: async (client, args97, ctx) => {
-      const [result, apiCall] = await promptsList(client, args97.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args97,
+    tool: async (client, args98, ctx) => {
+      const [result, apiCall] = await promptsList(client, args98.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -59690,9 +59854,9 @@ List the existing prompts`,
 
 // src/funcs/promptsPromptGetSupportedLlms.ts
 function promptsPromptGetSupportedLlms(client, options) {
-  return new APIPromise($do107(client, options));
+  return new APIPromise($do108(client, options));
 }
-async function $do107(client, options) {
+async function $do108(client, options) {
   const path = pathToFunc("/api/v1/prompts/llms/supported")();
   const headers = new Headers(compactMap({
     Accept: "application/json"
@@ -59775,9 +59939,9 @@ Get supported LLM configs.`,
 
 // src/funcs/promptsPromptsHistory.ts
 function promptsPromptsHistory(client, request, options) {
-  return new APIPromise($do108(client, request, options));
+  return new APIPromise($do109(client, request, options));
 }
-async function $do108(client, request, options) {
+async function $do109(client, request, options) {
   const parsed = safeParse(request, (value) => PromptsHistoryRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -59855,12 +60019,12 @@ var init_promptsPromptsHistory = __esm(() => {
 });
 
 // src/mcp-server/tools/promptsPromptsHistory.ts
-var args97, tool$promptsPromptsHistory;
+var args98, tool$promptsPromptsHistory;
 var init_promptsPromptsHistory2 = __esm(() => {
   init_promptsPromptsHistory();
   init_operations();
   init_tools();
-  args97 = {
+  args98 = {
     request: PromptsHistoryRequest$inboundSchema
   };
   tool$promptsPromptsHistory = {
@@ -59868,9 +60032,9 @@ var init_promptsPromptsHistory2 = __esm(() => {
     description: `Get Prompt History
 
 Get a list of historical versions of a prompt by its ID`,
-    args: args97,
-    tool: async (client, args98, ctx) => {
-      const [result, apiCall] = await promptsPromptsHistory(client, args98.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args98,
+    tool: async (client, args99, ctx) => {
+      const [result, apiCall] = await promptsPromptsHistory(client, args99.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -59885,9 +60049,9 @@ Get a list of historical versions of a prompt by its ID`,
 
 // src/funcs/promptsUpdate.ts
 function promptsUpdate(client, request, options) {
-  return new APIPromise($do109(client, request, options));
+  return new APIPromise($do110(client, request, options));
 }
-async function $do109(client, request, options) {
+async function $do110(client, request, options) {
   const parsed = safeParse(request, (value) => PromptUpdateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -59958,12 +60122,12 @@ var init_promptsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/promptsUpdate.ts
-var args98, tool$promptsUpdate;
+var args99, tool$promptsUpdate;
 var init_promptsUpdate2 = __esm(() => {
   init_promptsUpdate();
   init_components();
   init_tools();
-  args98 = {
+  args99 = {
     request: PromptUpdateRequest$inboundSchema
   };
   tool$promptsUpdate = {
@@ -59971,9 +60135,9 @@ var init_promptsUpdate2 = __esm(() => {
     description: `Update Prompt
 
 Update an existing prompt`,
-    args: args98,
-    tool: async (client, args99, ctx) => {
-      const [result, apiCall] = await promptsUpdate(client, args99.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args99,
+    tool: async (client, args100, ctx) => {
+      const [result, apiCall] = await promptsUpdate(client, args100.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -59988,9 +60152,9 @@ Update an existing prompt`,
 
 // src/funcs/pronunciationsPronunciationsDeleteCsv.ts
 function pronunciationsPronunciationsDeleteCsv(client, options) {
-  return new APIPromise($do110(client, options));
+  return new APIPromise($do111(client, options));
 }
-async function $do110(client, options) {
+async function $do111(client, options) {
   const path = pathToFunc("/api/v1/pronunciations/csv")();
   const headers = new Headers(compactMap({
     Accept: "*/*"
@@ -60069,9 +60233,9 @@ var init_pronunciationsPronunciationsDeleteCsv2 = __esm(() => {
 
 // src/funcs/pronunciationsPronunciationsDownloadCsv.ts
 function pronunciationsPronunciationsDownloadCsv(client, options) {
-  return new APIPromise($do111(client, options));
+  return new APIPromise($do112(client, options));
 }
-async function $do111(client, options) {
+async function $do112(client, options) {
   const path = pathToFunc("/api/v1/pronunciations/csv")();
   const headers = new Headers(compactMap({
     Accept: "text/csv"
@@ -60158,9 +60322,9 @@ var init_pronunciationsPronunciationsDownloadCsv2 = __esm(() => {
 
 // src/funcs/pronunciationsPronunciationsGet.ts
 function pronunciationsPronunciationsGet(client, options) {
-  return new APIPromise($do112(client, options));
+  return new APIPromise($do113(client, options));
 }
-async function $do112(client, options) {
+async function $do113(client, options) {
   const path = pathToFunc("/api/v1/pronunciations")();
   const headers = new Headers(compactMap({
     Accept: "application/json"
@@ -60240,9 +60404,9 @@ var init_pronunciationsPronunciationsGet2 = __esm(() => {
 
 // src/funcs/pronunciationsPronunciationsGetMetadata.ts
 function pronunciationsPronunciationsGetMetadata(client, options) {
-  return new APIPromise($do113(client, options));
+  return new APIPromise($do114(client, options));
 }
-async function $do113(client, options) {
+async function $do114(client, options) {
   const path = pathToFunc("/api/v1/pronunciations/metadata")();
   const headers = new Headers(compactMap({
     Accept: "application/json"
@@ -60322,9 +60486,9 @@ var init_pronunciationsPronunciationsGetMetadata2 = __esm(() => {
 
 // src/funcs/pronunciationsPronunciationsUploadCsv.ts
 function pronunciationsPronunciationsUploadCsv(client, request, options) {
-  return new APIPromise($do114(client, request, options));
+  return new APIPromise($do115(client, request, options));
 }
-async function $do114(client, request, options) {
+async function $do115(client, request, options) {
   const parsed = safeParse(request, (value) => BodyPronunciationsUploadCsv$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -60406,20 +60570,20 @@ var init_pronunciationsPronunciationsUploadCsv = __esm(() => {
 });
 
 // src/mcp-server/tools/pronunciationsPronunciationsUploadCsv.ts
-var args99, tool$pronunciationsPronunciationsUploadCsv;
+var args100, tool$pronunciationsPronunciationsUploadCsv;
 var init_pronunciationsPronunciationsUploadCsv2 = __esm(() => {
   init_pronunciationsPronunciationsUploadCsv();
   init_components();
   init_tools();
-  args99 = {
+  args100 = {
     request: BodyPronunciationsUploadCsv$inboundSchema
   };
   tool$pronunciationsPronunciationsUploadCsv = {
     name: "pronunciations-pronunciations-upload-csv",
     description: `Upload Pronunciations Csv`,
-    args: args99,
-    tool: async (client, args100, ctx) => {
-      const [result, apiCall] = await pronunciationsPronunciationsUploadCsv(client, args100.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args100,
+    tool: async (client, args101, ctx) => {
+      const [result, apiCall] = await pronunciationsPronunciationsUploadCsv(client, args101.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -60434,9 +60598,9 @@ var init_pronunciationsPronunciationsUploadCsv2 = __esm(() => {
 
 // src/funcs/rolesCreate.ts
 function rolesCreate(client, request, options) {
-  return new APIPromise($do115(client, request, options));
+  return new APIPromise($do116(client, request, options));
 }
-async function $do115(client, request, options) {
+async function $do116(client, request, options) {
   const parsed = safeParse(request, (value) => RoleCreateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -60507,12 +60671,12 @@ var init_rolesCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/rolesCreate.ts
-var args100, tool$rolesCreate;
+var args101, tool$rolesCreate;
 var init_rolesCreate2 = __esm(() => {
   init_rolesCreate();
   init_components();
   init_tools();
-  args100 = {
+  args101 = {
     request: RoleCreateRequest$inboundSchema
   };
   tool$rolesCreate = {
@@ -60520,9 +60684,9 @@ var init_rolesCreate2 = __esm(() => {
     description: `Create Role
 
 Create a new role.`,
-    args: args100,
-    tool: async (client, args101, ctx) => {
-      const [result, apiCall] = await rolesCreate(client, args101.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args101,
+    tool: async (client, args102, ctx) => {
+      const [result, apiCall] = await rolesCreate(client, args102.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -60537,9 +60701,9 @@ Create a new role.`,
 
 // src/funcs/rolesDelete.ts
 function rolesDelete(client, request, options) {
-  return new APIPromise($do116(client, request, options));
+  return new APIPromise($do117(client, request, options));
 }
-async function $do116(client, request, options) {
+async function $do117(client, request, options) {
   const parsed = safeParse(request, (value) => RolesDeleteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -60621,12 +60785,12 @@ var init_rolesDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/rolesDelete.ts
-var args101, tool$rolesDelete;
+var args102, tool$rolesDelete;
 var init_rolesDelete2 = __esm(() => {
   init_rolesDelete();
   init_operations();
   init_tools();
-  args101 = {
+  args102 = {
     request: RolesDeleteRequest$inboundSchema
   };
   tool$rolesDelete = {
@@ -60634,9 +60798,9 @@ var init_rolesDelete2 = __esm(() => {
     description: `Delete Role
 
 Delete a role. Optionally, reassign existing users with that role to a new role.`,
-    args: args101,
-    tool: async (client, args102, ctx) => {
-      const [result, apiCall] = await rolesDelete(client, args102.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args102,
+    tool: async (client, args103, ctx) => {
+      const [result, apiCall] = await rolesDelete(client, args103.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -60651,9 +60815,9 @@ Delete a role. Optionally, reassign existing users with that role to a new role.
 
 // src/funcs/rolesGetById.ts
 function rolesGetById(client, request, options) {
-  return new APIPromise($do117(client, request, options));
+  return new APIPromise($do118(client, request, options));
 }
-async function $do117(client, request, options) {
+async function $do118(client, request, options) {
   const parsed = safeParse(request, (value) => RolesGetByIdRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -60730,12 +60894,12 @@ var init_rolesGetById = __esm(() => {
 });
 
 // src/mcp-server/tools/rolesGetById.ts
-var args102, tool$rolesGetById;
+var args103, tool$rolesGetById;
 var init_rolesGetById2 = __esm(() => {
   init_rolesGetById();
   init_operations();
   init_tools();
-  args102 = {
+  args103 = {
     request: RolesGetByIdRequest$inboundSchema
   };
   tool$rolesGetById = {
@@ -60743,9 +60907,9 @@ var init_rolesGetById2 = __esm(() => {
     description: `Get Role
 
 Fetch a given role.`,
-    args: args102,
-    tool: async (client, args103, ctx) => {
-      const [result, apiCall] = await rolesGetById(client, args103.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args103,
+    tool: async (client, args104, ctx) => {
+      const [result, apiCall] = await rolesGetById(client, args104.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -60760,9 +60924,9 @@ Fetch a given role.`,
 
 // src/funcs/rolesList.ts
 function rolesList(client, request, options) {
-  return new APIPromise($do118(client, request, options));
+  return new APIPromise($do119(client, request, options));
 }
-async function $do118(client, request, options) {
+async function $do119(client, request, options) {
   const parsed = safeParse(request, (value) => RolesListRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -60845,12 +61009,12 @@ var init_rolesList = __esm(() => {
 });
 
 // src/mcp-server/tools/rolesList.ts
-var args103, tool$rolesList;
+var args104, tool$rolesList;
 var init_rolesList2 = __esm(() => {
   init_rolesList();
   init_operations();
   init_tools();
-  args103 = {
+  args104 = {
     request: RolesListRequest$inboundSchema
   };
   tool$rolesList = {
@@ -60858,9 +61022,9 @@ var init_rolesList2 = __esm(() => {
     description: `List Roles
 
 List the existing roles.`,
-    args: args103,
-    tool: async (client, args104, ctx) => {
-      const [result, apiCall] = await rolesList(client, args104.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args104,
+    tool: async (client, args105, ctx) => {
+      const [result, apiCall] = await rolesList(client, args105.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -60875,9 +61039,9 @@ List the existing roles.`,
 
 // src/funcs/rolesUpdate.ts
 function rolesUpdate(client, request, options) {
-  return new APIPromise($do119(client, request, options));
+  return new APIPromise($do120(client, request, options));
 }
-async function $do119(client, request, options) {
+async function $do120(client, request, options) {
   const parsed = safeParse(request, (value) => RoleUpdateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -60948,12 +61112,12 @@ var init_rolesUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/rolesUpdate.ts
-var args104, tool$rolesUpdate;
+var args105, tool$rolesUpdate;
 var init_rolesUpdate2 = __esm(() => {
   init_rolesUpdate();
   init_components();
   init_tools();
-  args104 = {
+  args105 = {
     request: RoleUpdateRequest$inboundSchema
   };
   tool$rolesUpdate = {
@@ -60961,9 +61125,9 @@ var init_rolesUpdate2 = __esm(() => {
     description: `Update Role
 
 Update an existing role.`,
-    args: args104,
-    tool: async (client, args105, ctx) => {
-      const [result, apiCall] = await rolesUpdate(client, args105.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args105,
+    tool: async (client, args106, ctx) => {
+      const [result, apiCall] = await rolesUpdate(client, args106.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -60978,9 +61142,9 @@ Update an existing role.`,
 
 // src/funcs/servicesCreate.ts
 function servicesCreate(client, request, options) {
-  return new APIPromise($do120(client, request, options));
+  return new APIPromise($do121(client, request, options));
 }
-async function $do120(client, request, options) {
+async function $do121(client, request, options) {
   const parsed = safeParse(request, (value) => ServiceCreateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -61051,12 +61215,12 @@ var init_servicesCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/servicesCreate.ts
-var args105, tool$servicesCreate;
+var args106, tool$servicesCreate;
 var init_servicesCreate2 = __esm(() => {
   init_servicesCreate();
   init_components();
   init_tools();
-  args105 = {
+  args106 = {
     request: ServiceCreateRequest$inboundSchema
   };
   tool$servicesCreate = {
@@ -61064,9 +61228,9 @@ var init_servicesCreate2 = __esm(() => {
     description: `Create Service
 
 Create a new service.`,
-    args: args105,
-    tool: async (client, args106, ctx) => {
-      const [result, apiCall] = await servicesCreate(client, args106.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args106,
+    tool: async (client, args107, ctx) => {
+      const [result, apiCall] = await servicesCreate(client, args107.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -61081,9 +61245,9 @@ Create a new service.`,
 
 // src/funcs/servicesDelete.ts
 function servicesDelete(client, request, options) {
-  return new APIPromise($do121(client, request, options));
+  return new APIPromise($do122(client, request, options));
 }
-async function $do121(client, request, options) {
+async function $do122(client, request, options) {
   const parsed = safeParse(request, (value) => ServiceDeleteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -61164,12 +61328,12 @@ var init_servicesDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/servicesDelete.ts
-var args106, tool$servicesDelete;
+var args107, tool$servicesDelete;
 var init_servicesDelete2 = __esm(() => {
   init_servicesDelete();
   init_operations();
   init_tools();
-  args106 = {
+  args107 = {
     request: ServiceDeleteRequest$inboundSchema
   };
   tool$servicesDelete = {
@@ -61177,9 +61341,9 @@ var init_servicesDelete2 = __esm(() => {
     description: `Delete Service
 
 Delete a service. A service with linked tools cannot be deleted.`,
-    args: args106,
-    tool: async (client, args107, ctx) => {
-      const [result, apiCall] = await servicesDelete(client, args107.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args107,
+    tool: async (client, args108, ctx) => {
+      const [result, apiCall] = await servicesDelete(client, args108.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -61194,9 +61358,9 @@ Delete a service. A service with linked tools cannot be deleted.`,
 
 // src/funcs/servicesGetById.ts
 function servicesGetById(client, request, options) {
-  return new APIPromise($do122(client, request, options));
+  return new APIPromise($do123(client, request, options));
 }
-async function $do122(client, request, options) {
+async function $do123(client, request, options) {
   const parsed = safeParse(request, (value) => ServicesGetByIdRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -61273,12 +61437,12 @@ var init_servicesGetById = __esm(() => {
 });
 
 // src/mcp-server/tools/servicesGetById.ts
-var args107, tool$servicesGetById;
+var args108, tool$servicesGetById;
 var init_servicesGetById2 = __esm(() => {
   init_servicesGetById();
   init_operations();
   init_tools();
-  args107 = {
+  args108 = {
     request: ServicesGetByIdRequest$inboundSchema
   };
   tool$servicesGetById = {
@@ -61286,9 +61450,9 @@ var init_servicesGetById2 = __esm(() => {
     description: `Get Service By Id
 
 Get a service by its ID`,
-    args: args107,
-    tool: async (client, args108, ctx) => {
-      const [result, apiCall] = await servicesGetById(client, args108.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args108,
+    tool: async (client, args109, ctx) => {
+      const [result, apiCall] = await servicesGetById(client, args109.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -61303,9 +61467,9 @@ Get a service by its ID`,
 
 // src/funcs/servicesList.ts
 function servicesList(client, request, options) {
-  return new APIPromise($do123(client, request, options));
+  return new APIPromise($do124(client, request, options));
 }
-async function $do123(client, request, options) {
+async function $do124(client, request, options) {
   const parsed = safeParse(request, (value) => ServiceListRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -61388,12 +61552,12 @@ var init_servicesList = __esm(() => {
 });
 
 // src/mcp-server/tools/servicesList.ts
-var args108, tool$servicesList;
+var args109, tool$servicesList;
 var init_servicesList2 = __esm(() => {
   init_servicesList();
   init_operations();
   init_tools();
-  args108 = {
+  args109 = {
     request: ServiceListRequest$inboundSchema
   };
   tool$servicesList = {
@@ -61401,9 +61565,9 @@ var init_servicesList2 = __esm(() => {
     description: `Service List
 
 List the existing services`,
-    args: args108,
-    tool: async (client, args109, ctx) => {
-      const [result, apiCall] = await servicesList(client, args109.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args109,
+    tool: async (client, args110, ctx) => {
+      const [result, apiCall] = await servicesList(client, args110.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -61418,9 +61582,9 @@ List the existing services`,
 
 // src/funcs/servicesUpdate.ts
 function servicesUpdate(client, request, options) {
-  return new APIPromise($do124(client, request, options));
+  return new APIPromise($do125(client, request, options));
 }
-async function $do124(client, request, options) {
+async function $do125(client, request, options) {
   const parsed = safeParse(request, (value) => ServiceUpdateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -61491,12 +61655,12 @@ var init_servicesUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/servicesUpdate.ts
-var args109, tool$servicesUpdate;
+var args110, tool$servicesUpdate;
 var init_servicesUpdate2 = __esm(() => {
   init_servicesUpdate();
   init_components();
   init_tools();
-  args109 = {
+  args110 = {
     request: ServiceUpdateRequest$inboundSchema
   };
   tool$servicesUpdate = {
@@ -61504,9 +61668,9 @@ var init_servicesUpdate2 = __esm(() => {
     description: `Update Service
 
 Update an existing service.`,
-    args: args109,
-    tool: async (client, args110, ctx) => {
-      const [result, apiCall] = await servicesUpdate(client, args110.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args110,
+    tool: async (client, args111, ctx) => {
+      const [result, apiCall] = await servicesUpdate(client, args111.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -61521,9 +61685,9 @@ Update an existing service.`,
 
 // src/funcs/sessionDebugGetSessionDataBySessionId.ts
 function sessionDebugGetSessionDataBySessionId(client, request, options) {
-  return new APIPromise($do125(client, request, options));
+  return new APIPromise($do126(client, request, options));
 }
-async function $do125(client, request, options) {
+async function $do126(client, request, options) {
   const parsed = safeParse(request, (value) => GetSessionDataBySessionIdRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -61600,20 +61764,20 @@ var init_sessionDebugGetSessionDataBySessionId = __esm(() => {
 });
 
 // src/mcp-server/tools/sessionDebugGetSessionDataBySessionId.ts
-var args110, tool$sessionDebugGetSessionDataBySessionId;
+var args111, tool$sessionDebugGetSessionDataBySessionId;
 var init_sessionDebugGetSessionDataBySessionId2 = __esm(() => {
   init_sessionDebugGetSessionDataBySessionId();
   init_operations();
   init_tools();
-  args110 = {
+  args111 = {
     request: GetSessionDataBySessionIdRequest$inboundSchema
   };
   tool$sessionDebugGetSessionDataBySessionId = {
     name: "session-debug-get-session-data-by-session-id",
     description: `Get Session Data By Session Id`,
-    args: args110,
-    tool: async (client, args111, ctx) => {
-      const [result, apiCall] = await sessionDebugGetSessionDataBySessionId(client, args111.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args111,
+    tool: async (client, args112, ctx) => {
+      const [result, apiCall] = await sessionDebugGetSessionDataBySessionId(client, args112.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -61628,9 +61792,9 @@ var init_sessionDebugGetSessionDataBySessionId2 = __esm(() => {
 
 // src/funcs/sessionDebugGetSessionDataBySid.ts
 function sessionDebugGetSessionDataBySid(client, request, options) {
-  return new APIPromise($do126(client, request, options));
+  return new APIPromise($do127(client, request, options));
 }
-async function $do126(client, request, options) {
+async function $do127(client, request, options) {
   const parsed = safeParse(request, (value) => GetSessionDataBySidRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -61705,20 +61869,20 @@ var init_sessionDebugGetSessionDataBySid = __esm(() => {
 });
 
 // src/mcp-server/tools/sessionDebugGetSessionDataBySid.ts
-var args111, tool$sessionDebugGetSessionDataBySid;
+var args112, tool$sessionDebugGetSessionDataBySid;
 var init_sessionDebugGetSessionDataBySid2 = __esm(() => {
   init_sessionDebugGetSessionDataBySid();
   init_operations();
   init_tools();
-  args111 = {
+  args112 = {
     request: GetSessionDataBySidRequest$inboundSchema
   };
   tool$sessionDebugGetSessionDataBySid = {
     name: "session-debug-get-session-data-by-sid",
     description: `Get Session Data By Sid`,
-    args: args111,
-    tool: async (client, args112, ctx) => {
-      const [result, apiCall] = await sessionDebugGetSessionDataBySid(client, args112.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args112,
+    tool: async (client, args113, ctx) => {
+      const [result, apiCall] = await sessionDebugGetSessionDataBySid(client, args113.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -61733,9 +61897,9 @@ var init_sessionDebugGetSessionDataBySid2 = __esm(() => {
 
 // src/funcs/sessionDebugGetSessionToolCallResultById.ts
 function sessionDebugGetSessionToolCallResultById(client, request, options) {
-  return new APIPromise($do127(client, request, options));
+  return new APIPromise($do128(client, request, options));
 }
-async function $do127(client, request, options) {
+async function $do128(client, request, options) {
   const parsed = safeParse(request, (value) => GetSessionToolCallResultByIdRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -61816,20 +61980,20 @@ var init_sessionDebugGetSessionToolCallResultById = __esm(() => {
 });
 
 // src/mcp-server/tools/sessionDebugGetSessionToolCallResultById.ts
-var args112, tool$sessionDebugGetSessionToolCallResultById;
+var args113, tool$sessionDebugGetSessionToolCallResultById;
 var init_sessionDebugGetSessionToolCallResultById2 = __esm(() => {
   init_sessionDebugGetSessionToolCallResultById();
   init_operations();
   init_tools();
-  args112 = {
+  args113 = {
     request: GetSessionToolCallResultByIdRequest$inboundSchema
   };
   tool$sessionDebugGetSessionToolCallResultById = {
     name: "session-debug-get-session-tool-call-result-by-id",
     description: `Get Session Tool Call Result By Id`,
-    args: args112,
-    tool: async (client, args113, ctx) => {
-      const [result, apiCall] = await sessionDebugGetSessionToolCallResultById(client, args113.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args113,
+    tool: async (client, args114, ctx) => {
+      const [result, apiCall] = await sessionDebugGetSessionToolCallResultById(client, args114.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -61844,9 +62008,9 @@ var init_sessionDebugGetSessionToolCallResultById2 = __esm(() => {
 
 // src/funcs/sessionLabelsCreate.ts
 function sessionLabelsCreate(client, request, options) {
-  return new APIPromise($do128(client, request, options));
+  return new APIPromise($do129(client, request, options));
 }
-async function $do128(client, request, options) {
+async function $do129(client, request, options) {
   const parsed = safeParse(request, (value) => SessionLabelCreate$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -61917,12 +62081,12 @@ var init_sessionLabelsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/sessionLabelsCreate.ts
-var args113, tool$sessionLabelsCreate;
+var args114, tool$sessionLabelsCreate;
 var init_sessionLabelsCreate2 = __esm(() => {
   init_sessionLabelsCreate();
   init_components();
   init_tools();
-  args113 = {
+  args114 = {
     request: SessionLabelCreate$inboundSchema
   };
   tool$sessionLabelsCreate = {
@@ -61930,9 +62094,9 @@ var init_sessionLabelsCreate2 = __esm(() => {
     description: `Create Label
 
 Create a new label`,
-    args: args113,
-    tool: async (client, args114, ctx) => {
-      const [result, apiCall] = await sessionLabelsCreate(client, args114.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args114,
+    tool: async (client, args115, ctx) => {
+      const [result, apiCall] = await sessionLabelsCreate(client, args115.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -61947,9 +62111,9 @@ Create a new label`,
 
 // src/funcs/sessionLabelsGetById.ts
 function sessionLabelsGetById(client, request, options) {
-  return new APIPromise($do129(client, request, options));
+  return new APIPromise($do130(client, request, options));
 }
-async function $do129(client, request, options) {
+async function $do130(client, request, options) {
   const parsed = safeParse(request, (value) => SessionLabelGetByIdRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -62023,20 +62187,20 @@ var init_sessionLabelsGetById = __esm(() => {
 });
 
 // src/mcp-server/tools/sessionLabelsGetById.ts
-var args114, tool$sessionLabelsGetById;
+var args115, tool$sessionLabelsGetById;
 var init_sessionLabelsGetById2 = __esm(() => {
   init_sessionLabelsGetById();
   init_operations();
   init_tools();
-  args114 = {
+  args115 = {
     request: SessionLabelGetByIdRequest$inboundSchema
   };
   tool$sessionLabelsGetById = {
     name: "session-labels-get-by-id",
     description: `Get Label By Id`,
-    args: args114,
-    tool: async (client, args115, ctx) => {
-      const [result, apiCall] = await sessionLabelsGetById(client, args115.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args115,
+    tool: async (client, args116, ctx) => {
+      const [result, apiCall] = await sessionLabelsGetById(client, args116.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -62051,9 +62215,9 @@ var init_sessionLabelsGetById2 = __esm(() => {
 
 // src/funcs/sessionLabelsList.ts
 function sessionLabelsList(client, request, options) {
-  return new APIPromise($do130(client, request, options));
+  return new APIPromise($do131(client, request, options));
 }
-async function $do130(client, request, options) {
+async function $do131(client, request, options) {
   const parsed = safeParse(request, (value) => SessionLabelsListRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -62136,20 +62300,20 @@ var init_sessionLabelsList = __esm(() => {
 });
 
 // src/mcp-server/tools/sessionLabelsList.ts
-var args115, tool$sessionLabelsList;
+var args116, tool$sessionLabelsList;
 var init_sessionLabelsList2 = __esm(() => {
   init_sessionLabelsList();
   init_operations();
   init_tools();
-  args115 = {
+  args116 = {
     request: SessionLabelsListRequest$inboundSchema
   };
   tool$sessionLabelsList = {
     name: "session-labels-list",
     description: `Session Labels List`,
-    args: args115,
-    tool: async (client, args116, ctx) => {
-      const [result, apiCall] = await sessionLabelsList(client, args116.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args116,
+    tool: async (client, args117, ctx) => {
+      const [result, apiCall] = await sessionLabelsList(client, args117.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -62164,9 +62328,9 @@ var init_sessionLabelsList2 = __esm(() => {
 
 // src/funcs/sessionsFullSummaryGetById.ts
 function sessionsFullSummaryGetById(client, request, options) {
-  return new APIPromise($do131(client, request, options));
+  return new APIPromise($do132(client, request, options));
 }
-async function $do131(client, request, options) {
+async function $do132(client, request, options) {
   const parsed = safeParse(request, (value) => SessionFullSummaryGetByIdRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -62243,20 +62407,20 @@ var init_sessionsFullSummaryGetById = __esm(() => {
 });
 
 // src/mcp-server/tools/sessionsFullSummaryGetById.ts
-var args116, tool$sessionsFullSummaryGetById;
+var args117, tool$sessionsFullSummaryGetById;
 var init_sessionsFullSummaryGetById2 = __esm(() => {
   init_sessionsFullSummaryGetById();
   init_operations();
   init_tools();
-  args116 = {
+  args117 = {
     request: SessionFullSummaryGetByIdRequest$inboundSchema
   };
   tool$sessionsFullSummaryGetById = {
     name: "sessions-full-summary-get-by-id",
     description: `Get Full Session Summary By Id`,
-    args: args116,
-    tool: async (client, args117, ctx) => {
-      const [result, apiCall] = await sessionsFullSummaryGetById(client, args117.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args117,
+    tool: async (client, args118, ctx) => {
+      const [result, apiCall] = await sessionsFullSummaryGetById(client, args118.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -62271,9 +62435,9 @@ var init_sessionsFullSummaryGetById2 = __esm(() => {
 
 // src/funcs/sessionsGenerateSessionRecordingUrls.ts
 function sessionsGenerateSessionRecordingUrls(client, request, options) {
-  return new APIPromise($do132(client, request, options));
+  return new APIPromise($do133(client, request, options));
 }
-async function $do132(client, request, options) {
+async function $do133(client, request, options) {
   const parsed = safeParse(request, (value) => GenerateSessionRecordingUrlsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -62350,20 +62514,20 @@ var init_sessionsGenerateSessionRecordingUrls = __esm(() => {
 });
 
 // src/mcp-server/tools/sessionsGenerateSessionRecordingUrls.ts
-var args117, tool$sessionsGenerateSessionRecordingUrls;
+var args118, tool$sessionsGenerateSessionRecordingUrls;
 var init_sessionsGenerateSessionRecordingUrls2 = __esm(() => {
   init_sessionsGenerateSessionRecordingUrls();
   init_operations();
   init_tools();
-  args117 = {
+  args118 = {
     request: GenerateSessionRecordingUrlsRequest$inboundSchema
   };
   tool$sessionsGenerateSessionRecordingUrls = {
     name: "sessions-generate-session-recording-urls",
     description: `Generate Recording Urls`,
-    args: args117,
-    tool: async (client, args118, ctx) => {
-      const [result, apiCall] = await sessionsGenerateSessionRecordingUrls(client, args118.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args118,
+    tool: async (client, args119, ctx) => {
+      const [result, apiCall] = await sessionsGenerateSessionRecordingUrls(client, args119.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -62378,9 +62542,9 @@ var init_sessionsGenerateSessionRecordingUrls2 = __esm(() => {
 
 // src/funcs/sessionsGetById.ts
 function sessionsGetById(client, request, options) {
-  return new APIPromise($do133(client, request, options));
+  return new APIPromise($do134(client, request, options));
 }
-async function $do133(client, request, options) {
+async function $do134(client, request, options) {
   const parsed = safeParse(request, (value) => SessionGetByIdRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -62457,20 +62621,20 @@ var init_sessionsGetById = __esm(() => {
 });
 
 // src/mcp-server/tools/sessionsGetById.ts
-var args118, tool$sessionsGetById;
+var args119, tool$sessionsGetById;
 var init_sessionsGetById2 = __esm(() => {
   init_sessionsGetById();
   init_operations();
   init_tools();
-  args118 = {
+  args119 = {
     request: SessionGetByIdRequest$inboundSchema
   };
   tool$sessionsGetById = {
     name: "sessions-get-by-id",
     description: `Get A Single Session By Id`,
-    args: args118,
-    tool: async (client, args119, ctx) => {
-      const [result, apiCall] = await sessionsGetById(client, args119.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args119,
+    tool: async (client, args120, ctx) => {
+      const [result, apiCall] = await sessionsGetById(client, args120.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -62485,9 +62649,9 @@ var init_sessionsGetById2 = __esm(() => {
 
 // src/funcs/sessionsLatencyGetById.ts
 function sessionsLatencyGetById(client, request, options) {
-  return new APIPromise($do134(client, request, options));
+  return new APIPromise($do135(client, request, options));
 }
-async function $do134(client, request, options) {
+async function $do135(client, request, options) {
   const parsed = safeParse(request, (value) => SessionLatencyGetByIdRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -62564,20 +62728,20 @@ var init_sessionsLatencyGetById = __esm(() => {
 });
 
 // src/mcp-server/tools/sessionsLatencyGetById.ts
-var args119, tool$sessionsLatencyGetById;
+var args120, tool$sessionsLatencyGetById;
 var init_sessionsLatencyGetById2 = __esm(() => {
   init_sessionsLatencyGetById();
   init_operations();
   init_tools();
-  args119 = {
+  args120 = {
     request: SessionLatencyGetByIdRequest$inboundSchema
   };
   tool$sessionsLatencyGetById = {
     name: "sessions-latency-get-by-id",
     description: `Inspect Latency For Session`,
-    args: args119,
-    tool: async (client, args120, ctx) => {
-      const [result, apiCall] = await sessionsLatencyGetById(client, args120.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args120,
+    tool: async (client, args121, ctx) => {
+      const [result, apiCall] = await sessionsLatencyGetById(client, args121.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -62592,9 +62756,9 @@ var init_sessionsLatencyGetById2 = __esm(() => {
 
 // src/funcs/sessionsList.ts
 function sessionsList(client, request, options) {
-  return new APIPromise($do135(client, request, options));
+  return new APIPromise($do136(client, request, options));
 }
-async function $do135(client, request, options) {
+async function $do136(client, request, options) {
   const parsed = safeParse(request, (value) => SessionsListRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -62677,20 +62841,20 @@ var init_sessionsList = __esm(() => {
 });
 
 // src/mcp-server/tools/sessionsList.ts
-var args120, tool$sessionsList;
+var args121, tool$sessionsList;
 var init_sessionsList2 = __esm(() => {
   init_sessionsList();
   init_operations();
   init_tools();
-  args120 = {
+  args121 = {
     request: SessionsListRequest$inboundSchema
   };
   tool$sessionsList = {
     name: "sessions-list",
     description: `Sessions List`,
-    args: args120,
-    tool: async (client, args121, ctx) => {
-      const [result, apiCall] = await sessionsList(client, args121.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args121,
+    tool: async (client, args122, ctx) => {
+      const [result, apiCall] = await sessionsList(client, args122.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -62705,9 +62869,9 @@ var init_sessionsList2 = __esm(() => {
 
 // src/funcs/sessionsSessionRecordingStream.ts
 function sessionsSessionRecordingStream(client, request, options) {
-  return new APIPromise($do136(client, request, options));
+  return new APIPromise($do137(client, request, options));
 }
-async function $do136(client, request, options) {
+async function $do137(client, request, options) {
   const parsed = safeParse(request, (value) => SessionRecordingStreamRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -62782,20 +62946,20 @@ var init_sessionsSessionRecordingStream = __esm(() => {
 });
 
 // src/mcp-server/tools/sessionsSessionRecordingStream.ts
-var args121, tool$sessionsSessionRecordingStream;
+var args122, tool$sessionsSessionRecordingStream;
 var init_sessionsSessionRecordingStream2 = __esm(() => {
   init_sessionsSessionRecordingStream();
   init_operations();
   init_tools();
-  args121 = {
+  args122 = {
     request: SessionRecordingStreamRequest$inboundSchema
   };
   tool$sessionsSessionRecordingStream = {
     name: "sessions-session-recording-stream",
     description: `Stream Recording`,
-    args: args121,
-    tool: async (client, args122, ctx) => {
-      const [result, apiCall] = await sessionsSessionRecordingStream(client, args122.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args122,
+    tool: async (client, args123, ctx) => {
+      const [result, apiCall] = await sessionsSessionRecordingStream(client, args123.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -62810,9 +62974,9 @@ var init_sessionsSessionRecordingStream2 = __esm(() => {
 
 // src/funcs/sessionsTranscriptGetById.ts
 function sessionsTranscriptGetById(client, request, options) {
-  return new APIPromise($do137(client, request, options));
+  return new APIPromise($do138(client, request, options));
 }
-async function $do137(client, request, options) {
+async function $do138(client, request, options) {
   const parsed = safeParse(request, (value) => SessionTranscriptGetByIdRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -62889,20 +63053,20 @@ var init_sessionsTranscriptGetById = __esm(() => {
 });
 
 // src/mcp-server/tools/sessionsTranscriptGetById.ts
-var args122, tool$sessionsTranscriptGetById;
+var args123, tool$sessionsTranscriptGetById;
 var init_sessionsTranscriptGetById2 = __esm(() => {
   init_sessionsTranscriptGetById();
   init_operations();
   init_tools();
-  args122 = {
+  args123 = {
     request: SessionTranscriptGetByIdRequest$inboundSchema
   };
   tool$sessionsTranscriptGetById = {
     name: "sessions-transcript-get-by-id",
     description: `Get Session Transcript By Id`,
-    args: args122,
-    tool: async (client, args123, ctx) => {
-      const [result, apiCall] = await sessionsTranscriptGetById(client, args123.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args123,
+    tool: async (client, args124, ctx) => {
+      const [result, apiCall] = await sessionsTranscriptGetById(client, args124.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -62917,9 +63081,9 @@ var init_sessionsTranscriptGetById2 = __esm(() => {
 
 // src/funcs/takeoutsCreate.ts
 function takeoutsCreate(client, options) {
-  return new APIPromise($do138(client, options));
+  return new APIPromise($do139(client, options));
 }
-async function $do138(client, options) {
+async function $do139(client, options) {
   const path = pathToFunc("/api/v1/takeouts/create")();
   const headers = new Headers(compactMap({
     Accept: "application/json"
@@ -62999,9 +63163,9 @@ var init_takeoutsCreate2 = __esm(() => {
 
 // src/funcs/takeoutsTakeoutsGetByJobId.ts
 function takeoutsTakeoutsGetByJobId(client, request, options) {
-  return new APIPromise($do139(client, request, options));
+  return new APIPromise($do140(client, request, options));
 }
-async function $do139(client, request, options) {
+async function $do140(client, request, options) {
   const parsed = safeParse(request, (value) => TakeoutsGetByJobIdRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -63078,20 +63242,20 @@ var init_takeoutsTakeoutsGetByJobId = __esm(() => {
 });
 
 // src/mcp-server/tools/takeoutsTakeoutsGetByJobId.ts
-var args123, tool$takeoutsTakeoutsGetByJobId;
+var args124, tool$takeoutsTakeoutsGetByJobId;
 var init_takeoutsTakeoutsGetByJobId2 = __esm(() => {
   init_takeoutsTakeoutsGetByJobId();
   init_operations();
   init_tools();
-  args123 = {
+  args124 = {
     request: TakeoutsGetByJobIdRequest$inboundSchema
   };
   tool$takeoutsTakeoutsGetByJobId = {
     name: "takeouts-takeouts-get-by-job-id",
     description: `Get Takeout`,
-    args: args123,
-    tool: async (client, args124, ctx) => {
-      const [result, apiCall] = await takeoutsTakeoutsGetByJobId(client, args124.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args124,
+    tool: async (client, args125, ctx) => {
+      const [result, apiCall] = await takeoutsTakeoutsGetByJobId(client, args125.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -63106,9 +63270,9 @@ var init_takeoutsTakeoutsGetByJobId2 = __esm(() => {
 
 // src/funcs/takeoutsTakeoutsGetFile.ts
 function takeoutsTakeoutsGetFile(client, request, options) {
-  return new APIPromise($do140(client, request, options));
+  return new APIPromise($do141(client, request, options));
 }
-async function $do140(client, request, options) {
+async function $do141(client, request, options) {
   const parsed = safeParse(request, (value) => TakeoutsGetFileRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -63191,20 +63355,20 @@ var init_takeoutsTakeoutsGetFile = __esm(() => {
 });
 
 // src/mcp-server/tools/takeoutsTakeoutsGetFile.ts
-var args124, tool$takeoutsTakeoutsGetFile;
+var args125, tool$takeoutsTakeoutsGetFile;
 var init_takeoutsTakeoutsGetFile2 = __esm(() => {
   init_takeoutsTakeoutsGetFile();
   init_operations();
   init_tools();
-  args124 = {
+  args125 = {
     request: TakeoutsGetFileRequest$inboundSchema
   };
   tool$takeoutsTakeoutsGetFile = {
     name: "takeouts-takeouts-get-file",
     description: `Get File`,
-    args: args124,
-    tool: async (client, args125, ctx) => {
-      const [result, apiCall] = await takeoutsTakeoutsGetFile(client, args125.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args125,
+    tool: async (client, args126, ctx) => {
+      const [result, apiCall] = await takeoutsTakeoutsGetFile(client, args126.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -63219,9 +63383,9 @@ var init_takeoutsTakeoutsGetFile2 = __esm(() => {
 
 // src/funcs/toolsCreate.ts
 function toolsCreate(client, request, options) {
-  return new APIPromise($do141(client, request, options));
+  return new APIPromise($do142(client, request, options));
 }
-async function $do141(client, request, options) {
+async function $do142(client, request, options) {
   const parsed = safeParse(request, (value) => ToolCreateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -63292,12 +63456,12 @@ var init_toolsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/toolsCreate.ts
-var args125, tool$toolsCreate;
+var args126, tool$toolsCreate;
 var init_toolsCreate2 = __esm(() => {
   init_toolsCreate();
   init_components();
   init_tools();
-  args125 = {
+  args126 = {
     request: ToolCreateRequest$inboundSchema
   };
   tool$toolsCreate = {
@@ -63305,9 +63469,9 @@ var init_toolsCreate2 = __esm(() => {
     description: `Create Tool
 
 Create a new tool`,
-    args: args125,
-    tool: async (client, args126, ctx) => {
-      const [result, apiCall] = await toolsCreate(client, args126.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args126,
+    tool: async (client, args127, ctx) => {
+      const [result, apiCall] = await toolsCreate(client, args127.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -63322,9 +63486,9 @@ Create a new tool`,
 
 // src/funcs/toolsDelete.ts
 function toolsDelete(client, request, options) {
-  return new APIPromise($do142(client, request, options));
+  return new APIPromise($do143(client, request, options));
 }
-async function $do142(client, request, options) {
+async function $do143(client, request, options) {
   const parsed = safeParse(request, (value) => ToolDeleteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -63405,12 +63569,12 @@ var init_toolsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/toolsDelete.ts
-var args126, tool$toolsDelete;
+var args127, tool$toolsDelete;
 var init_toolsDelete2 = __esm(() => {
   init_toolsDelete();
   init_operations();
   init_tools();
-  args126 = {
+  args127 = {
     request: ToolDeleteRequest$inboundSchema
   };
   tool$toolsDelete = {
@@ -63418,9 +63582,9 @@ var init_toolsDelete2 = __esm(() => {
     description: `Delete Tool
 
 Delete a tool.`,
-    args: args126,
-    tool: async (client, args127, ctx) => {
-      const [result, apiCall] = await toolsDelete(client, args127.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args127,
+    tool: async (client, args128, ctx) => {
+      const [result, apiCall] = await toolsDelete(client, args128.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -63435,9 +63599,9 @@ Delete a tool.`,
 
 // src/funcs/toolsGetByName.ts
 function toolsGetByName(client, request, options) {
-  return new APIPromise($do143(client, request, options));
+  return new APIPromise($do144(client, request, options));
 }
-async function $do143(client, request, options) {
+async function $do144(client, request, options) {
   const parsed = safeParse(request, (value) => ToolGetByNameRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -63514,12 +63678,12 @@ var init_toolsGetByName = __esm(() => {
 });
 
 // src/mcp-server/tools/toolsGetByName.ts
-var args127, tool$toolsGetByName;
+var args128, tool$toolsGetByName;
 var init_toolsGetByName2 = __esm(() => {
   init_toolsGetByName();
   init_operations();
   init_tools();
-  args127 = {
+  args128 = {
     request: ToolGetByNameRequest$inboundSchema
   };
   tool$toolsGetByName = {
@@ -63527,9 +63691,9 @@ var init_toolsGetByName2 = __esm(() => {
     description: `Tool Info
 
 Get the details of a specific tool`,
-    args: args127,
-    tool: async (client, args128, ctx) => {
-      const [result, apiCall] = await toolsGetByName(client, args128.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args128,
+    tool: async (client, args129, ctx) => {
+      const [result, apiCall] = await toolsGetByName(client, args129.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -63544,9 +63708,9 @@ Get the details of a specific tool`,
 
 // src/funcs/toolsList.ts
 function toolsList(client, request, options) {
-  return new APIPromise($do144(client, request, options));
+  return new APIPromise($do145(client, request, options));
 }
-async function $do144(client, request, options) {
+async function $do145(client, request, options) {
   const parsed = safeParse(request, (value) => ToolListRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -63629,12 +63793,12 @@ var init_toolsList = __esm(() => {
 });
 
 // src/mcp-server/tools/toolsList.ts
-var args128, tool$toolsList;
+var args129, tool$toolsList;
 var init_toolsList2 = __esm(() => {
   init_toolsList();
   init_operations();
   init_tools();
-  args128 = {
+  args129 = {
     request: ToolListRequest$inboundSchema
   };
   tool$toolsList = {
@@ -63642,9 +63806,9 @@ var init_toolsList2 = __esm(() => {
     description: `Tool List
 
 List the existing tools`,
-    args: args128,
-    tool: async (client, args129, ctx) => {
-      const [result, apiCall] = await toolsList(client, args129.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args129,
+    tool: async (client, args130, ctx) => {
+      const [result, apiCall] = await toolsList(client, args130.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -63659,9 +63823,9 @@ List the existing tools`,
 
 // src/funcs/toolsUpdate.ts
 function toolsUpdate(client, request, options) {
-  return new APIPromise($do145(client, request, options));
+  return new APIPromise($do146(client, request, options));
 }
-async function $do145(client, request, options) {
+async function $do146(client, request, options) {
   const parsed = safeParse(request, (value) => ToolUpdateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -63732,12 +63896,12 @@ var init_toolsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/toolsUpdate.ts
-var args129, tool$toolsUpdate;
+var args130, tool$toolsUpdate;
 var init_toolsUpdate2 = __esm(() => {
   init_toolsUpdate();
   init_components();
   init_tools();
-  args129 = {
+  args130 = {
     request: ToolUpdateRequest$inboundSchema
   };
   tool$toolsUpdate = {
@@ -63745,9 +63909,9 @@ var init_toolsUpdate2 = __esm(() => {
     description: `Update Tool
 
 Update an existing tool`,
-    args: args129,
-    tool: async (client, args130, ctx) => {
-      const [result, apiCall] = await toolsUpdate(client, args130.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args130,
+    tool: async (client, args131, ctx) => {
+      const [result, apiCall] = await toolsUpdate(client, args131.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -63762,9 +63926,9 @@ Update an existing tool`,
 
 // src/funcs/usersCreate.ts
 function usersCreate(client, request, options) {
-  return new APIPromise($do146(client, request, options));
+  return new APIPromise($do147(client, request, options));
 }
-async function $do146(client, request, options) {
+async function $do147(client, request, options) {
   const parsed = safeParse(request, (value) => UserCreateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -63835,12 +63999,12 @@ var init_usersCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/usersCreate.ts
-var args130, tool$usersCreate;
+var args131, tool$usersCreate;
 var init_usersCreate2 = __esm(() => {
   init_usersCreate();
   init_components();
   init_tools();
-  args130 = {
+  args131 = {
     request: UserCreateRequest$inboundSchema
   };
   tool$usersCreate = {
@@ -63848,9 +64012,9 @@ var init_usersCreate2 = __esm(() => {
     description: `Create User
 
 Create a new user.`,
-    args: args130,
-    tool: async (client, args131, ctx) => {
-      const [result, apiCall] = await usersCreate(client, args131.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args131,
+    tool: async (client, args132, ctx) => {
+      const [result, apiCall] = await usersCreate(client, args132.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -63865,9 +64029,9 @@ Create a new user.`,
 
 // src/funcs/usersDelete.ts
 function usersDelete(client, request, options) {
-  return new APIPromise($do147(client, request, options));
+  return new APIPromise($do148(client, request, options));
 }
-async function $do147(client, request, options) {
+async function $do148(client, request, options) {
   const parsed = safeParse(request, (value) => UserDeleteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -63939,12 +64103,12 @@ var init_usersDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/usersDelete.ts
-var args131, tool$usersDelete;
+var args132, tool$usersDelete;
 var init_usersDelete2 = __esm(() => {
   init_usersDelete();
   init_components();
   init_tools();
-  args131 = {
+  args132 = {
     request: UserDeleteRequest$inboundSchema
   };
   tool$usersDelete = {
@@ -63952,9 +64116,9 @@ var init_usersDelete2 = __esm(() => {
     description: `Delete User
 
 Delete a user.`,
-    args: args131,
-    tool: async (client, args132, ctx) => {
-      const [result, apiCall] = await usersDelete(client, args132.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args132,
+    tool: async (client, args133, ctx) => {
+      const [result, apiCall] = await usersDelete(client, args133.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -63969,9 +64133,9 @@ Delete a user.`,
 
 // src/funcs/usersList.ts
 function usersList(client, request, options) {
-  return new APIPromise($do148(client, request, options));
+  return new APIPromise($do149(client, request, options));
 }
-async function $do148(client, request, options) {
+async function $do149(client, request, options) {
   const parsed = safeParse(request, (value) => UsersListRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -64054,12 +64218,12 @@ var init_usersList = __esm(() => {
 });
 
 // src/mcp-server/tools/usersList.ts
-var args132, tool$usersList;
+var args133, tool$usersList;
 var init_usersList2 = __esm(() => {
   init_usersList();
   init_operations();
   init_tools();
-  args132 = {
+  args133 = {
     request: UsersListRequest$inboundSchema
   };
   tool$usersList = {
@@ -64067,9 +64231,9 @@ var init_usersList2 = __esm(() => {
     description: `List Users
 
 List the existing users.`,
-    args: args132,
-    tool: async (client, args133, ctx) => {
-      const [result, apiCall] = await usersList(client, args133.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args133,
+    tool: async (client, args134, ctx) => {
+      const [result, apiCall] = await usersList(client, args134.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -64084,9 +64248,9 @@ List the existing users.`,
 
 // src/funcs/usersUpdate.ts
 function usersUpdate(client, request, options) {
-  return new APIPromise($do149(client, request, options));
+  return new APIPromise($do150(client, request, options));
 }
-async function $do149(client, request, options) {
+async function $do150(client, request, options) {
   const parsed = safeParse(request, (value) => UserUpdateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -64157,12 +64321,12 @@ var init_usersUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/usersUpdate.ts
-var args133, tool$usersUpdate;
+var args134, tool$usersUpdate;
 var init_usersUpdate2 = __esm(() => {
   init_usersUpdate();
   init_components();
   init_tools();
-  args133 = {
+  args134 = {
     request: UserUpdateRequest$inboundSchema
   };
   tool$usersUpdate = {
@@ -64170,9 +64334,9 @@ var init_usersUpdate2 = __esm(() => {
     description: `Update User
 
 Update an existing user.`,
-    args: args133,
-    tool: async (client, args134, ctx) => {
-      const [result, apiCall] = await usersUpdate(client, args134.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args134,
+    tool: async (client, args135, ctx) => {
+      const [result, apiCall] = await usersUpdate(client, args135.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -64187,9 +64351,9 @@ Update an existing user.`,
 
 // src/funcs/usersUsersDeleteAccount.ts
 function usersUsersDeleteAccount(client, options) {
-  return new APIPromise($do150(client, options));
+  return new APIPromise($do151(client, options));
 }
-async function $do150(client, options) {
+async function $do151(client, options) {
   const path = pathToFunc("/api/v1/users/delete_account")();
   const headers = new Headers(compactMap({
     Accept: "application/json"
@@ -64272,9 +64436,9 @@ accounts.`,
 
 // src/funcs/usersUsersGetByEmail.ts
 function usersUsersGetByEmail(client, request, options) {
-  return new APIPromise($do151(client, request, options));
+  return new APIPromise($do152(client, request, options));
 }
-async function $do151(client, request, options) {
+async function $do152(client, request, options) {
   const parsed = safeParse(request, (value) => UsersGetByEmailRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -64351,12 +64515,12 @@ var init_usersUsersGetByEmail = __esm(() => {
 });
 
 // src/mcp-server/tools/usersUsersGetByEmail.ts
-var args134, tool$usersUsersGetByEmail;
+var args135, tool$usersUsersGetByEmail;
 var init_usersUsersGetByEmail2 = __esm(() => {
   init_usersUsersGetByEmail();
   init_operations();
   init_tools();
-  args134 = {
+  args135 = {
     request: UsersGetByEmailRequest$inboundSchema
   };
   tool$usersUsersGetByEmail = {
@@ -64364,9 +64528,9 @@ var init_usersUsersGetByEmail2 = __esm(() => {
     description: `Get User
 
 Fetch a given user.`,
-    args: args134,
-    tool: async (client, args135, ctx) => {
-      const [result, apiCall] = await usersUsersGetByEmail(client, args135.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args135,
+    tool: async (client, args136, ctx) => {
+      const [result, apiCall] = await usersUsersGetByEmail(client, args136.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -64381,9 +64545,9 @@ Fetch a given user.`,
 
 // src/funcs/usersUsersSendEmail.ts
 function usersUsersSendEmail(client, request, options) {
-  return new APIPromise($do152(client, request, options));
+  return new APIPromise($do153(client, request, options));
 }
-async function $do152(client, request, options) {
+async function $do153(client, request, options) {
   const parsed = safeParse(request, (value) => UsersSendEmailRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -64464,12 +64628,12 @@ var init_usersUsersSendEmail = __esm(() => {
 });
 
 // src/mcp-server/tools/usersUsersSendEmail.ts
-var args135, tool$usersUsersSendEmail;
+var args136, tool$usersUsersSendEmail;
 var init_usersUsersSendEmail2 = __esm(() => {
   init_usersUsersSendEmail();
   init_operations();
   init_tools();
-  args135 = {
+  args136 = {
     request: UsersSendEmailRequest$inboundSchema
   };
   tool$usersUsersSendEmail = {
@@ -64477,9 +64641,9 @@ var init_usersUsersSendEmail2 = __esm(() => {
     description: `Send User Email
 
 Send a welcome email to a user.`,
-    args: args135,
-    tool: async (client, args136, ctx) => {
-      const [result, apiCall] = await usersUsersSendEmail(client, args136.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args136,
+    tool: async (client, args137, ctx) => {
+      const [result, apiCall] = await usersUsersSendEmail(client, args137.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -64494,9 +64658,9 @@ Send a welcome email to a user.`,
 
 // src/funcs/voiceGroupsCreate.ts
 function voiceGroupsCreate(client, request, options) {
-  return new APIPromise($do153(client, request, options));
+  return new APIPromise($do154(client, request, options));
 }
-async function $do153(client, request, options) {
+async function $do154(client, request, options) {
   const parsed = safeParse(request, (value) => VoiceGroupCreateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -64567,12 +64731,12 @@ var init_voiceGroupsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/voiceGroupsCreate.ts
-var args136, tool$voiceGroupsCreate;
+var args137, tool$voiceGroupsCreate;
 var init_voiceGroupsCreate2 = __esm(() => {
   init_voiceGroupsCreate();
   init_components();
   init_tools();
-  args136 = {
+  args137 = {
     request: VoiceGroupCreateRequest$inboundSchema
   };
   tool$voiceGroupsCreate = {
@@ -64580,9 +64744,9 @@ var init_voiceGroupsCreate2 = __esm(() => {
     description: `Create Voice Group
 
 Create a new voice group.`,
-    args: args136,
-    tool: async (client, args137, ctx) => {
-      const [result, apiCall] = await voiceGroupsCreate(client, args137.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args137,
+    tool: async (client, args138, ctx) => {
+      const [result, apiCall] = await voiceGroupsCreate(client, args138.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -64597,9 +64761,9 @@ Create a new voice group.`,
 
 // src/funcs/voiceGroupsDelete.ts
 function voiceGroupsDelete(client, request, options) {
-  return new APIPromise($do154(client, request, options));
+  return new APIPromise($do155(client, request, options));
 }
-async function $do154(client, request, options) {
+async function $do155(client, request, options) {
   const parsed = safeParse(request, (value) => VoiceGroupsDeleteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -64680,12 +64844,12 @@ var init_voiceGroupsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/voiceGroupsDelete.ts
-var args137, tool$voiceGroupsDelete;
+var args138, tool$voiceGroupsDelete;
 var init_voiceGroupsDelete2 = __esm(() => {
   init_voiceGroupsDelete();
   init_operations();
   init_tools();
-  args137 = {
+  args138 = {
     request: VoiceGroupsDeleteRequest$inboundSchema
   };
   tool$voiceGroupsDelete = {
@@ -64693,9 +64857,9 @@ var init_voiceGroupsDelete2 = __esm(() => {
     description: `Delete Voice Group
 
 Delete a voice group.`,
-    args: args137,
-    tool: async (client, args138, ctx) => {
-      const [result, apiCall] = await voiceGroupsDelete(client, args138.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args138,
+    tool: async (client, args139, ctx) => {
+      const [result, apiCall] = await voiceGroupsDelete(client, args139.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -64710,9 +64874,9 @@ Delete a voice group.`,
 
 // src/funcs/voiceGroupsGetById.ts
 function voiceGroupsGetById(client, request, options) {
-  return new APIPromise($do155(client, request, options));
+  return new APIPromise($do156(client, request, options));
 }
-async function $do155(client, request, options) {
+async function $do156(client, request, options) {
   const parsed = safeParse(request, (value) => VoiceGroupsGetByIdRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -64789,12 +64953,12 @@ var init_voiceGroupsGetById = __esm(() => {
 });
 
 // src/mcp-server/tools/voiceGroupsGetById.ts
-var args138, tool$voiceGroupsGetById;
+var args139, tool$voiceGroupsGetById;
 var init_voiceGroupsGetById2 = __esm(() => {
   init_voiceGroupsGetById();
   init_operations();
   init_tools();
-  args138 = {
+  args139 = {
     request: VoiceGroupsGetByIdRequest$inboundSchema
   };
   tool$voiceGroupsGetById = {
@@ -64802,9 +64966,9 @@ var init_voiceGroupsGetById2 = __esm(() => {
     description: `Get Voice Group
 
 Fetch a given voice group.`,
-    args: args138,
-    tool: async (client, args139, ctx) => {
-      const [result, apiCall] = await voiceGroupsGetById(client, args139.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args139,
+    tool: async (client, args140, ctx) => {
+      const [result, apiCall] = await voiceGroupsGetById(client, args140.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -64819,9 +64983,9 @@ Fetch a given voice group.`,
 
 // src/funcs/voiceGroupsList.ts
 function voiceGroupsList(client, request, options) {
-  return new APIPromise($do156(client, request, options));
+  return new APIPromise($do157(client, request, options));
 }
-async function $do156(client, request, options) {
+async function $do157(client, request, options) {
   const parsed = safeParse(request, (value) => VoiceGroupsListRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -64904,12 +65068,12 @@ var init_voiceGroupsList = __esm(() => {
 });
 
 // src/mcp-server/tools/voiceGroupsList.ts
-var args139, tool$voiceGroupsList;
+var args140, tool$voiceGroupsList;
 var init_voiceGroupsList2 = __esm(() => {
   init_voiceGroupsList();
   init_operations();
   init_tools();
-  args139 = {
+  args140 = {
     request: VoiceGroupsListRequest$inboundSchema
   };
   tool$voiceGroupsList = {
@@ -64917,9 +65081,9 @@ var init_voiceGroupsList2 = __esm(() => {
     description: `List Voice Groups
 
 Fetch voice groups.`,
-    args: args139,
-    tool: async (client, args140, ctx) => {
-      const [result, apiCall] = await voiceGroupsList(client, args140.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args140,
+    tool: async (client, args141, ctx) => {
+      const [result, apiCall] = await voiceGroupsList(client, args141.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -64934,9 +65098,9 @@ Fetch voice groups.`,
 
 // src/funcs/voiceGroupsUpdate.ts
 function voiceGroupsUpdate(client, request, options) {
-  return new APIPromise($do157(client, request, options));
+  return new APIPromise($do158(client, request, options));
 }
-async function $do157(client, request, options) {
+async function $do158(client, request, options) {
   const parsed = safeParse(request, (value) => VoiceGroupUpdateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -65007,12 +65171,12 @@ var init_voiceGroupsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/voiceGroupsUpdate.ts
-var args140, tool$voiceGroupsUpdate;
+var args141, tool$voiceGroupsUpdate;
 var init_voiceGroupsUpdate2 = __esm(() => {
   init_voiceGroupsUpdate();
   init_components();
   init_tools();
-  args140 = {
+  args141 = {
     request: VoiceGroupUpdateRequest$inboundSchema
   };
   tool$voiceGroupsUpdate = {
@@ -65020,9 +65184,9 @@ var init_voiceGroupsUpdate2 = __esm(() => {
     description: `Update Voice Group
 
 Update an existing voice group`,
-    args: args140,
-    tool: async (client, args141, ctx) => {
-      const [result, apiCall] = await voiceGroupsUpdate(client, args141.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args141,
+    tool: async (client, args142, ctx) => {
+      const [result, apiCall] = await voiceGroupsUpdate(client, args142.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -65037,9 +65201,9 @@ Update an existing voice group`,
 
 // src/funcs/voiceGroupsVoiceGroupsCreateVoiceSample.ts
 function voiceGroupsVoiceGroupsCreateVoiceSample(client, request, options) {
-  return new APIPromise($do158(client, request, options));
+  return new APIPromise($do159(client, request, options));
 }
-async function $do158(client, request, options) {
+async function $do159(client, request, options) {
   const parsed = safeParse(request, (value) => VoiceSampleCreateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -65111,12 +65275,12 @@ var init_voiceGroupsVoiceGroupsCreateVoiceSample = __esm(() => {
 });
 
 // src/mcp-server/tools/voiceGroupsVoiceGroupsCreateVoiceSample.ts
-var args141, tool$voiceGroupsVoiceGroupsCreateVoiceSample;
+var args142, tool$voiceGroupsVoiceGroupsCreateVoiceSample;
 var init_voiceGroupsVoiceGroupsCreateVoiceSample2 = __esm(() => {
   init_voiceGroupsVoiceGroupsCreateVoiceSample();
   init_components();
   init_tools();
-  args141 = {
+  args142 = {
     request: VoiceSampleCreateRequest$inboundSchema
   };
   tool$voiceGroupsVoiceGroupsCreateVoiceSample = {
@@ -65124,9 +65288,9 @@ var init_voiceGroupsVoiceGroupsCreateVoiceSample2 = __esm(() => {
     description: `Create Voice Sample
 
 Generate voice sample.`,
-    args: args141,
-    tool: async (client, args142, ctx) => {
-      const [result, apiCall] = await voiceGroupsVoiceGroupsCreateVoiceSample(client, args142.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args142,
+    tool: async (client, args143, ctx) => {
+      const [result, apiCall] = await voiceGroupsVoiceGroupsCreateVoiceSample(client, args143.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -65143,7 +65307,7 @@ Generate voice sample.`,
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "SyllableSDK",
-    version: "1.0.7-rc.4"
+    version: "1.0.7-rc.5"
   });
   const client = new SyllableSDKCore({
     apiKeyHeader: deps.apiKeyHeader,
@@ -65229,6 +65393,7 @@ function createMCPServer(deps) {
   tool(tool$directoryGetById);
   tool(tool$directoryUpdate);
   tool(tool$directoryDelete);
+  tool(tool$directoryDirectoryMemberTestExtension);
   tool(tool$directoryDirectoryMemberBulkLoad);
   tool(tool$directoryDirectoryMemberDownload);
   tool(tool$dashboardsPostListDashboard);
@@ -65365,6 +65530,7 @@ var init_server2 = __esm(() => {
   init_directoryDelete2();
   init_directoryDirectoryMemberBulkLoad2();
   init_directoryDirectoryMemberDownload2();
+  init_directoryDirectoryMemberTestExtension2();
   init_directoryGetById2();
   init_directoryList2();
   init_directoryUpdate2();
@@ -66675,7 +66841,7 @@ var routes = ln({
 var app = _e(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "1.0.7-rc.4"
+    currentVersion: "1.0.7-rc.5"
   }
 });
 Yt(app, process3.argv.slice(2), buildContext(process3));
@@ -66683,5 +66849,5 @@ export {
   app
 };
 
-//# debugId=6E8FFFAE7C46031D64756E2164756E21
+//# debugId=8CFA546D8DE6A46364756E2164756E21
 //# sourceMappingURL=mcp-server.js.map