@meetkai/mka1 0.51.7 → 0.51.8

package/bin/mcp-server.js

@@ -52876,9 +52876,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.1.0",
-    sdkVersion: "0.51.7",
+    sdkVersion: "0.51.8",
     genVersion: "2.918.4",
-    userAgent: "speakeasy-sdk/typescript 0.51.7 2.918.4 1.1.0 @meetkai/mka1"
+    userAgent: "speakeasy-sdk/typescript 0.51.8 2.918.4 1.1.0 @meetkai/mka1"
   };
 });
 
@@ -87622,6 +87622,116 @@ var init_exchangeapikeytoken2 = __esm(() => {
   });
 });
 
+// src/models/operations/exportcompletionfeedback.ts
+var ExportCompletionFeedbackQueryParamOrder, ExportCompletionFeedbackQueryParamRating, ExportCompletionFeedbackQueryParamOrder$inboundSchema, ExportCompletionFeedbackQueryParamOrder$outboundSchema, ExportCompletionFeedbackQueryParamRating$inboundSchema, ExportCompletionFeedbackQueryParamRating$outboundSchema, ExportCompletionFeedbackRequest$inboundSchema, ExportCompletionFeedbackRequest$outboundSchema, ExportCompletionFeedbackResponse$inboundSchema, ExportCompletionFeedbackResponse$outboundSchema;
+var init_exportcompletionfeedback = __esm(() => {
+  init_esm();
+  init_primitives();
+  ExportCompletionFeedbackQueryParamOrder = {
+    Asc: "asc",
+    Desc: "desc"
+  };
+  ExportCompletionFeedbackQueryParamRating = {
+    ThumbsUp: "thumbs_up",
+    ThumbsDown: "thumbs_down"
+  };
+  ExportCompletionFeedbackQueryParamOrder$inboundSchema = nativeEnumType(ExportCompletionFeedbackQueryParamOrder);
+  ExportCompletionFeedbackQueryParamOrder$outboundSchema = ExportCompletionFeedbackQueryParamOrder$inboundSchema;
+  ExportCompletionFeedbackQueryParamRating$inboundSchema = nativeEnumType(ExportCompletionFeedbackQueryParamRating);
+  ExportCompletionFeedbackQueryParamRating$outboundSchema = ExportCompletionFeedbackQueryParamRating$inboundSchema;
+  ExportCompletionFeedbackRequest$inboundSchema = objectType({
+    order: ExportCompletionFeedbackQueryParamOrder$inboundSchema.default("desc"),
+    rating: ExportCompletionFeedbackQueryParamRating$inboundSchema.optional(),
+    "X-On-Behalf-Of": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-On-Behalf-Of": "xOnBehalfOf"
+    });
+  });
+  ExportCompletionFeedbackRequest$outboundSchema = objectType({
+    order: ExportCompletionFeedbackQueryParamOrder$outboundSchema.default("desc"),
+    rating: ExportCompletionFeedbackQueryParamRating$outboundSchema.optional(),
+    xOnBehalfOf: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      xOnBehalfOf: "X-On-Behalf-Of"
+    });
+  });
+  ExportCompletionFeedbackResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())).default({}),
+    Result: instanceOfType(ReadableStream)
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  ExportCompletionFeedbackResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: instanceOfType(ReadableStream)
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+});
+
+// src/models/operations/exportresponsefeedback.ts
+var ExportResponseFeedbackQueryParamOrder, ExportResponseFeedbackQueryParamRating, ExportResponseFeedbackQueryParamOrder$inboundSchema, ExportResponseFeedbackQueryParamOrder$outboundSchema, ExportResponseFeedbackQueryParamRating$inboundSchema, ExportResponseFeedbackQueryParamRating$outboundSchema, ExportResponseFeedbackRequest$inboundSchema, ExportResponseFeedbackRequest$outboundSchema, ExportResponseFeedbackResponse$inboundSchema, ExportResponseFeedbackResponse$outboundSchema;
+var init_exportresponsefeedback = __esm(() => {
+  init_esm();
+  init_primitives();
+  ExportResponseFeedbackQueryParamOrder = {
+    Asc: "asc",
+    Desc: "desc"
+  };
+  ExportResponseFeedbackQueryParamRating = {
+    ThumbsUp: "thumbs_up",
+    ThumbsDown: "thumbs_down"
+  };
+  ExportResponseFeedbackQueryParamOrder$inboundSchema = nativeEnumType(ExportResponseFeedbackQueryParamOrder);
+  ExportResponseFeedbackQueryParamOrder$outboundSchema = ExportResponseFeedbackQueryParamOrder$inboundSchema;
+  ExportResponseFeedbackQueryParamRating$inboundSchema = nativeEnumType(ExportResponseFeedbackQueryParamRating);
+  ExportResponseFeedbackQueryParamRating$outboundSchema = ExportResponseFeedbackQueryParamRating$inboundSchema;
+  ExportResponseFeedbackRequest$inboundSchema = objectType({
+    order: ExportResponseFeedbackQueryParamOrder$inboundSchema.default("desc"),
+    rating: ExportResponseFeedbackQueryParamRating$inboundSchema.optional(),
+    "X-On-Behalf-Of": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-On-Behalf-Of": "xOnBehalfOf"
+    });
+  });
+  ExportResponseFeedbackRequest$outboundSchema = objectType({
+    order: ExportResponseFeedbackQueryParamOrder$outboundSchema.default("desc"),
+    rating: ExportResponseFeedbackQueryParamRating$outboundSchema.optional(),
+    xOnBehalfOf: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      xOnBehalfOf: "X-On-Behalf-Of"
+    });
+  });
+  ExportResponseFeedbackResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())).default({}),
+    Result: instanceOfType(ReadableStream)
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  ExportResponseFeedbackResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: instanceOfType(ReadableStream)
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+});
+
 // src/types/blobs.ts
 function isBlobLike2(val) {
   if (val instanceof Blob) {
@@ -89482,27 +89592,6 @@ var init_getevalsuiteversion = __esm(() => {
   });
 });
 
-// src/models/operations/getexportstatus.ts
-var GetExportStatusRequest$inboundSchema, GetExportStatusRequest$outboundSchema;
-var init_getexportstatus = __esm(() => {
-  init_esm();
-  init_primitives();
-  GetExportStatusRequest$inboundSchema = objectType({
-    "X-On-Behalf-Of": stringType().optional()
-  }).transform((v2) => {
-    return remap(v2, {
-      "X-On-Behalf-Of": "xOnBehalfOf"
-    });
-  });
-  GetExportStatusRequest$outboundSchema = objectType({
-    xOnBehalfOf: stringType().optional()
-  }).transform((v2) => {
-    return remap(v2, {
-      xOnBehalfOf: "X-On-Behalf-Of"
-    });
-  });
-});
-
 // src/models/operations/getextractschema.ts
 var GetExtractSchemaRequest$inboundSchema, GetExtractSchemaRequest$outboundSchema;
 var init_getextractschema = __esm(() => {
@@ -96282,27 +96371,6 @@ var init_setupwhatsappappwebhook = __esm(() => {
   });
 });
 
-// src/models/operations/startexportfeedback.ts
-var StartExportFeedbackRequest$inboundSchema, StartExportFeedbackRequest$outboundSchema;
-var init_startexportfeedback = __esm(() => {
-  init_esm();
-  init_primitives();
-  StartExportFeedbackRequest$inboundSchema = objectType({
-    "X-On-Behalf-Of": stringType().optional()
-  }).transform((v2) => {
-    return remap(v2, {
-      "X-On-Behalf-Of": "xOnBehalfOf"
-    });
-  });
-  StartExportFeedbackRequest$outboundSchema = objectType({
-    xOnBehalfOf: stringType().optional()
-  }).transform((v2) => {
-    return remap(v2, {
-      xOnBehalfOf: "X-On-Behalf-Of"
-    });
-  });
-});
-
 // src/models/operations/streamagentrunevents.ts
 var StreamAgentRunEventsRequest$inboundSchema, StreamAgentRunEventsRequest$outboundSchema;
 var init_streamagentrunevents = __esm(() => {
@@ -98335,6 +98403,8 @@ var init_operations = __esm(() => {
   init_downloadworkspacefile();
   init_embed();
   init_exchangeapikeytoken2();
+  init_exportcompletionfeedback();
+  init_exportresponsefeedback();
   init_extract();
   init_extractwithschema();
   init_getagent();
@@ -98363,7 +98433,6 @@ var init_operations = __esm(() => {
   init_getevalschedule();
   init_getevalsuite();
   init_getevalsuiteversion();
-  init_getexportstatus();
   init_getextractschema();
   init_getextractusage();
   init_getfile();
@@ -98510,7 +98579,6 @@ var init_operations = __esm(() => {
   init_setorgprice();
   init_setservingtenant();
   init_setupwhatsappappwebhook();
-  init_startexportfeedback();
   init_streamagentrunevents();
   init_suspendclusterorg2();
   init_terminatesession();
@@ -114274,26 +114342,24 @@ Submit user feedback for a specific agent response to track satisfaction and mod
   };
 });
 
-// src/funcs/llmFeedbackGetCompletionFeedback.ts
-function llmFeedbackGetCompletionFeedback(client, request, options) {
+// src/funcs/llmFeedbackExportCompletionFeedback.ts
+function llmFeedbackExportCompletionFeedback(client, request, options) {
   return new APIPromise($do134(client, request, options));
 }
 async function $do134(client, request, options) {
-  const parsed = safeParse4(request, (value) => GetCompletionFeedbackRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse4(request, (value) => ExportCompletionFeedbackRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
   const body = null;
-  const pathParams = {
-    id: encodeSimple("id", payload.id, {
-      explode: false,
-      charEncoding: "percent"
-    })
-  };
-  const path = pathToFunc("/api/v1/llm/feedback/completions/{id}")(pathParams);
+  const path = pathToFunc("/api/v1/llm/feedback/export/completions")();
+  const query = encodeFormQuery({
+    order: payload.order,
+    rating: payload.rating
+  });
   const headers = new Headers(compactMap({
-    Accept: "application/json",
+    Accept: "text/csv",
     "X-On-Behalf-Of": encodeSimple("X-On-Behalf-Of", payload["X-On-Behalf-Of"], { explode: false, charEncoding: "none" })
   }));
   const secConfig = await extractSecurity(client._options.bearerAuth);
@@ -114302,7 +114368,7 @@ async function $do134(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "getCompletionFeedback",
+    operationID: "exportCompletionFeedback",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -114324,6 +114390,7 @@ async function $do134(client, request, options) {
     baseURL: options?.serverURL,
     path,
     headers,
+    query,
     body,
     userAgent: client._options.userAgent,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
@@ -114342,13 +114409,20 @@ async function $do134(client, request, options) {
     return [doResult, { status: "request-error", request: req }];
   }
   const response = doResult.value;
-  const [result] = await match(json(200, GetFeedbackResponse$inboundSchema), fail("4XX"), fail("5XX"))(response, req);
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(stream(200, ExportCompletionFeedbackResponse$inboundSchema, {
+    ctype: "text/csv",
+    hdrs: true,
+    key: "Result"
+  }), 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_llmFeedbackGetCompletionFeedback = __esm(() => {
+var init_llmFeedbackExportCompletionFeedback = __esm(() => {
   init_encodings();
   init_http();
   init_matchers();
@@ -114356,52 +114430,178 @@ var init_llmFeedbackGetCompletionFeedback = __esm(() => {
   init_schemas4();
   init_security();
   init_url();
-  init_components();
   init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/llmFeedbackGetCompletionFeedback.ts
-var args132, tool$llmFeedbackGetCompletionFeedback;
-var init_llmFeedbackGetCompletionFeedback2 = __esm(() => {
-  init_llmFeedbackGetCompletionFeedback();
+// src/mcp-server/tools/llmFeedbackExportCompletionFeedback.ts
+var args132, tool$llmFeedbackExportCompletionFeedback;
+var init_llmFeedbackExportCompletionFeedback2 = __esm(() => {
+  init_llmFeedbackExportCompletionFeedback();
   init_operations();
   init_tools();
   args132 = {
-    request: GetCompletionFeedbackRequest$inboundSchema
+    request: ExportCompletionFeedbackRequest$inboundSchema
   };
-  tool$llmFeedbackGetCompletionFeedback = {
-    name: "llm-feedback-get-completion-feedback",
-    description: `Retrieve feedback by completion ID
+  tool$llmFeedbackExportCompletionFeedback = {
+    name: "llm-feedback-export-completion-feedback",
+    description: `Export completion feedback as CSV
 
-Retrieves the existing feedback rating and description for a specific chat completion.`,
+Synchronously exports the completion feedback entries visible to the caller as a CSV file, ordered by the creation date of the underlying request. Visibility matches the list endpoint: callers see their own feedback; org owners and admins see their whole team. Supports filtering by rating. The export is capped at 50,000 rows; when the cap is hit the response carries an X-Export-Truncated header and older rows (with the default descending order) are omitted.`,
     args: args132,
     tool: async (client, args133, ctx) => {
-      const [result, apiCall] = await llmFeedbackGetCompletionFeedback(client, args133.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await llmFeedbackExportCompletionFeedback(client, args133.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
           isError: true
         };
       }
-      const value = result.value;
+      const value = result.value.result;
       return formatResult(value, apiCall);
     }
   };
 });
 
-// src/funcs/llmFeedbackGetExportStatus.ts
-function llmFeedbackGetExportStatus(client, request, options) {
+// src/funcs/llmFeedbackExportResponseFeedback.ts
+function llmFeedbackExportResponseFeedback(client, request, options) {
   return new APIPromise($do135(client, request, options));
 }
 async function $do135(client, request, options) {
-  const parsed = safeParse4(request, (value) => GetExportStatusRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse4(request, (value) => ExportResponseFeedbackRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
   const body = null;
-  const path = pathToFunc("/api/v1/llm/feedback/export/status")();
+  const path = pathToFunc("/api/v1/llm/feedback/export/responses")();
+  const query = encodeFormQuery({
+    order: payload.order,
+    rating: payload.rating
+  });
+  const headers = new Headers(compactMap({
+    Accept: "text/csv",
+    "X-On-Behalf-Of": encodeSimple("X-On-Behalf-Of", payload["X-On-Behalf-Of"], { explode: false, charEncoding: "none" })
+  }));
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "exportResponseFeedback",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearerAuth,
+    retryConfig: options?.retries || client._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 500,
+        maxInterval: 5000,
+        exponent: 1.5,
+        maxElapsedTime: 15000
+      },
+      retryConnectionErrors: true
+    },
+    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,
+    isErrorStatusCode: (statusCode) => matchStatusCode({ status: statusCode }, ["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(stream(200, ExportResponseFeedbackResponse$inboundSchema, {
+    ctype: "text/csv",
+    hdrs: true,
+    key: "Result"
+  }), 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_llmFeedbackExportResponseFeedback = __esm(() => {
+  init_encodings();
+  init_http();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/llmFeedbackExportResponseFeedback.ts
+var args133, tool$llmFeedbackExportResponseFeedback;
+var init_llmFeedbackExportResponseFeedback2 = __esm(() => {
+  init_llmFeedbackExportResponseFeedback();
+  init_operations();
+  init_tools();
+  args133 = {
+    request: ExportResponseFeedbackRequest$inboundSchema
+  };
+  tool$llmFeedbackExportResponseFeedback = {
+    name: "llm-feedback-export-response-feedback",
+    description: `Export response feedback as CSV
+
+Synchronously exports the response feedback entries visible to the caller as a CSV file, ordered by the creation date of the underlying request. Visibility matches the list endpoint: callers see their own feedback; org owners and admins see their whole team. Supports filtering by rating. The export is capped at 50,000 rows; when the cap is hit the response carries an X-Export-Truncated header and older rows (with the default descending order) are omitted.`,
+    args: args133,
+    tool: async (client, args134, ctx) => {
+      const [result, apiCall] = await llmFeedbackExportResponseFeedback(client, args134.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value.result;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/llmFeedbackGetCompletionFeedback.ts
+function llmFeedbackGetCompletionFeedback(client, request, options) {
+  return new APIPromise($do136(client, request, options));
+}
+async function $do136(client, request, options) {
+  const parsed = safeParse4(request, (value) => GetCompletionFeedbackRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    id: encodeSimple("id", payload.id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/api/v1/llm/feedback/completions/{id}")(pathParams);
   const headers = new Headers(compactMap({
     Accept: "application/json",
     "X-On-Behalf-Of": encodeSimple("X-On-Behalf-Of", payload["X-On-Behalf-Of"], { explode: false, charEncoding: "none" })
@@ -114412,7 +114612,7 @@ async function $do135(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "getExportStatus",
+    operationID: "getCompletionFeedback",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -114452,13 +114652,13 @@ async function $do135(client, request, options) {
     return [doResult, { status: "request-error", request: req }];
   }
   const response = doResult.value;
-  const [result] = await match(json(200, GetExportStatusResponse$inboundSchema), fail("4XX"), fail("5XX"))(response, req);
+  const [result] = await match(json(200, GetFeedbackResponse$inboundSchema), fail("4XX"), fail("5XX"))(response, req);
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_llmFeedbackGetExportStatus = __esm(() => {
+var init_llmFeedbackGetCompletionFeedback = __esm(() => {
   init_encodings();
   init_http();
   init_matchers();
@@ -114471,23 +114671,117 @@ var init_llmFeedbackGetExportStatus = __esm(() => {
   init_async();
 });
 
+// src/mcp-server/tools/llmFeedbackGetCompletionFeedback.ts
+var args134, tool$llmFeedbackGetCompletionFeedback;
+var init_llmFeedbackGetCompletionFeedback2 = __esm(() => {
+  init_llmFeedbackGetCompletionFeedback();
+  init_operations();
+  init_tools();
+  args134 = {
+    request: GetCompletionFeedbackRequest$inboundSchema
+  };
+  tool$llmFeedbackGetCompletionFeedback = {
+    name: "llm-feedback-get-completion-feedback",
+    description: `Retrieve feedback by completion ID
+
+Retrieves the existing feedback rating and description for a specific chat completion.`,
+    args: args134,
+    tool: async (client, args135, ctx) => {
+      const [result, apiCall] = await llmFeedbackGetCompletionFeedback(client, args135.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/llmFeedbackGetExportStatus.ts
+function llmFeedbackGetExportStatus(client, options) {
+  return new APIPromise($do137(client, options));
+}
+async function $do137(client, options) {
+  const path = pathToFunc("/api/v1/llm/feedback/export/status")();
+  const headers = new Headers(compactMap({
+    Accept: "application/json"
+  }));
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "getExportStatus",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearerAuth,
+    retryConfig: options?.retries || client._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 500,
+        maxInterval: 5000,
+        exponent: 1.5,
+        maxElapsedTime: 15000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    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,
+    isErrorStatusCode: (statusCode) => matchStatusCode({ status: statusCode }, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const [result] = await match(json(200, GetExportStatusResponse$inboundSchema), fail("4XX"), fail("5XX"))(response, req);
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_llmFeedbackGetExportStatus = __esm(() => {
+  init_http();
+  init_matchers();
+  init_primitives();
+  init_security();
+  init_url();
+  init_components();
+  init_async();
+});
+
 // src/mcp-server/tools/llmFeedbackGetExportStatus.ts
-var args133, tool$llmFeedbackGetExportStatus;
+var tool$llmFeedbackGetExportStatus;
 var init_llmFeedbackGetExportStatus2 = __esm(() => {
   init_llmFeedbackGetExportStatus();
-  init_operations();
   init_tools();
-  args133 = {
-    request: GetExportStatusRequest$inboundSchema
-  };
   tool$llmFeedbackGetExportStatus = {
     name: "llm-feedback-get-export-status",
     description: `Get feedback export status
 
-Checks the status and progress of the currently running or most recently completed feedback export job.`,
-    args: args133,
-    tool: async (client, args134, ctx) => {
-      const [result, apiCall] = await llmFeedbackGetExportStatus(client, args134.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+Checks the status and progress of the currently running or most recently completed feedback export job. Restricted to cluster administrators.`,
+    tool: async (client, ctx) => {
+      const [result, apiCall] = await llmFeedbackGetExportStatus(client, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -114502,9 +114796,9 @@ Checks the status and progress of the currently running or most recently complet
 
 // src/funcs/llmFeedbackGetResponseFeedback.ts
 function llmFeedbackGetResponseFeedback(client, request, options) {
-  return new APIPromise($do136(client, request, options));
+  return new APIPromise($do138(client, request, options));
 }
-async function $do136(client, request, options) {
+async function $do138(client, request, options) {
   const parsed = safeParse4(request, (value) => GetResponseFeedbackRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -114588,12 +114882,12 @@ var init_llmFeedbackGetResponseFeedback = __esm(() => {
 });
 
 // src/mcp-server/tools/llmFeedbackGetResponseFeedback.ts
-var args134, tool$llmFeedbackGetResponseFeedback;
+var args135, tool$llmFeedbackGetResponseFeedback;
 var init_llmFeedbackGetResponseFeedback2 = __esm(() => {
   init_llmFeedbackGetResponseFeedback();
   init_operations();
   init_tools();
-  args134 = {
+  args135 = {
     request: GetResponseFeedbackRequest$inboundSchema
   };
   tool$llmFeedbackGetResponseFeedback = {
@@ -114601,9 +114895,9 @@ var init_llmFeedbackGetResponseFeedback2 = __esm(() => {
     description: `Retrieve feedback by response ID
 
 Retrieves the existing feedback rating and description for a specific agent response.`,
-    args: args134,
-    tool: async (client, args135, ctx) => {
-      const [result, apiCall] = await llmFeedbackGetResponseFeedback(client, args135.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args135,
+    tool: async (client, args136, ctx) => {
+      const [result, apiCall] = await llmFeedbackGetResponseFeedback(client, args136.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -114618,9 +114912,9 @@ Retrieves the existing feedback rating and description for a specific agent resp
 
 // src/funcs/llmFeedbackListCompletionFeedback.ts
 function llmFeedbackListCompletionFeedback(client, request, options) {
-  return new APIPromise($do137(client, request, options));
+  return new APIPromise($do139(client, request, options));
 }
-async function $do137(client, request, options) {
+async function $do139(client, request, options) {
   const parsed = safeParse4(request, (value) => ListCompletionFeedbackRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -114705,12 +114999,12 @@ var init_llmFeedbackListCompletionFeedback = __esm(() => {
 });
 
 // src/mcp-server/tools/llmFeedbackListCompletionFeedback.ts
-var args135, tool$llmFeedbackListCompletionFeedback;
+var args136, tool$llmFeedbackListCompletionFeedback;
 var init_llmFeedbackListCompletionFeedback2 = __esm(() => {
   init_llmFeedbackListCompletionFeedback();
   init_operations();
   init_tools();
-  args135 = {
+  args136 = {
     request: ListCompletionFeedbackRequest$inboundSchema
   };
   tool$llmFeedbackListCompletionFeedback = {
@@ -114718,9 +115012,9 @@ var init_llmFeedbackListCompletionFeedback2 = __esm(() => {
     description: `List chat completion feedback
 
 Retrieves a paginated list of feedback entries recorded on the caller's chat completions, ordered by the completion's creation date. Supports filtering by rating. An \`after\` cursor that no longer resolves to a completion visible to the caller returns 400; restart pagination from the first page.`,
-    args: args135,
-    tool: async (client, args136, ctx) => {
-      const [result, apiCall] = await llmFeedbackListCompletionFeedback(client, args136.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args136,
+    tool: async (client, args137, ctx) => {
+      const [result, apiCall] = await llmFeedbackListCompletionFeedback(client, args137.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -114735,9 +115029,9 @@ Retrieves a paginated list of feedback entries recorded on the caller's chat com
 
 // src/funcs/llmFeedbackListResponseFeedback.ts
 function llmFeedbackListResponseFeedback(client, request, options) {
-  return new APIPromise($do138(client, request, options));
+  return new APIPromise($do140(client, request, options));
 }
-async function $do138(client, request, options) {
+async function $do140(client, request, options) {
   const parsed = safeParse4(request, (value) => ListResponseFeedbackRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -114822,12 +115116,12 @@ var init_llmFeedbackListResponseFeedback = __esm(() => {
 });
 
 // src/mcp-server/tools/llmFeedbackListResponseFeedback.ts
-var args136, tool$llmFeedbackListResponseFeedback;
+var args137, tool$llmFeedbackListResponseFeedback;
 var init_llmFeedbackListResponseFeedback2 = __esm(() => {
   init_llmFeedbackListResponseFeedback();
   init_operations();
   init_tools();
-  args136 = {
+  args137 = {
     request: ListResponseFeedbackRequest$inboundSchema
   };
   tool$llmFeedbackListResponseFeedback = {
@@ -114835,9 +115129,9 @@ var init_llmFeedbackListResponseFeedback2 = __esm(() => {
     description: `List response feedback
 
 Retrieves a paginated list of feedback entries recorded on the caller's agent responses, ordered by the response's creation date. Supports filtering by rating. An \`after\` cursor that no longer resolves to a response visible to the caller — including responses that have since been deleted — returns 400; restart pagination from the first page.`,
-    args: args136,
-    tool: async (client, args137, ctx) => {
-      const [result, apiCall] = await llmFeedbackListResponseFeedback(client, args137.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args137,
+    tool: async (client, args138, ctx) => {
+      const [result, apiCall] = await llmFeedbackListResponseFeedback(client, args138.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -114851,20 +115145,13 @@ Retrieves a paginated list of feedback entries recorded on the caller's agent re
 });
 
 // src/funcs/llmFeedbackStartExport.ts
-function llmFeedbackStartExport(client, request, options) {
-  return new APIPromise($do139(client, request, options));
+function llmFeedbackStartExport(client, options) {
+  return new APIPromise($do141(client, options));
 }
-async function $do139(client, request, options) {
-  const parsed = safeParse4(request, (value) => StartExportFeedbackRequest$outboundSchema.parse(value), "Input validation failed");
-  if (!parsed.ok) {
-    return [parsed, { status: "invalid" }];
-  }
-  const payload = parsed.value;
-  const body = null;
+async function $do141(client, options) {
   const path = pathToFunc("/api/v1/llm/feedback/export")();
   const headers = new Headers(compactMap({
-    Accept: "application/json",
-    "X-On-Behalf-Of": encodeSimple("X-On-Behalf-Of", payload["X-On-Behalf-Of"], { explode: false, charEncoding: "none" })
+    Accept: "application/json"
   }));
   const secConfig = await extractSecurity(client._options.bearerAuth);
   const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
@@ -114894,7 +115181,6 @@ async function $do139(client, request, options) {
     baseURL: options?.serverURL,
     path,
     headers,
-    body,
     userAgent: client._options.userAgent,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
   }, options);
@@ -114919,35 +115205,27 @@ async function $do139(client, request, options) {
   return [result, { status: "complete", request: req, response }];
 }
 var init_llmFeedbackStartExport = __esm(() => {
-  init_encodings();
   init_http();
   init_matchers();
   init_primitives();
-  init_schemas4();
   init_security();
   init_url();
   init_components();
-  init_operations();
   init_async();
 });
 
 // src/mcp-server/tools/llmFeedbackStartExport.ts
-var args137, tool$llmFeedbackStartExport;
+var tool$llmFeedbackStartExport;
 var init_llmFeedbackStartExport2 = __esm(() => {
   init_llmFeedbackStartExport();
-  init_operations();
   init_tools();
-  args137 = {
-    request: StartExportFeedbackRequest$inboundSchema
-  };
   tool$llmFeedbackStartExport = {
     name: "llm-feedback-start-export",
     description: `Start feedback export
 
-Starts a background job to export all feedback data to parquet files in S3/R2. Only one export can run simultaneously.`,
-    args: args137,
-    tool: async (client, args138, ctx) => {
-      const [result, apiCall] = await llmFeedbackStartExport(client, args138.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+Starts a background job to export all feedback data across every tenant to parquet files in S3/R2. Only one export can run simultaneously. Restricted to cluster administrators.`,
+    tool: async (client, ctx) => {
+      const [result, apiCall] = await llmFeedbackStartExport(client, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -114962,9 +115240,9 @@ Starts a background job to export all feedback data to parquet files in S3/R2. O
 
 // src/funcs/llmFeedbackUpdateCompletionFeedback.ts
 function llmFeedbackUpdateCompletionFeedback(client, request, options) {
-  return new APIPromise($do140(client, request, options));
+  return new APIPromise($do142(client, request, options));
 }
-async function $do140(client, request, options) {
+async function $do142(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateCompletionFeedbackRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -115079,9 +115357,9 @@ Updates or modifies existing feedback for a specific chat completion. Useful for
 
 // src/funcs/llmFeedbackUpdateResponseFeedback.ts
 function llmFeedbackUpdateResponseFeedback(client, request, options) {
-  return new APIPromise($do141(client, request, options));
+  return new APIPromise($do143(client, request, options));
 }
-async function $do141(client, request, options) {
+async function $do143(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateResponseFeedbackRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -115196,9 +115474,9 @@ Updates or modifies existing feedback for a specific agent response. Useful for
 
 // src/funcs/llmFilesContent.ts
 function llmFilesContent(client, request, options) {
-  return new APIPromise($do142(client, request, options));
+  return new APIPromise($do144(client, request, options));
 }
-async function $do142(client, request, options) {
+async function $do144(client, request, options) {
   const parsed = safeParse4(request, (value) => GetFileContentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -115371,9 +115649,9 @@ Returns the raw binary contents of the specified file with appropriate Content-T
 
 // src/funcs/llmFilesDelete.ts
 function llmFilesDelete(client, request, options) {
-  return new APIPromise($do143(client, request, options));
+  return new APIPromise($do145(client, request, options));
 }
-async function $do143(client, request, options) {
+async function $do145(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteFileRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -115487,9 +115765,9 @@ Delete a file from storage. This will also remove it from any vector stores.`,
 
 // src/funcs/llmFilesGet.ts
 function llmFilesGet(client, request, options) {
-  return new APIPromise($do144(client, request, options));
+  return new APIPromise($do146(client, request, options));
 }
-async function $do144(client, request, options) {
+async function $do146(client, request, options) {
   const parsed = safeParse4(request, (value) => GetFileRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -115603,9 +115881,9 @@ Returns information about a specific file.`,
 
 // src/funcs/llmFilesList.ts
 function llmFilesList(client, request, options) {
-  return new APIPromise($do145(client, request, options));
+  return new APIPromise($do147(client, request, options));
 }
-async function $do145(client, request, options) {
+async function $do147(client, request, options) {
   const parsed = safeParse4(request, (value) => ListFilesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -115720,9 +115998,9 @@ Returns a list of files that have been uploaded.`,
 
 // src/funcs/llmFilesUpload.ts
 function llmFilesUpload(client, request, options) {
-  return new APIPromise($do146(client, request, options));
+  return new APIPromise($do148(client, request, options));
 }
-async function $do146(client, request, options) {
+async function $do148(client, request, options) {
   const parsed = safeParse4(request, (value) => UploadFileRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -115845,9 +116123,9 @@ Upload a file that can be used with Assistants, Vector Stores, and other feature
 
 // src/funcs/llmFineTuningCancel.ts
 function llmFineTuningCancel(client, request, options) {
-  return new APIPromise($do147(client, request, options));
+  return new APIPromise($do149(client, request, options));
 }
-async function $do147(client, request, options) {
+async function $do149(client, request, options) {
   const parsed = safeParse4(request, (value) => CancelFineTuningJobRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -115957,9 +116235,9 @@ Immediately cancel a fine-tuning job.`,
 
 // src/funcs/llmFineTuningCreate.ts
 function llmFineTuningCreate(client, request, options) {
-  return new APIPromise($do148(client, request, options));
+  return new APIPromise($do150(client, request, options));
 }
-async function $do148(client, request, options) {
+async function $do150(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateFineTuningJobRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -116066,9 +116344,9 @@ Creates a fine-tuning job which begins the process of training a new model from
 
 // src/funcs/llmFineTuningList.ts
 function llmFineTuningList(client, request, options) {
-  return new APIPromise($do149(client, request, options));
+  return new APIPromise($do151(client, request, options));
 }
-async function $do149(client, request, options) {
+async function $do151(client, request, options) {
   const parsed = safeParse4(request, (value) => ListFineTuningJobsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -116180,9 +116458,9 @@ List your organization's fine-tuning jobs.`,
 
 // src/funcs/llmFineTuningListCheckpoints.ts
 function llmFineTuningListCheckpoints(client, request, options) {
-  return new APIPromise($do150(client, request, options));
+  return new APIPromise($do152(client, request, options));
 }
-async function $do150(client, request, options) {
+async function $do152(client, request, options) {
   const parsed = safeParse4(request, (value) => ListFineTuningCheckpointsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -116297,9 +116575,9 @@ List checkpoints for a fine-tuning job.`,
 
 // src/funcs/llmFineTuningListEvents.ts
 function llmFineTuningListEvents(client, request, options) {
-  return new APIPromise($do151(client, request, options));
+  return new APIPromise($do153(client, request, options));
 }
-async function $do151(client, request, options) {
+async function $do153(client, request, options) {
   const parsed = safeParse4(request, (value) => ListFineTuningEventsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -116414,9 +116692,9 @@ Get status updates for a fine-tuning job.`,
 
 // src/funcs/llmFineTuningPause.ts
 function llmFineTuningPause(client, request, options) {
-  return new APIPromise($do152(client, request, options));
+  return new APIPromise($do154(client, request, options));
 }
-async function $do152(client, request, options) {
+async function $do154(client, request, options) {
   const parsed = safeParse4(request, (value) => PauseFineTuningJobRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -116526,9 +116804,9 @@ Pause a running fine-tuning job.`,
 
 // src/funcs/llmFineTuningResume.ts
 function llmFineTuningResume(client, request, options) {
-  return new APIPromise($do153(client, request, options));
+  return new APIPromise($do155(client, request, options));
 }
-async function $do153(client, request, options) {
+async function $do155(client, request, options) {
   const parsed = safeParse4(request, (value) => ResumeFineTuningJobRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -116638,9 +116916,9 @@ Resume a paused fine-tuning job.`,
 
 // src/funcs/llmFineTuningRetrieve.ts
 function llmFineTuningRetrieve(client, request, options) {
-  return new APIPromise($do154(client, request, options));
+  return new APIPromise($do156(client, request, options));
 }
-async function $do154(client, request, options) {
+async function $do156(client, request, options) {
   const parsed = safeParse4(request, (value) => RetrieveFineTuningJobRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -116750,9 +117028,9 @@ Get info about a fine-tuning job.`,
 
 // src/funcs/llmImagesCreate.ts
 function llmImagesCreate(client, request, options) {
-  return new APIPromise($do155(client, request, options));
+  return new APIPromise($do157(client, request, options));
 }
-async function $do155(client, request, options) {
+async function $do157(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateImageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -116863,9 +117141,9 @@ Creates AI-generated images from text descriptions.`,
 
 // src/funcs/llmMcpVaultCreateCredential.ts
 function llmMcpVaultCreateCredential(client, request, options) {
-  return new APIPromise($do156(client, request, options));
+  return new APIPromise($do158(client, request, options));
 }
-async function $do156(client, request, options) {
+async function $do158(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateMcpCredentialRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -116982,9 +117260,9 @@ Stores encrypted credentials for a user-owned MCP server. Secret values are neve
 
 // src/funcs/llmMcpVaultCreateServer.ts
 function llmMcpVaultCreateServer(client, request, options) {
-  return new APIPromise($do157(client, request, options));
+  return new APIPromise($do159(client, request, options));
 }
-async function $do157(client, request, options) {
+async function $do159(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateMcpServerRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -117095,9 +117373,9 @@ Creates a user-owned MCP server configuration. Secret credentials are stored sep
 
 // src/funcs/llmMcpVaultDeleteCredential.ts
 function llmMcpVaultDeleteCredential(client, request, options) {
-  return new APIPromise($do158(client, request, options));
+  return new APIPromise($do160(client, request, options));
 }
-async function $do158(client, request, options) {
+async function $do160(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteMcpCredentialRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -117211,9 +117489,9 @@ Revokes a user-owned MCP credential.`,
 
 // src/funcs/llmMcpVaultDeleteServer.ts
 function llmMcpVaultDeleteServer(client, request, options) {
-  return new APIPromise($do159(client, request, options));
+  return new APIPromise($do161(client, request, options));
 }
-async function $do159(client, request, options) {
+async function $do161(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteMcpServerRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -117327,9 +117605,9 @@ Soft-deletes a user-owned MCP server and revokes its credentials.`,
 
 // src/funcs/llmMcpVaultGetServer.ts
 function llmMcpVaultGetServer(client, request, options) {
-  return new APIPromise($do160(client, request, options));
+  return new APIPromise($do162(client, request, options));
 }
-async function $do160(client, request, options) {
+async function $do162(client, request, options) {
   const parsed = safeParse4(request, (value) => GetMcpServerRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -117443,9 +117721,9 @@ Returns a user-owned MCP server configuration.`,
 
 // src/funcs/llmMcpVaultListCredentials.ts
 function llmMcpVaultListCredentials(client, request, options) {
-  return new APIPromise($do161(client, request, options));
+  return new APIPromise($do163(client, request, options));
 }
-async function $do161(client, request, options) {
+async function $do163(client, request, options) {
   const parsed = safeParse4(request, (value) => ListMcpCredentialsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -117566,9 +117844,9 @@ Lists encrypted credential metadata for a user-owned MCP server.`,
 
 // src/funcs/llmMcpVaultListServers.ts
 function llmMcpVaultListServers(client, request, options) {
-  return new APIPromise($do162(client, request, options));
+  return new APIPromise($do164(client, request, options));
 }
-async function $do162(client, request, options) {
+async function $do164(client, request, options) {
   const parsed = safeParse4(request, (value) => ListMcpServersRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -117682,9 +117960,9 @@ Lists MCP server configurations owned by the authenticated user context.`,
 
 // src/funcs/llmMcpVaultTestServer.ts
 function llmMcpVaultTestServer(client, request, options) {
-  return new APIPromise($do163(client, request, options));
+  return new APIPromise($do165(client, request, options));
 }
-async function $do163(client, request, options) {
+async function $do165(client, request, options) {
   const parsed = safeParse4(request, (value) => TestMcpServerRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -117798,9 +118076,9 @@ Connects to an MCP server using the authenticated user's stored credential and r
 
 // src/funcs/llmMcpVaultUpdateServer.ts
 function llmMcpVaultUpdateServer(client, request, options) {
-  return new APIPromise($do164(client, request, options));
+  return new APIPromise($do166(client, request, options));
 }
-async function $do164(client, request, options) {
+async function $do166(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateMcpServerRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -117917,9 +118195,9 @@ Partially updates a user-owned MCP server configuration.`,
 
 // src/funcs/llmMemoryStoresCreate.ts
 function llmMemoryStoresCreate(client, request, options) {
-  return new APIPromise($do165(client, request, options));
+  return new APIPromise($do167(client, request, options));
 }
-async function $do165(client, request, options) {
+async function $do167(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateMemoryStoreRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -118030,9 +118308,9 @@ Creates a memory store for persistent agent notes. Stores are private by default
 
 // src/funcs/llmMemoryStoresCreateEntry.ts
 function llmMemoryStoresCreateEntry(client, request, options) {
-  return new APIPromise($do166(client, request, options));
+  return new APIPromise($do168(client, request, options));
 }
-async function $do166(client, request, options) {
+async function $do168(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateMemoryEntryRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -118147,9 +118425,9 @@ var init_llmMemoryStoresCreateEntry2 = __esm(() => {
 
 // src/funcs/llmMemoryStoresDelete.ts
 function llmMemoryStoresDelete(client, request, options) {
-  return new APIPromise($do167(client, request, options));
+  return new APIPromise($do169(client, request, options));
 }
-async function $do167(client, request, options) {
+async function $do169(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteMemoryStoreRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -118261,9 +118539,9 @@ var init_llmMemoryStoresDelete2 = __esm(() => {
 
 // src/funcs/llmMemoryStoresDeleteEntry.ts
 function llmMemoryStoresDeleteEntry(client, request, options) {
-  return new APIPromise($do168(client, request, options));
+  return new APIPromise($do170(client, request, options));
 }
-async function $do168(client, request, options) {
+async function $do170(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteMemoryEntryRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -118386,9 +118664,9 @@ var init_llmMemoryStoresDeleteEntry2 = __esm(() => {
 
 // src/funcs/llmMemoryStoresGet.ts
 function llmMemoryStoresGet(client, request, options) {
-  return new APIPromise($do169(client, request, options));
+  return new APIPromise($do171(client, request, options));
 }
-async function $do169(client, request, options) {
+async function $do171(client, request, options) {
   const parsed = safeParse4(request, (value) => GetMemoryStoreRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -118500,9 +118778,9 @@ var init_llmMemoryStoresGet2 = __esm(() => {
 
 // src/funcs/llmMemoryStoresGetEntry.ts
 function llmMemoryStoresGetEntry(client, request, options) {
-  return new APIPromise($do170(client, request, options));
+  return new APIPromise($do172(client, request, options));
 }
-async function $do170(client, request, options) {
+async function $do172(client, request, options) {
   const parsed = safeParse4(request, (value) => GetMemoryEntryRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -118618,9 +118896,9 @@ var init_llmMemoryStoresGetEntry2 = __esm(() => {
 
 // src/funcs/llmMemoryStoresList.ts
 function llmMemoryStoresList(client, request, options) {
-  return new APIPromise($do171(client, request, options));
+  return new APIPromise($do173(client, request, options));
 }
-async function $do171(client, request, options) {
+async function $do173(client, request, options) {
   const parsed = safeParse4(request, (value) => ListMemoryStoresRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -118732,9 +119010,9 @@ var init_llmMemoryStoresList2 = __esm(() => {
 
 // src/funcs/llmMemoryStoresListEntries.ts
 function llmMemoryStoresListEntries(client, request, options) {
-  return new APIPromise($do172(client, request, options));
+  return new APIPromise($do174(client, request, options));
 }
-async function $do172(client, request, options) {
+async function $do174(client, request, options) {
   const parsed = safeParse4(request, (value) => ListMemoryEntriesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -118852,9 +119130,9 @@ var init_llmMemoryStoresListEntries2 = __esm(() => {
 
 // src/funcs/llmMemoryStoresUpdate.ts
 function llmMemoryStoresUpdate(client, request, options) {
-  return new APIPromise($do173(client, request, options));
+  return new APIPromise($do175(client, request, options));
 }
-async function $do173(client, request, options) {
+async function $do175(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateMemoryStoreRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -118969,9 +119247,9 @@ var init_llmMemoryStoresUpdate2 = __esm(() => {
 
 // src/funcs/llmMemoryStoresUpdateEntry.ts
 function llmMemoryStoresUpdateEntry(client, request, options) {
-  return new APIPromise($do174(client, request, options));
+  return new APIPromise($do176(client, request, options));
 }
-async function $do174(client, request, options) {
+async function $do176(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateMemoryEntryRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -119090,9 +119368,9 @@ var init_llmMemoryStoresUpdateEntry2 = __esm(() => {
 
 // src/funcs/llmModelsActivateRegistryEntry.ts
 function llmModelsActivateRegistryEntry(client, request, options) {
-  return new APIPromise($do175(client, request, options));
+  return new APIPromise($do177(client, request, options));
 }
-async function $do175(client, request, options) {
+async function $do177(client, request, options) {
   const parsed = safeParse4(request, (value) => ActivateRegistryEntryRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -119199,9 +119477,9 @@ Claims a model name from one catalog source. Re-activation from the same source
 
 // src/funcs/llmModelsAddCatalogEntry.ts
 function llmModelsAddCatalogEntry(client, request, options) {
-  return new APIPromise($do176(client, request, options));
+  return new APIPromise($do178(client, request, options));
 }
-async function $do176(client, request, options) {
+async function $do178(client, request, options) {
   const parsed = safeParse4(request, (value) => AddCatalogModelRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -119308,9 +119586,9 @@ Creates an API-owned BYO definition without activating its name.`,
 
 // src/funcs/llmModelsAddCatalogOrgAccess.ts
 function llmModelsAddCatalogOrgAccess(client, request, options) {
-  return new APIPromise($do177(client, request, options));
+  return new APIPromise($do179(client, request, options));
 }
-async function $do177(client, request, options) {
+async function $do179(client, request, options) {
   const parsed = safeParse4(request, (value) => AddModelCatalogOrgAccessRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -119426,9 +119704,9 @@ Idempotently adds availability without activating or revoking any model names.`,
 
 // src/funcs/llmModelsCheckCatalogHealth.ts
 function llmModelsCheckCatalogHealth(client, request, options) {
-  return new APIPromise($do178(client, request, options));
+  return new APIPromise($do180(client, request, options));
 }
-async function $do178(client, request, options) {
+async function $do180(client, request, options) {
   const parsed = safeParse4(request, (value) => CheckModelCatalogHealthRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -119539,9 +119817,9 @@ Probes an available BYO definition whether or not it is active.`,
 
 // src/funcs/llmModelsClearClusterPrice.ts
 function llmModelsClearClusterPrice(client, request, options) {
-  return new APIPromise($do179(client, request, options));
+  return new APIPromise($do181(client, request, options));
 }
-async function $do179(client, request, options) {
+async function $do181(client, request, options) {
   const parsed = safeParse4(request, (value) => ClearClusterPriceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -119652,9 +119930,9 @@ Closes the cluster-default price. Active cluster lineage then uses an org overri
 
 // src/funcs/llmModelsClearOrgPrice.ts
 function llmModelsClearOrgPrice(client, request, options) {
-  return new APIPromise($do180(client, request, options));
+  return new APIPromise($do182(client, request, options));
 }
-async function $do180(client, request, options) {
+async function $do182(client, request, options) {
   const parsed = safeParse4(request, (value) => ClearOrgPriceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -119771,9 +120049,9 @@ Closes a per-org price. Only active cluster lineage can then fall back to the cl
 
 // src/funcs/llmModelsDeactivateRegistryEntry.ts
 function llmModelsDeactivateRegistryEntry(client, request, options) {
-  return new APIPromise($do181(client, request, options));
+  return new APIPromise($do183(client, request, options));
 }
-async function $do181(client, request, options) {
+async function $do183(client, request, options) {
   const parsed = safeParse4(request, (value) => DeactivateModelRegistryEntryRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -119884,9 +120162,9 @@ Idempotently removes the active name and closes its org-scope price rows without
 
 // src/funcs/llmModelsDeleteCatalogEntry.ts
 function llmModelsDeleteCatalogEntry(client, request, options) {
-  return new APIPromise($do182(client, request, options));
+  return new APIPromise($do184(client, request, options));
 }
-async function $do182(client, request, options) {
+async function $do184(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteModelCatalogEntryRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -119997,9 +120275,9 @@ Withdraws a BYO definition and deactivates it only when the active name is sourc
 
 // src/funcs/llmModelsDeleteOrgAutoModel.ts
 function llmModelsDeleteOrgAutoModel(client, request, options) {
-  return new APIPromise($do183(client, request, options));
+  return new APIPromise($do185(client, request, options));
 }
-async function $do183(client, request, options) {
+async function $do185(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteOrgAutoModelRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -120112,9 +120390,9 @@ Removes the per-org override for the endpoint. Subsequent \`model: "auto"\` requ
 
 // src/funcs/llmModelsGet.ts
 function llmModelsGet(client, request, options) {
-  return new APIPromise($do184(client, request, options));
+  return new APIPromise($do186(client, request, options));
 }
-async function $do184(client, request, options) {
+async function $do186(client, request, options) {
   const parsed = safeParse4(request, (value) => GetModelRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -120227,9 +120505,9 @@ Retrieves a model instance, providing basic information about the model such as
 
 // src/funcs/llmModelsGetClusterCurrency.ts
 function llmModelsGetClusterCurrency(client, options) {
-  return new APIPromise($do185(client, options));
+  return new APIPromise($do187(client, options));
 }
-async function $do185(client, options) {
+async function $do187(client, options) {
   const path = pathToFunc("/api/v1/llm/models/pricing/currency")();
   const headers = new Headers(compactMap({
     Accept: "application/json"
@@ -120321,9 +120599,9 @@ Returns the single cluster-wide ISO-4217 currency code (null if not set).`,
 
 // src/funcs/llmModelsList.ts
 function llmModelsList(client, request, options) {
-  return new APIPromise($do186(client, request, options));
+  return new APIPromise($do188(client, request, options));
 }
-async function $do186(client, request, options) {
+async function $do188(client, request, options) {
   const parsed = safeParse4(request, (value) => ListModelsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -120430,9 +120708,9 @@ Lists the currently available models. Provides basic information about each mode
 
 // src/funcs/llmModelsListCatalog.ts
 function llmModelsListCatalog(client, options) {
-  return new APIPromise($do187(client, options));
+  return new APIPromise($do189(client, options));
 }
-async function $do187(client, options) {
+async function $do189(client, options) {
   const path = pathToFunc("/api/v1/llm/models/catalog")();
   const headers = new Headers(compactMap({
     Accept: "application/json"
@@ -120524,9 +120802,9 @@ Lists all BYO, serving, and cluster-access definitions with activation state, bl
 
 // src/funcs/llmModelsListCatalogModelAccess.ts
 function llmModelsListCatalogModelAccess(client, request, options) {
-  return new APIPromise($do188(client, request, options));
+  return new APIPromise($do190(client, request, options));
 }
-async function $do188(client, request, options) {
+async function $do190(client, request, options) {
   const parsed = safeParse4(request, (value) => ListModelCatalogAccessRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -120637,9 +120915,9 @@ Cluster operator reverse lookup showing availability and activation for one clus
 
 // src/funcs/llmModelsListCatalogOrgAccess.ts
 function llmModelsListCatalogOrgAccess(client, request, options) {
-  return new APIPromise($do189(client, request, options));
+  return new APIPromise($do191(client, request, options));
 }
-async function $do189(client, request, options) {
+async function $do191(client, request, options) {
   const parsed = safeParse4(request, (value) => ListModelCatalogOrgAccessRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -120752,9 +121030,9 @@ Cluster operator view of an org's available cluster catalog entries and their ac
 
 // src/funcs/llmModelsListClusterPrices.ts
 function llmModelsListClusterPrices(client, request, options) {
-  return new APIPromise($do190(client, request, options));
+  return new APIPromise($do192(client, request, options));
 }
-async function $do190(client, request, options) {
+async function $do192(client, request, options) {
   const parsed = safeParse4(request, (value) => ListClusterPricesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -120865,9 +121143,9 @@ Without \`model\`, lists every model's current cluster-default price. With \`mod
 
 // src/funcs/llmModelsListEffectivePrices.ts
 function llmModelsListEffectivePrices(client, request, options) {
-  return new APIPromise($do191(client, request, options));
+  return new APIPromise($do193(client, request, options));
 }
-async function $do191(client, request, options) {
+async function $do193(client, request, options) {
   const parsed = safeParse4(request, (value) => ListEffectivePricesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -120975,9 +121253,9 @@ For every active model, returns its registry-aware price: an org row, a cluster
 
 // src/funcs/llmModelsListOrgAutoModels.ts
 function llmModelsListOrgAutoModels(client, options) {
-  return new APIPromise($do192(client, options));
+  return new APIPromise($do194(client, options));
 }
-async function $do192(client, options) {
+async function $do194(client, options) {
   const path = pathToFunc("/api/v1/llm/models/auto")();
   const headers = new Headers(compactMap({
     Accept: "application/json"
@@ -121069,9 +121347,9 @@ Returns every endpoint for which this org has set its own \`"auto"\` target. End
 
 // src/funcs/llmModelsListOrgPrices.ts
 function llmModelsListOrgPrices(client, request, options) {
-  return new APIPromise($do193(client, request, options));
+  return new APIPromise($do195(client, request, options));
 }
-async function $do193(client, request, options) {
+async function $do195(client, request, options) {
   const parsed = safeParse4(request, (value) => ListOrgPricesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -121188,9 +121466,9 @@ Without \`model\`, lists the org's current overrides. With \`model\`, returns th
 
 // src/funcs/llmModelsListRegistry.ts
 function llmModelsListRegistry(client, options) {
-  return new APIPromise($do194(client, options));
+  return new APIPromise($do196(client, options));
 }
-async function $do194(client, options) {
+async function $do196(client, options) {
   const path = pathToFunc("/api/v1/llm/models/registry")();
   const headers = new Headers(compactMap({
     Accept: "application/json"
@@ -121282,9 +121560,9 @@ Single management view of every active name with source-qualified definition, he
 
 // src/funcs/llmModelsPutOrgAutoModel.ts
 function llmModelsPutOrgAutoModel(client, request, options) {
-  return new APIPromise($do195(client, request, options));
+  return new APIPromise($do197(client, request, options));
 }
-async function $do195(client, request, options) {
+async function $do197(client, request, options) {
   const parsed = safeParse4(request, (value) => PutOrgAutoModelRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -121400,9 +121678,9 @@ Stores \`{ endpoint → modelId }\` so subsequent requests with \`model: "auto"\
 
 // src/funcs/llmModelsReplaceCatalogOrgAccess.ts
 function llmModelsReplaceCatalogOrgAccess(client, request, options) {
-  return new APIPromise($do196(client, request, options));
+  return new APIPromise($do198(client, request, options));
 }
-async function $do196(client, request, options) {
+async function $do198(client, request, options) {
   const parsed = safeParse4(request, (value) => ReplaceModelCatalogOrgAccessRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -121518,9 +121796,9 @@ Serializable full replacement; revoked active cluster names are deactivated and
 
 // src/funcs/llmModelsSetClusterCurrency.ts
 function llmModelsSetClusterCurrency(client, request, options) {
-  return new APIPromise($do197(client, request, options));
+  return new APIPromise($do199(client, request, options));
 }
-async function $do197(client, request, options) {
+async function $do199(client, request, options) {
   const parsed = safeParse4(request, (value) => PutClusterCurrencyBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -121627,9 +121905,9 @@ Sets the cluster-wide currency. Changing it does not auto-convert existing price
 
 // src/funcs/llmModelsSetClusterPrice.ts
 function llmModelsSetClusterPrice(client, request, options) {
-  return new APIPromise($do198(client, request, options));
+  return new APIPromise($do200(client, request, options));
 }
-async function $do198(client, request, options) {
+async function $do200(client, request, options) {
   const parsed = safeParse4(request, (value) => PutModelPriceBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -121736,9 +122014,9 @@ Upserts the cluster-default price for a model as a new dated version. \`rates\`
 
 // src/funcs/llmModelsSetOrgPrice.ts
 function llmModelsSetOrgPrice(client, request, options) {
-  return new APIPromise($do199(client, request, options));
+  return new APIPromise($do201(client, request, options));
 }
-async function $do199(client, request, options) {
+async function $do201(client, request, options) {
   const parsed = safeParse4(request, (value) => SetOrgPriceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -121852,9 +122130,9 @@ Upserts a dated per-org price. Cluster lineage falls back to the cluster default
 
 // src/funcs/llmModelsUpdateCatalogEntry.ts
 function llmModelsUpdateCatalogEntry(client, request, options) {
-  return new APIPromise($do200(client, request, options));
+  return new APIPromise($do202(client, request, options));
 }
-async function $do200(client, request, options) {
+async function $do202(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateCatalogModelRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -121961,9 +122239,9 @@ Updates an API-owned BYO definition; yaml-origin entries are file-managed and im
 
 // src/funcs/llmPromptsCreate.ts
 function llmPromptsCreate(client, request, options) {
-  return new APIPromise($do201(client, request, options));
+  return new APIPromise($do203(client, request, options));
 }
-async function $do201(client, request, options) {
+async function $do203(client, request, options) {
   const parsed = safeParse4(request, (value) => CreatePromptRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -122074,9 +122352,9 @@ Creates a new prompt with its first version. The template supports {{variable}}
 
 // src/funcs/llmPromptsCreateVersion.ts
 function llmPromptsCreateVersion(client, request, options) {
-  return new APIPromise($do202(client, request, options));
+  return new APIPromise($do204(client, request, options));
 }
-async function $do202(client, request, options) {
+async function $do204(client, request, options) {
   const parsed = safeParse4(request, (value) => CreatePromptVersionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -122191,9 +122469,9 @@ Creates a new version of a prompt. The new version automatically becomes the act
 
 // src/funcs/llmPromptsDelete.ts
 function llmPromptsDelete(client, request, options) {
-  return new APIPromise($do203(client, request, options));
+  return new APIPromise($do205(client, request, options));
 }
-async function $do203(client, request, options) {
+async function $do205(client, request, options) {
   const parsed = safeParse4(request, (value) => DeletePromptRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -122307,9 +122585,9 @@ Deletes a prompt and all its versions.`,
 
 // src/funcs/llmPromptsGet.ts
 function llmPromptsGet(client, request, options) {
-  return new APIPromise($do204(client, request, options));
+  return new APIPromise($do206(client, request, options));
 }
-async function $do204(client, request, options) {
+async function $do206(client, request, options) {
   const parsed = safeParse4(request, (value) => GetPromptRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -122428,9 +122706,9 @@ Retrieves a prompt by its ID, including the active template. Pass \`version\` to
 
 // src/funcs/llmPromptsGetVersion.ts
 function llmPromptsGetVersion(client, request, options) {
-  return new APIPromise($do205(client, request, options));
+  return new APIPromise($do207(client, request, options));
 }
-async function $do205(client, request, options) {
+async function $do207(client, request, options) {
   const parsed = safeParse4(request, (value) => GetPromptVersionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -122548,9 +122826,9 @@ Retrieves a specific version of a prompt by version number.`,
 
 // src/funcs/llmPromptsList.ts
 function llmPromptsList(client, request, options) {
-  return new APIPromise($do206(client, request, options));
+  return new APIPromise($do208(client, request, options));
 }
-async function $do206(client, request, options) {
+async function $do208(client, request, options) {
   const parsed = safeParse4(request, (value) => ListPromptsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -122664,9 +122942,9 @@ Returns a paginated list of prompts owned by the authenticated user.`,
 
 // src/funcs/llmPromptsListVersions.ts
 function llmPromptsListVersions(client, request, options) {
-  return new APIPromise($do207(client, request, options));
+  return new APIPromise($do209(client, request, options));
 }
-async function $do207(client, request, options) {
+async function $do209(client, request, options) {
   const parsed = safeParse4(request, (value) => ListPromptVersionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -122785,9 +123063,9 @@ Returns the version history of a prompt, ordered by version number.`,
 
 // src/funcs/llmPromptsRollback.ts
 function llmPromptsRollback(client, request, options) {
-  return new APIPromise($do208(client, request, options));
+  return new APIPromise($do210(client, request, options));
 }
-async function $do208(client, request, options) {
+async function $do210(client, request, options) {
   const parsed = safeParse4(request, (value) => RollbackPromptRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -122902,9 +123180,9 @@ Sets the active version of a prompt to a previous version. This does not delete
 
 // src/funcs/llmPromptsUpdate.ts
 function llmPromptsUpdate(client, request, options) {
-  return new APIPromise($do209(client, request, options));
+  return new APIPromise($do211(client, request, options));
 }
-async function $do209(client, request, options) {
+async function $do211(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdatePromptRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -123019,9 +123297,9 @@ Updates prompt metadata. To update the template content, create a new version in
 
 // src/funcs/llmResponsesCancel.ts
 function llmResponsesCancel(client, request, options) {
-  return new APIPromise($do210(client, request, options));
+  return new APIPromise($do212(client, request, options));
 }
-async function $do210(client, request, options) {
+async function $do212(client, request, options) {
   const parsed = safeParse4(request, (value) => CancelResponseRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -123135,9 +123413,9 @@ Cancels an agent response that is currently processing in the background.`,
 
 // src/funcs/llmResponsesCompact.ts
 function llmResponsesCompact(client, request, options) {
-  return new APIPromise($do211(client, request, options));
+  return new APIPromise($do213(client, request, options));
 }
-async function $do211(client, request, options) {
+async function $do213(client, request, options) {
   const parsed = safeParse4(request, (value) => CompactResponseRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -123248,9 +123526,9 @@ Creates a compacted summary of the conversation history for a response, reducing
 
 // src/funcs/llmResponsesCreate.ts
 function llmResponsesCreate(client, request, options) {
-  return new APIPromise($do212(client, request, options));
+  return new APIPromise($do214(client, request, options));
 }
-async function $do212(client, request, options) {
+async function $do214(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateResponseRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -123360,9 +123638,9 @@ Creates a new AI agent response using advanced language models with autonomous t
 
 // src/funcs/llmResponsesDelete.ts
 function llmResponsesDelete(client, request, options) {
-  return new APIPromise($do213(client, request, options));
+  return new APIPromise($do215(client, request, options));
 }
-async function $do213(client, request, options) {
+async function $do215(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteResponseRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -123476,9 +123754,9 @@ Permanently deletes an agent response and all associated data.`,
 
 // src/funcs/llmResponsesGet.ts
 function llmResponsesGet(client, request, options) {
-  return new APIPromise($do214(client, request, options));
+  return new APIPromise($do216(client, request, options));
 }
-async function $do214(client, request, options) {
+async function $do216(client, request, options) {
   const parsed = safeParse4(request, (value) => GetResponseRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -123598,9 +123876,9 @@ Retrieves a previously created agent response by its unique ID. When stream=true
 
 // src/funcs/llmResponsesList.ts
 function llmResponsesList(client, request, options) {
-  return new APIPromise($do215(client, request, options));
+  return new APIPromise($do217(client, request, options));
 }
-async function $do215(client, request, options) {
+async function $do217(client, request, options) {
   const parsed = safeParse4(request, (value) => ListResponsesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -123715,9 +123993,9 @@ Retrieves a paginated list of all agent responses for the authenticated user.`,
 
 // src/funcs/llmResponsesListInputItems.ts
 function llmResponsesListInputItems(client, request, options) {
-  return new APIPromise($do216(client, request, options));
+  return new APIPromise($do218(client, request, options));
 }
-async function $do216(client, request, options) {
+async function $do218(client, request, options) {
   const parsed = safeParse4(request, (value) => ListInputItemsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -123838,9 +124116,9 @@ Retrieves a paginated list of all input items provided when creating the specifi
 
 // src/funcs/llmResponsesUpdate.ts
 function llmResponsesUpdate(client, request, options) {
-  return new APIPromise($do217(client, request, options));
+  return new APIPromise($do219(client, request, options));
 }
-async function $do217(client, request, options) {
+async function $do219(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateResponseRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -123957,9 +124235,9 @@ Update a response's metadata.`,
 
 // src/funcs/llmResponsesWake.ts
 function llmResponsesWake(client, request, options) {
-  return new APIPromise($do218(client, request, options));
+  return new APIPromise($do220(client, request, options));
 }
-async function $do218(client, request, options) {
+async function $do220(client, request, options) {
   const parsed = safeParse4(request, (value) => WakeResponseRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -124073,9 +124351,9 @@ Interrupts a short sleep tool call on an in-progress background response by prov
 
 // src/funcs/llmSkillsContent.ts
 function llmSkillsContent(client, request, options) {
-  return new APIPromise($do219(client, request, options));
+  return new APIPromise($do221(client, request, options));
 }
-async function $do219(client, request, options) {
+async function $do221(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSkillContentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -124191,9 +124469,9 @@ Download the zip bundle for a skill's default version.`,
 
 // src/funcs/llmSkillsCreate.ts
 function llmSkillsCreate(client, request, options) {
-  return new APIPromise($do220(client, request, options));
+  return new APIPromise($do222(client, request, options));
 }
-async function $do220(client, request, options) {
+async function $do222(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateSkillRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -124319,9 +124597,9 @@ Create a new skill by uploading files. The uploaded files must include a SKILL.m
 
 // src/funcs/llmSkillsCreateVersion.ts
 function llmSkillsCreateVersion(client, request, options) {
-  return new APIPromise($do221(client, request, options));
+  return new APIPromise($do223(client, request, options));
 }
-async function $do221(client, request, options) {
+async function $do223(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateSkillVersionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -124456,9 +124734,9 @@ Create a new immutable version of a skill by uploading files. The uploaded files
 
 // src/funcs/llmSkillsDelete.ts
 function llmSkillsDelete(client, request, options) {
-  return new APIPromise($do222(client, request, options));
+  return new APIPromise($do224(client, request, options));
 }
-async function $do222(client, request, options) {
+async function $do224(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteSkillRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -124572,9 +124850,9 @@ Delete a skill and all its versions.`,
 
 // src/funcs/llmSkillsDeleteVersion.ts
 function llmSkillsDeleteVersion(client, request, options) {
-  return new APIPromise($do223(client, request, options));
+  return new APIPromise($do225(client, request, options));
 }
-async function $do223(client, request, options) {
+async function $do225(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteSkillVersionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -124692,9 +124970,9 @@ Delete a specific version of a skill.`,
 
 // src/funcs/llmSkillsGet.ts
 function llmSkillsGet(client, request, options) {
-  return new APIPromise($do224(client, request, options));
+  return new APIPromise($do226(client, request, options));
 }
-async function $do224(client, request, options) {
+async function $do226(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSkillRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -124808,9 +125086,9 @@ Returns information about a specific skill.`,
 
 // src/funcs/llmSkillsGetVersion.ts
 function llmSkillsGetVersion(client, request, options) {
-  return new APIPromise($do225(client, request, options));
+  return new APIPromise($do227(client, request, options));
 }
-async function $do225(client, request, options) {
+async function $do227(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSkillVersionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -124928,9 +125206,9 @@ Returns information about a specific skill version.`,
 
 // src/funcs/llmSkillsList.ts
 function llmSkillsList(client, request, options) {
-  return new APIPromise($do226(client, request, options));
+  return new APIPromise($do228(client, request, options));
 }
-async function $do226(client, request, options) {
+async function $do228(client, request, options) {
   const parsed = safeParse4(request, (value) => ListSkillsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -125044,9 +125322,9 @@ Returns a paginated list of skills.`,
 
 // src/funcs/llmSkillsListPreconfigured.ts
 function llmSkillsListPreconfigured(client, request, options) {
-  return new APIPromise($do227(client, request, options));
+  return new APIPromise($do229(client, request, options));
 }
-async function $do227(client, request, options) {
+async function $do229(client, request, options) {
   const parsed = safeParse4(request, (value) => ListPreconfiguredSkillsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -125154,9 +125432,9 @@ Returns the list of preconfigured skills that ship with the gateway. These can b
 
 // src/funcs/llmSkillsListVersions.ts
 function llmSkillsListVersions(client, request, options) {
-  return new APIPromise($do228(client, request, options));
+  return new APIPromise($do230(client, request, options));
 }
-async function $do228(client, request, options) {
+async function $do230(client, request, options) {
   const parsed = safeParse4(request, (value) => ListSkillVersionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -125276,9 +125554,9 @@ Returns a paginated list of versions for a skill.`,
 
 // src/funcs/llmSkillsUpdate.ts
 function llmSkillsUpdate(client, request, options) {
-  return new APIPromise($do229(client, request, options));
+  return new APIPromise($do231(client, request, options));
 }
-async function $do229(client, request, options) {
+async function $do231(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateSkillRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -125395,9 +125673,9 @@ Update the default version pointer for a skill.`,
 
 // src/funcs/llmSkillsVersionContent.ts
 function llmSkillsVersionContent(client, request, options) {
-  return new APIPromise($do230(client, request, options));
+  return new APIPromise($do232(client, request, options));
 }
-async function $do230(client, request, options) {
+async function $do232(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSkillVersionContentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -125517,9 +125795,9 @@ Download the zip bundle for a specific skill version.`,
 
 // src/funcs/llmSpeechDeleteTranscriptionHistory.ts
 function llmSpeechDeleteTranscriptionHistory(client, request, options) {
-  return new APIPromise($do231(client, request, options));
+  return new APIPromise($do233(client, request, options));
 }
-async function $do231(client, request, options) {
+async function $do233(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteSpeechToTextHistoryRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -125633,9 +125911,9 @@ Deletes a stored transcription. The audio blob is content-addressed and may be s
 
 // src/funcs/llmSpeechDeleteTtsHistory.ts
 function llmSpeechDeleteTtsHistory(client, request, options) {
-  return new APIPromise($do232(client, request, options));
+  return new APIPromise($do234(client, request, options));
 }
-async function $do232(client, request, options) {
+async function $do234(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteTextToSpeechHistoryRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -125749,9 +126027,9 @@ Deletes a stored text-to-speech generation. The audio blob is content-addressed
 
 // src/funcs/llmSpeechGetTranscriptionHistory.ts
 function llmSpeechGetTranscriptionHistory(client, request, options) {
-  return new APIPromise($do233(client, request, options));
+  return new APIPromise($do235(client, request, options));
 }
-async function $do233(client, request, options) {
+async function $do235(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSpeechToTextHistoryRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -125865,9 +126143,9 @@ Returns metadata for a stored transcription.`,
 
 // src/funcs/llmSpeechGetTranscriptionHistoryContent.ts
 function llmSpeechGetTranscriptionHistoryContent(client, request, options) {
-  return new APIPromise($do234(client, request, options));
+  return new APIPromise($do236(client, request, options));
 }
-async function $do234(client, request, options) {
+async function $do236(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSpeechToTextHistoryContentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -125981,9 +126259,9 @@ Returns the stored input audio for a transcription as a binary response.`,
 
 // src/funcs/llmSpeechGetTtsHistory.ts
 function llmSpeechGetTtsHistory(client, request, options) {
-  return new APIPromise($do235(client, request, options));
+  return new APIPromise($do237(client, request, options));
 }
-async function $do235(client, request, options) {
+async function $do237(client, request, options) {
   const parsed = safeParse4(request, (value) => GetTextToSpeechHistoryRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -126097,9 +126375,9 @@ Returns metadata for a stored text-to-speech generation.`,
 
 // src/funcs/llmSpeechGetTtsHistoryContent.ts
 function llmSpeechGetTtsHistoryContent(client, request, options) {
-  return new APIPromise($do236(client, request, options));
+  return new APIPromise($do238(client, request, options));
 }
-async function $do236(client, request, options) {
+async function $do238(client, request, options) {
   const parsed = safeParse4(request, (value) => GetTextToSpeechHistoryContentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -126212,9 +126490,9 @@ Returns the stored audio for a text-to-speech generation as a binary response.`,
 
 // src/funcs/llmSpeechListTranscriptionHistory.ts
 function llmSpeechListTranscriptionHistory(client, request, options) {
-  return new APIPromise($do237(client, request, options));
+  return new APIPromise($do239(client, request, options));
 }
-async function $do237(client, request, options) {
+async function $do239(client, request, options) {
   const parsed = safeParse4(request, (value) => ListSpeechToTextHistoryRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -126329,9 +126607,9 @@ List stored transcriptions for the authenticated user, newest first by default.`
 
 // src/funcs/llmSpeechListTtsHistory.ts
 function llmSpeechListTtsHistory(client, request, options) {
-  return new APIPromise($do238(client, request, options));
+  return new APIPromise($do240(client, request, options));
 }
-async function $do238(client, request, options) {
+async function $do240(client, request, options) {
   const parsed = safeParse4(request, (value) => ListTextToSpeechHistoryRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -126446,9 +126724,9 @@ List stored text-to-speech generations for the authenticated user, newest first
 
 // src/funcs/llmSpeechLivekitToken.ts
 function llmSpeechLivekitToken(client, request, options) {
-  return new APIPromise($do239(client, request, options));
+  return new APIPromise($do241(client, request, options));
 }
-async function $do239(client, request, options) {
+async function $do241(client, request, options) {
   const parsed = safeParse4(request, (value) => LivekitTokenRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -126559,9 +126837,9 @@ Generates a LiveKit access token for joining a real-time voice room. The token i
 
 // src/funcs/llmSpeechSpeak.ts
 function llmSpeechSpeak(client, request, options) {
-  return new APIPromise($do240(client, request, options));
+  return new APIPromise($do242(client, request, options));
 }
-async function $do240(client, request, options) {
+async function $do242(client, request, options) {
   const parsed = safeParse4(request, (value) => TextToSpeechRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -126685,9 +126963,9 @@ Convert text to speech with automatic language detection.
 
 // src/funcs/llmSpeechSpeakStreaming.ts
 function llmSpeechSpeakStreaming(client, request, options) {
-  return new APIPromise($do241(client, request, options));
+  return new APIPromise($do243(client, request, options));
 }
-async function $do241(client, request, options) {
+async function $do243(client, request, options) {
   const parsed = safeParse4(request, (value) => TextToSpeechStreamingRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -126831,9 +127109,9 @@ Convert text to speech with real-time streaming audio delivery.
 
 // src/funcs/llmSpeechTranscribe.ts
 function llmSpeechTranscribe(client, request, options) {
-  return new APIPromise($do242(client, request, options));
+  return new APIPromise($do244(client, request, options));
 }
-async function $do242(client, request, options) {
+async function $do244(client, request, options) {
   const parsed = safeParse4(request, (value) => TranscribeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -126991,9 +127269,9 @@ curl -X POST "http://localhost:3000/api/v1/llm/speech/transcriptions?language=en
 
 // src/funcs/llmUsageClassify.ts
 function llmUsageClassify(client, request, options) {
-  return new APIPromise($do243(client, request, options));
+  return new APIPromise($do245(client, request, options));
 }
-async function $do243(client, request, options) {
+async function $do245(client, request, options) {
   const parsed = safeParse4(request, (value) => GetClassifyUsageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -127114,9 +127392,9 @@ Retrieve usage metrics for classify operations.`,
 
 // src/funcs/llmUsageCompletions.ts
 function llmUsageCompletions(client, request, options) {
-  return new APIPromise($do244(client, request, options));
+  return new APIPromise($do246(client, request, options));
 }
-async function $do244(client, request, options) {
+async function $do246(client, request, options) {
   const parsed = safeParse4(request, (value) => GetCompletionsUsageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -127237,9 +127515,9 @@ Retrieve usage metrics for chat completions, aggregated from the ChatCompletion
 
 // src/funcs/llmUsageConversations.ts
 function llmUsageConversations(client, request, options) {
-  return new APIPromise($do245(client, request, options));
+  return new APIPromise($do247(client, request, options));
 }
-async function $do245(client, request, options) {
+async function $do247(client, request, options) {
   const parsed = safeParse4(request, (value) => GetConversationsUsageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -127359,9 +127637,9 @@ Retrieve usage metrics for conversation operations.`,
 
 // src/funcs/llmUsageCosts.ts
 function llmUsageCosts(client, request, options) {
-  return new APIPromise($do246(client, request, options));
+  return new APIPromise($do248(client, request, options));
 }
-async function $do246(client, request, options) {
+async function $do248(client, request, options) {
   const parsed = safeParse4(request, (value) => GetCostsUsageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -127476,9 +127754,9 @@ Aggregates spend by model over a time range, priced in the cluster currency from
 
 // src/funcs/llmUsageEmbeddings.ts
 function llmUsageEmbeddings(client, request, options) {
-  return new APIPromise($do247(client, request, options));
+  return new APIPromise($do249(client, request, options));
 }
-async function $do247(client, request, options) {
+async function $do249(client, request, options) {
   const parsed = safeParse4(request, (value) => GetEmbeddingsUsageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -127599,9 +127877,9 @@ Retrieve usage metrics for embedding operations.`,
 
 // src/funcs/llmUsageExtract.ts
 function llmUsageExtract(client, request, options) {
-  return new APIPromise($do248(client, request, options));
+  return new APIPromise($do250(client, request, options));
 }
-async function $do248(client, request, options) {
+async function $do250(client, request, options) {
   const parsed = safeParse4(request, (value) => GetExtractUsageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -127722,9 +128000,9 @@ Retrieve usage metrics for extract operations.`,
 
 // src/funcs/llmUsageFiles.ts
 function llmUsageFiles(client, request, options) {
-  return new APIPromise($do249(client, request, options));
+  return new APIPromise($do251(client, request, options));
 }
-async function $do249(client, request, options) {
+async function $do251(client, request, options) {
   const parsed = safeParse4(request, (value) => GetFilesUsageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -127844,9 +128122,9 @@ Retrieve bytes of files created per period from durable file creation events. Th
 
 // src/funcs/llmUsageResponses.ts
 function llmUsageResponses(client, request, options) {
-  return new APIPromise($do250(client, request, options));
+  return new APIPromise($do252(client, request, options));
 }
-async function $do250(client, request, options) {
+async function $do252(client, request, options) {
   const parsed = safeParse4(request, (value) => GetResponsesUsageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -127968,9 +128246,9 @@ Retrieve usage metrics for agent responses, aggregated from the Response table.`
 
 // src/funcs/llmUsageVectorStores.ts
 function llmUsageVectorStores(client, request, options) {
-  return new APIPromise($do251(client, request, options));
+  return new APIPromise($do253(client, request, options));
 }
-async function $do251(client, request, options) {
+async function $do253(client, request, options) {
   const parsed = safeParse4(request, (value) => GetVectorStoresUsageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -128090,9 +128368,9 @@ Retrieve usage metrics for vector storage operations.`,
 
 // src/funcs/llmVectorStoresCancelFileBatch.ts
 function llmVectorStoresCancelFileBatch(client, request, options) {
-  return new APIPromise($do252(client, request, options));
+  return new APIPromise($do254(client, request, options));
 }
-async function $do252(client, request, options) {
+async function $do254(client, request, options) {
   const parsed = safeParse4(request, (value) => CancelVectorStoreFileBatchRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -128210,9 +128488,9 @@ Cancels an in-progress file batch operation.`,
 
 // src/funcs/llmVectorStoresCreate.ts
 function llmVectorStoresCreate(client, request, options) {
-  return new APIPromise($do253(client, request, options));
+  return new APIPromise($do255(client, request, options));
 }
-async function $do253(client, request, options) {
+async function $do255(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateVectorStoreRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -128323,9 +128601,9 @@ Creates a new vector store for storing and searching through document embeddings
 
 // src/funcs/llmVectorStoresCreateFile.ts
 function llmVectorStoresCreateFile(client, request, options) {
-  return new APIPromise($do254(client, request, options));
+  return new APIPromise($do256(client, request, options));
 }
-async function $do254(client, request, options) {
+async function $do256(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateVectorStoreFileRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -128442,9 +128720,9 @@ Adds a file to a vector store for semantic search indexing.`,
 
 // src/funcs/llmVectorStoresCreateFileBatch.ts
 function llmVectorStoresCreateFileBatch(client, request, options) {
-  return new APIPromise($do255(client, request, options));
+  return new APIPromise($do257(client, request, options));
 }
-async function $do255(client, request, options) {
+async function $do257(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateVectorStoreFileBatchRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -128561,9 +128839,9 @@ Adds multiple files to a vector store in a single batch operation.`,
 
 // src/funcs/llmVectorStoresDelete.ts
 function llmVectorStoresDelete(client, request, options) {
-  return new APIPromise($do256(client, request, options));
+  return new APIPromise($do258(client, request, options));
 }
-async function $do256(client, request, options) {
+async function $do258(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteVectorStoreRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -128677,9 +128955,9 @@ Permanently deletes a vector store and its associated embeddings.`,
 
 // src/funcs/llmVectorStoresDeleteFile.ts
 function llmVectorStoresDeleteFile(client, request, options) {
-  return new APIPromise($do257(client, request, options));
+  return new APIPromise($do259(client, request, options));
 }
-async function $do257(client, request, options) {
+async function $do259(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteVectorStoreFileRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -128797,9 +129075,9 @@ Removes a file from a vector store and deletes its associated embeddings.`,
 
 // src/funcs/llmVectorStoresGet.ts
 function llmVectorStoresGet(client, request, options) {
-  return new APIPromise($do258(client, request, options));
+  return new APIPromise($do260(client, request, options));
 }
-async function $do258(client, request, options) {
+async function $do260(client, request, options) {
   const parsed = safeParse4(request, (value) => GetVectorStoreRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -128913,9 +129191,9 @@ Retrieves a vector store by its ID.`,
 
 // src/funcs/llmVectorStoresGetFile.ts
 function llmVectorStoresGetFile(client, request, options) {
-  return new APIPromise($do259(client, request, options));
+  return new APIPromise($do261(client, request, options));
 }
-async function $do259(client, request, options) {
+async function $do261(client, request, options) {
   const parsed = safeParse4(request, (value) => GetVectorStoreFileRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -129033,9 +129311,9 @@ Retrieves detailed information about a specific file within a vector store.`,
 
 // src/funcs/llmVectorStoresGetFileBatch.ts
 function llmVectorStoresGetFileBatch(client, request, options) {
-  return new APIPromise($do260(client, request, options));
+  return new APIPromise($do262(client, request, options));
 }
-async function $do260(client, request, options) {
+async function $do262(client, request, options) {
   const parsed = safeParse4(request, (value) => GetVectorStoreFileBatchRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -129153,9 +129431,9 @@ Retrieves the status of a specific file batch operation within a vector store.`,
 
 // src/funcs/llmVectorStoresGetFileContent.ts
 function llmVectorStoresGetFileContent(client, request, options) {
-  return new APIPromise($do261(client, request, options));
+  return new APIPromise($do263(client, request, options));
 }
-async function $do261(client, request, options) {
+async function $do263(client, request, options) {
   const parsed = safeParse4(request, (value) => GetVectorStoreFileContentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -129273,9 +129551,9 @@ Retrieves the complete parsed contents of a file within a vector store.`,
 
 // src/funcs/llmVectorStoresList.ts
 function llmVectorStoresList(client, request, options) {
-  return new APIPromise($do262(client, request, options));
+  return new APIPromise($do264(client, request, options));
 }
-async function $do262(client, request, options) {
+async function $do264(client, request, options) {
   const parsed = safeParse4(request, (value) => ListVectorStoresRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -129390,9 +129668,9 @@ Retrieves a paginated list of all vector stores for the authenticated user.`,
 
 // src/funcs/llmVectorStoresListFiles.ts
 function llmVectorStoresListFiles(client, request, options) {
-  return new APIPromise($do263(client, request, options));
+  return new APIPromise($do265(client, request, options));
 }
-async function $do263(client, request, options) {
+async function $do265(client, request, options) {
   const parsed = safeParse4(request, (value) => ListVectorStoreFilesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -129514,9 +129792,9 @@ Retrieves a paginated list of all files in a specific vector store.`,
 
 // src/funcs/llmVectorStoresListFilesInBatch.ts
 function llmVectorStoresListFilesInBatch(client, request, options) {
-  return new APIPromise($do264(client, request, options));
+  return new APIPromise($do266(client, request, options));
 }
-async function $do264(client, request, options) {
+async function $do266(client, request, options) {
   const parsed = safeParse4(request, (value) => ListVectorStoreFilesInBatchRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -129642,9 +129920,9 @@ Retrieves a paginated list of all files within a specific batch operation.`,
 
 // src/funcs/llmVectorStoresSearch.ts
 function llmVectorStoresSearch(client, request, options) {
-  return new APIPromise($do265(client, request, options));
+  return new APIPromise($do267(client, request, options));
 }
-async function $do265(client, request, options) {
+async function $do267(client, request, options) {
   const parsed = safeParse4(request, (value) => SearchVectorStoreRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -129761,9 +130039,9 @@ Performs semantic search within a vector store to find the most relevant documen
 
 // src/funcs/llmVectorStoresUpdate.ts
 function llmVectorStoresUpdate(client, request, options) {
-  return new APIPromise($do266(client, request, options));
+  return new APIPromise($do268(client, request, options));
 }
-async function $do266(client, request, options) {
+async function $do268(client, request, options) {
   const parsed = safeParse4(request, (value) => ModifyVectorStoreRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -129880,9 +130158,9 @@ Updates the properties of an existing vector store.`,
 
 // src/funcs/llmVectorStoresUpdateFile.ts
 function llmVectorStoresUpdateFile(client, request, options) {
-  return new APIPromise($do267(client, request, options));
+  return new APIPromise($do269(client, request, options));
 }
-async function $do267(client, request, options) {
+async function $do269(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateVectorStoreFileAttributesRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -130001,9 +130279,9 @@ Updates the metadata attributes attached to a file within a vector store.`,
 
 // src/funcs/permissionsLlmCheck.ts
 function permissionsLlmCheck(client, request, options) {
-  return new APIPromise($do268(client, request, options));
+  return new APIPromise($do270(client, request, options));
 }
-async function $do268(client, request, options) {
+async function $do270(client, request, options) {
   const parsed = safeParse4(request, (value) => LlmCheckRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -130117,9 +130395,9 @@ Check whether the authenticated caller has a specific role on a resource.`,
 
 // src/funcs/permissionsLlmGrant.ts
 function permissionsLlmGrant(client, request, options) {
-  return new APIPromise($do269(client, request, options));
+  return new APIPromise($do271(client, request, options));
 }
-async function $do269(client, request, options) {
+async function $do271(client, request, options) {
   const parsed = safeParse4(request, (value) => LlmGrantRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -130229,9 +130507,9 @@ Grant a role to a user for a resource, or grant public access by using "*" as us
 
 // src/funcs/permissionsLlmRevoke.ts
 function permissionsLlmRevoke(client, request, options) {
-  return new APIPromise($do270(client, request, options));
+  return new APIPromise($do272(client, request, options));
 }
-async function $do270(client, request, options) {
+async function $do272(client, request, options) {
   const parsed = safeParse4(request, (value) => LlmRevokeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -130341,9 +130619,9 @@ Revoke a role from a user for a resource, or remove public access by using "*" a
 
 // src/funcs/sandboxCreate.ts
 function sandboxCreate(client, request, options) {
-  return new APIPromise($do271(client, request, options));
+  return new APIPromise($do273(client, request, options));
 }
-async function $do271(client, request, options) {
+async function $do273(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateSessionRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -130458,9 +130736,9 @@ Create a sandbox session and return its public session metadata, session token,
 
 // src/funcs/sandboxDownloadArchive.ts
 function sandboxDownloadArchive(client, request, options) {
-  return new APIPromise($do272(client, request, options));
+  return new APIPromise($do274(client, request, options));
 }
-async function $do272(client, request, options) {
+async function $do274(client, request, options) {
   const parsed = safeParse4(request, (value) => DownloadWorkspaceArchiveRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -130587,9 +130865,9 @@ Download a zip archive containing the selected workspace paths.`,
 
 // src/funcs/sandboxDownloadFile.ts
 function sandboxDownloadFile(client, request, options) {
-  return new APIPromise($do273(client, request, options));
+  return new APIPromise($do275(client, request, options));
 }
-async function $do273(client, request, options) {
+async function $do275(client, request, options) {
   const parsed = safeParse4(request, (value) => DownloadWorkspaceFileRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -130715,9 +130993,9 @@ Download raw bytes from a file in the session workspace.`,
 
 // src/funcs/sandboxGet.ts
 function sandboxGet(client, request, options) {
-  return new APIPromise($do274(client, request, options));
+  return new APIPromise($do276(client, request, options));
 }
-async function $do274(client, request, options) {
+async function $do276(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSessionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -130835,9 +131113,9 @@ Return the current state, configuration, and resource allocation for a sandbox s
 
 // src/funcs/sandboxGetBrowserUrl.ts
 function sandboxGetBrowserUrl(client, request, options) {
-  return new APIPromise($do275(client, request, options));
+  return new APIPromise($do277(client, request, options));
 }
-async function $do275(client, request, options) {
+async function $do277(client, request, options) {
   const parsed = safeParse4(request, (value) => GetBrowserSessionUrlRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -130959,9 +131237,9 @@ Return the public gateway URL for a browser session's Chrome DevTools Protocol e
 
 // src/funcs/sandboxGetPricing.ts
 function sandboxGetPricing(client, options) {
-  return new APIPromise($do276(client, options));
+  return new APIPromise($do278(client, options));
 }
-async function $do276(client, options) {
+async function $do278(client, options) {
   const path = pathToFunc("/api/v1/sandbox/pricing")();
   const headers = new Headers(compactMap({
     Accept: "application/json"
@@ -131053,9 +131331,9 @@ Current sandbox pricing rate card, keyed by SKU (\`standard\`, \`browser\`, \`ev
 
 // src/funcs/sandboxGetWorkspace.ts
 function sandboxGetWorkspace(client, request, options) {
-  return new APIPromise($do277(client, request, options));
+  return new APIPromise($do279(client, request, options));
 }
-async function $do277(client, request, options) {
+async function $do279(client, request, options) {
   const parsed = safeParse4(request, (value) => GetWorkspaceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -131177,9 +131455,9 @@ List files currently stored in the session workspace, including paths, sizes, an
 
 // src/funcs/sandboxList.ts
 function sandboxList(client, request, options) {
-  return new APIPromise($do278(client, request, options));
+  return new APIPromise($do280(client, request, options));
 }
-async function $do278(client, request, options) {
+async function $do280(client, request, options) {
   const parsed = safeParse4(request, (value) => ListSessionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -131292,9 +131570,9 @@ List sandbox sessions visible to the authenticated caller.`,
 
 // src/funcs/sandboxProxyBrowserPortRequest.ts
 function sandboxProxyBrowserPortRequest(client, request, options) {
-  return new APIPromise($do279(client, request, options));
+  return new APIPromise($do281(client, request, options));
 }
-async function $do279(client, request, options) {
+async function $do281(client, request, options) {
   const parsed = safeParse4(request, (value) => ProxyBrowserPortRequestRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -131424,9 +131702,9 @@ Proxy an HTTP request to an exposed browser-session port through the gateway. Us
 
 // src/funcs/sandboxRunCode.ts
 function sandboxRunCode(client, request, options) {
-  return new APIPromise($do280(client, request, options));
+  return new APIPromise($do282(client, request, options));
 }
-async function $do280(client, request, options) {
+async function $do282(client, request, options) {
   const parsed = safeParse4(request, (value) => RunCodeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -131545,9 +131823,9 @@ Execute source code in the session workspace using a supported runtime and retur
 
 // src/funcs/sandboxRunCommand.ts
 function sandboxRunCommand(client, request, options) {
-  return new APIPromise($do281(client, request, options));
+  return new APIPromise($do283(client, request, options));
 }
-async function $do281(client, request, options) {
+async function $do283(client, request, options) {
   const parsed = safeParse4(request, (value) => RunCommandRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -131666,9 +131944,9 @@ Run a command in the session workspace and return stdout, stderr, exit code, and
 
 // src/funcs/sandboxSetPricing.ts
 function sandboxSetPricing(client, request, options) {
-  return new APIPromise($do282(client, request, options));
+  return new APIPromise($do284(client, request, options));
 }
-async function $do282(client, request, options) {
+async function $do284(client, request, options) {
   const parsed = safeParse4(request, (value) => SandboxPricingUpdate$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -131779,9 +132057,9 @@ Replace the sandbox pricing rate card. Full-replace semantics: SKUs omitted from
 
 // src/funcs/sandboxTerminate.ts
 function sandboxTerminate(client, request, options) {
-  return new APIPromise($do283(client, request, options));
+  return new APIPromise($do285(client, request, options));
 }
-async function $do283(client, request, options) {
+async function $do285(client, request, options) {
   const parsed = safeParse4(request, (value) => TerminateSessionRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -131902,9 +132180,9 @@ Stop a sandbox session and release the backing sandbox resources.`,
 
 // src/funcs/sandboxUploadArchive.ts
 function sandboxUploadArchive(client, request, options) {
-  return new APIPromise($do284(client, request, options));
+  return new APIPromise($do286(client, request, options));
 }
-async function $do284(client, request, options) {
+async function $do286(client, request, options) {
   const parsed = safeParse4(request, (value) => UploadWorkspaceArchiveRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -132027,9 +132305,9 @@ Upload a zip archive and extract its files into the session workspace.`,
 
 // src/funcs/sandboxUploadFile.ts
 function sandboxUploadFile(client, request, options) {
-  return new APIPromise($do285(client, request, options));
+  return new APIPromise($do287(client, request, options));
 }
-async function $do285(client, request, options) {
+async function $do287(client, request, options) {
   const parsed = safeParse4(request, (value) => UploadWorkspaceFileRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -132156,9 +132434,9 @@ Upload raw bytes into the session workspace at the given path.`,
 
 // src/funcs/servingAcceleratorsList.ts
 function servingAcceleratorsList(client, request, options) {
-  return new APIPromise($do286(client, request, options));
+  return new APIPromise($do288(client, request, options));
 }
-async function $do286(client, request, options) {
+async function $do288(client, request, options) {
   const parsed = safeParse4(request, (value) => ListAcceleratorsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -132270,9 +132548,9 @@ List the accelerator types available to your organization (GPU, NPU, TPU).`,
 
 // src/funcs/servingDeploymentsCreate.ts
 function servingDeploymentsCreate(client, request, options) {
-  return new APIPromise($do287(client, request, options));
+  return new APIPromise($do289(client, request, options));
 }
-async function $do287(client, request, options) {
+async function $do289(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateDeploymentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -132385,9 +132663,9 @@ Create and start an inference deployment for a model, and return its endpoint.`,
 
 // src/funcs/servingDeploymentsDelete.ts
 function servingDeploymentsDelete(client, request, options) {
-  return new APIPromise($do288(client, request, options));
+  return new APIPromise($do290(client, request, options));
 }
-async function $do288(client, request, options) {
+async function $do290(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteDeploymentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -132504,9 +132782,9 @@ Tear down a deployment and release its resources.`,
 
 // src/funcs/servingDeploymentsDeregister.ts
 function servingDeploymentsDeregister(client, request, options) {
-  return new APIPromise($do289(client, request, options));
+  return new APIPromise($do291(client, request, options));
 }
-async function $do289(client, request, options) {
+async function $do291(client, request, options) {
   const parsed = safeParse4(request, (value) => DeregisterDeploymentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -132623,9 +132901,9 @@ Withdraw the deployment's model from the LLM gateway registry: inference stops r
 
 // src/funcs/servingDeploymentsGet.ts
 function servingDeploymentsGet(client, request, options) {
-  return new APIPromise($do290(client, request, options));
+  return new APIPromise($do292(client, request, options));
 }
-async function $do290(client, request, options) {
+async function $do292(client, request, options) {
   const parsed = safeParse4(request, (value) => GetDeploymentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -132743,9 +133021,9 @@ Retrieve a single deployment, including its status and endpoint URL.`,
 
 // src/funcs/servingDeploymentsGetLogs.ts
 function servingDeploymentsGetLogs(client, request, options) {
-  return new APIPromise($do291(client, request, options));
+  return new APIPromise($do293(client, request, options));
 }
-async function $do291(client, request, options) {
+async function $do293(client, request, options) {
   const parsed = safeParse4(request, (value) => GetDeploymentLogsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -132868,9 +133146,9 @@ Fetch recent log lines from a deployment's replicas.`,
 
 // src/funcs/servingDeploymentsGetMetrics.ts
 function servingDeploymentsGetMetrics(client, request, options) {
-  return new APIPromise($do292(client, request, options));
+  return new APIPromise($do294(client, request, options));
 }
-async function $do292(client, request, options) {
+async function $do294(client, request, options) {
   const parsed = safeParse4(request, (value) => GetDeploymentMetricsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -132988,9 +133266,9 @@ Return live serving metrics (throughput, queue depth, accelerator usage).`,
 
 // src/funcs/servingDeploymentsList.ts
 function servingDeploymentsList(client, request, options) {
-  return new APIPromise($do293(client, request, options));
+  return new APIPromise($do295(client, request, options));
 }
-async function $do293(client, request, options) {
+async function $do295(client, request, options) {
   const parsed = safeParse4(request, (value) => ListDeploymentsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -133107,9 +133385,9 @@ List your inference deployments.`,
 
 // src/funcs/servingDeploymentsListReplicas.ts
 function servingDeploymentsListReplicas(client, request, options) {
-  return new APIPromise($do294(client, request, options));
+  return new APIPromise($do296(client, request, options));
 }
-async function $do294(client, request, options) {
+async function $do296(client, request, options) {
   const parsed = safeParse4(request, (value) => ListReplicasRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -133227,9 +133505,9 @@ List the replicas currently backing a deployment.`,
 
 // src/funcs/servingDeploymentsListRevisions.ts
 function servingDeploymentsListRevisions(client, request, options) {
-  return new APIPromise($do295(client, request, options));
+  return new APIPromise($do297(client, request, options));
 }
-async function $do295(client, request, options) {
+async function $do297(client, request, options) {
   const parsed = safeParse4(request, (value) => ListRevisionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -133347,9 +133625,9 @@ List a deployment's configuration revisions, most recent first.`,
 
 // src/funcs/servingDeploymentsRegister.ts
 function servingDeploymentsRegister(client, request, options) {
-  return new APIPromise($do296(client, request, options));
+  return new APIPromise($do298(client, request, options));
 }
-async function $do296(client, request, options) {
+async function $do298(client, request, options) {
   const parsed = safeParse4(request, (value) => RegisterDeploymentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -133467,9 +133745,9 @@ Make the deployment's model available for inference: registers it in the LLM gat
 
 // src/funcs/servingDeploymentsRollback.ts
 function servingDeploymentsRollback(client, request, options) {
-  return new APIPromise($do297(client, request, options));
+  return new APIPromise($do299(client, request, options));
 }
-async function $do297(client, request, options) {
+async function $do299(client, request, options) {
   const parsed = safeParse4(request, (value) => RollbackDeploymentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -133590,9 +133868,9 @@ Roll a deployment back to a previous configuration revision.`,
 
 // src/funcs/servingDeploymentsUpdate.ts
 function servingDeploymentsUpdate(client, request, options) {
-  return new APIPromise($do298(client, request, options));
+  return new APIPromise($do300(client, request, options));
 }
-async function $do298(client, request, options) {
+async function $do300(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateDeploymentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -133711,9 +133989,9 @@ Update a deployment's configuration, rolling out a new revision.`,
 
 // src/funcs/servingDeploymentsUpdateScaling.ts
 function servingDeploymentsUpdateScaling(client, request, options) {
-  return new APIPromise($do299(client, request, options));
+  return new APIPromise($do301(client, request, options));
 }
-async function $do299(client, request, options) {
+async function $do301(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateScalingRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -133834,9 +134112,9 @@ Change a deployment's autoscaling limits in place, without redeploying.`,
 
 // src/funcs/servingFinetuneJobsCancel.ts
 function servingFinetuneJobsCancel(client, request, options) {
-  return new APIPromise($do300(client, request, options));
+  return new APIPromise($do302(client, request, options));
 }
-async function $do300(client, request, options) {
+async function $do302(client, request, options) {
   const parsed = safeParse4(request, (value) => CancelFinetuneJobRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -133953,9 +134231,9 @@ Cancel a running fine-tune job.`,
 
 // src/funcs/servingFinetuneJobsCreate.ts
 function servingFinetuneJobsCreate(client, request, options) {
-  return new APIPromise($do301(client, request, options));
+  return new APIPromise($do303(client, request, options));
 }
-async function $do301(client, request, options) {
+async function $do303(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateFinetuneJobRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -134068,9 +134346,9 @@ Submit a fine-tune job for a base model and dataset, and return its id.`,
 
 // src/funcs/servingFinetuneJobsGet.ts
 function servingFinetuneJobsGet(client, request, options) {
-  return new APIPromise($do302(client, request, options));
+  return new APIPromise($do304(client, request, options));
 }
-async function $do302(client, request, options) {
+async function $do304(client, request, options) {
   const parsed = safeParse4(request, (value) => GetFinetuneJobRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -134188,9 +134466,9 @@ Retrieve a fine-tune job, including its status and progress.`,
 
 // src/funcs/servingFinetuneJobsGetEvents.ts
 function servingFinetuneJobsGetEvents(client, request, options) {
-  return new APIPromise($do303(client, request, options));
+  return new APIPromise($do305(client, request, options));
 }
-async function $do303(client, request, options) {
+async function $do305(client, request, options) {
   const parsed = safeParse4(request, (value) => GetFinetuneEventsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -134313,9 +134591,9 @@ Return the job's status timeline (queued, running, checkpoints, completion).`,
 
 // src/funcs/servingFinetuneJobsGetLogs.ts
 function servingFinetuneJobsGetLogs(client, request, options) {
-  return new APIPromise($do304(client, request, options));
+  return new APIPromise($do306(client, request, options));
 }
-async function $do304(client, request, options) {
+async function $do306(client, request, options) {
   const parsed = safeParse4(request, (value) => GetFinetuneLogsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -134438,9 +134716,9 @@ Fetch recent training log lines for a job.`,
 
 // src/funcs/servingFinetuneJobsList.ts
 function servingFinetuneJobsList(client, request, options) {
-  return new APIPromise($do305(client, request, options));
+  return new APIPromise($do307(client, request, options));
 }
-async function $do305(client, request, options) {
+async function $do307(client, request, options) {
   const parsed = safeParse4(request, (value) => ListFinetuneJobsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -134557,9 +134835,9 @@ List your fine-tune jobs.`,
 
 // src/funcs/servingFinetuneJobsListCheckpoints.ts
 function servingFinetuneJobsListCheckpoints(client, request, options) {
-  return new APIPromise($do306(client, request, options));
+  return new APIPromise($do308(client, request, options));
 }
-async function $do306(client, request, options) {
+async function $do308(client, request, options) {
   const parsed = safeParse4(request, (value) => ListFinetuneCheckpointsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -134678,9 +134956,9 @@ List the checkpoints a fine-tune job has produced.`,
 
 // src/funcs/servingImagesDelete.ts
 function servingImagesDelete(client, request, options) {
-  return new APIPromise($do307(client, request, options));
+  return new APIPromise($do309(client, request, options));
 }
-async function $do307(client, request, options) {
+async function $do309(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteImageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -134797,9 +135075,9 @@ Delete a container image.`,
 
 // src/funcs/servingImagesGet.ts
 function servingImagesGet(client, request, options) {
-  return new APIPromise($do308(client, request, options));
+  return new APIPromise($do310(client, request, options));
 }
-async function $do308(client, request, options) {
+async function $do310(client, request, options) {
   const parsed = safeParse4(request, (value) => GetImageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -134917,9 +135195,9 @@ Retrieve an image, including its build status.`,
 
 // src/funcs/servingImagesList.ts
 function servingImagesList(client, request, options) {
-  return new APIPromise($do309(client, request, options));
+  return new APIPromise($do311(client, request, options));
 }
-async function $do309(client, request, options) {
+async function $do311(client, request, options) {
   const parsed = safeParse4(request, (value) => ListImagesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135036,9 +135314,9 @@ List your container images.`,
 
 // src/funcs/servingImagesRegister.ts
 function servingImagesRegister(client, request, options) {
-  return new APIPromise($do310(client, request, options));
+  return new APIPromise($do312(client, request, options));
 }
-async function $do310(client, request, options) {
+async function $do312(client, request, options) {
   const parsed = safeParse4(request, (value) => RegisterImageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135151,9 +135429,9 @@ Register a container image by reference so it can back a BYO deployment or a rec
 
 // src/funcs/servingModelsDelete.ts
 function servingModelsDelete(client, request, options) {
-  return new APIPromise($do311(client, request, options));
+  return new APIPromise($do313(client, request, options));
 }
-async function $do311(client, request, options) {
+async function $do313(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteModelRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135270,9 +135548,9 @@ Deregister a model from the catalog.`,
 
 // src/funcs/servingModelsGet.ts
 function servingModelsGet(client, request, options) {
-  return new APIPromise($do312(client, request, options));
+  return new APIPromise($do314(client, request, options));
 }
-async function $do312(client, request, options) {
+async function $do314(client, request, options) {
   const parsed = safeParse4(request, (value) => GetServingModelRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135390,9 +135668,9 @@ Retrieve a registered model.`,
 
 // src/funcs/servingModelsList.ts
 function servingModelsList(client, request, options) {
-  return new APIPromise($do313(client, request, options));
+  return new APIPromise($do315(client, request, options));
 }
-async function $do313(client, request, options) {
+async function $do315(client, request, options) {
   const parsed = safeParse4(request, (value) => ListServingModelsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135509,9 +135787,9 @@ List your registered models.`,
 
 // src/funcs/servingModelsRegister.ts
 function servingModelsRegister(client, request, options) {
-  return new APIPromise($do314(client, request, options));
+  return new APIPromise($do316(client, request, options));
 }
-async function $do314(client, request, options) {
+async function $do316(client, request, options) {
   const parsed = safeParse4(request, (value) => RegisterModelRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135624,9 +135902,9 @@ Register a model (from a source or volume) so it can be deployed or fine-tuned.`
 
 // src/funcs/servingSecretsCreate.ts
 function servingSecretsCreate(client, request, options) {
-  return new APIPromise($do315(client, request, options));
+  return new APIPromise($do317(client, request, options));
 }
-async function $do315(client, request, options) {
+async function $do317(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateSecretRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135739,9 +136017,9 @@ Create a secret whose values are injected into your workloads as env vars.`,
 
 // src/funcs/servingSecretsDelete.ts
 function servingSecretsDelete(client, request, options) {
-  return new APIPromise($do316(client, request, options));
+  return new APIPromise($do318(client, request, options));
 }
-async function $do316(client, request, options) {
+async function $do318(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteSecretRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135858,9 +136136,9 @@ Delete a secret.`,
 
 // src/funcs/servingSecretsList.ts
 function servingSecretsList(client, request, options) {
-  return new APIPromise($do317(client, request, options));
+  return new APIPromise($do319(client, request, options));
 }
-async function $do317(client, request, options) {
+async function $do319(client, request, options) {
   const parsed = safeParse4(request, (value) => ListSecretsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135977,9 +136255,9 @@ List your secrets by name (values are never returned).`,
 
 // src/funcs/servingTenantsDeleteOrganization.ts
 function servingTenantsDeleteOrganization(client, request, options) {
-  return new APIPromise($do318(client, request, options));
+  return new APIPromise($do320(client, request, options));
 }
-async function $do318(client, request, options) {
+async function $do320(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteServingOrganizationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -136100,9 +136378,9 @@ Durably records an organization.deleted.v1 event and starts (or adopts) the mand
 
 // src/funcs/servingTenantsGet.ts
 function servingTenantsGet(client, request, options) {
-  return new APIPromise($do319(client, request, options));
+  return new APIPromise($do321(client, request, options));
 }
-async function $do319(client, request, options) {
+async function $do321(client, request, options) {
   const parsed = safeParse4(request, (value) => GetServingTenantRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -136220,9 +136498,9 @@ Get one organization's serving enablement record. Cluster administrators only.`,
 
 // src/funcs/servingTenantsGetOrganizationDeletion.ts
 function servingTenantsGetOrganizationDeletion(client, request, options) {
-  return new APIPromise($do320(client, request, options));
+  return new APIPromise($do322(client, request, options));
 }
-async function $do320(client, request, options) {
+async function $do322(client, request, options) {
   const parsed = safeParse4(request, (value) => GetServingOrganizationDeletionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -136340,9 +136618,9 @@ Returns the durable teardown-cascade state for an organization (running or compl
 
 // src/funcs/servingTenantsList.ts
 function servingTenantsList(client, request, options) {
-  return new APIPromise($do321(client, request, options));
+  return new APIPromise($do323(client, request, options));
 }
-async function $do321(client, request, options) {
+async function $do323(client, request, options) {
   const parsed = safeParse4(request, (value) => ListServingTenantsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -136459,9 +136737,9 @@ List organization-wide serving enablement records. Cluster administrators only;
 
 // src/funcs/servingTenantsSet.ts
 function servingTenantsSet(client, request, options) {
-  return new APIPromise($do322(client, request, options));
+  return new APIPromise($do324(client, request, options));
 }
-async function $do322(client, request, options) {
+async function $do324(client, request, options) {
   const parsed = safeParse4(request, (value) => SetServingTenantRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -136580,9 +136858,9 @@ Enable or disable serving for an organization and all of its teams. Disabling bl
 
 // src/funcs/servingVolumesCreate.ts
 function servingVolumesCreate(client, request, options) {
-  return new APIPromise($do323(client, request, options));
+  return new APIPromise($do325(client, request, options));
 }
-async function $do323(client, request, options) {
+async function $do325(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateVolumeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -136695,9 +136973,9 @@ Create a persistent volume for weights, datasets, or checkpoints.`,
 
 // src/funcs/servingVolumesDelete.ts
 function servingVolumesDelete(client, request, options) {
-  return new APIPromise($do324(client, request, options));
+  return new APIPromise($do326(client, request, options));
 }
-async function $do324(client, request, options) {
+async function $do326(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteVolumeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -136814,9 +137092,9 @@ Delete a volume and its contents.`,
 
 // src/funcs/servingVolumesGet.ts
 function servingVolumesGet(client, request, options) {
-  return new APIPromise($do325(client, request, options));
+  return new APIPromise($do327(client, request, options));
 }
-async function $do325(client, request, options) {
+async function $do327(client, request, options) {
   const parsed = safeParse4(request, (value) => GetVolumeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -136934,9 +137212,9 @@ Retrieve a volume.`,
 
 // src/funcs/servingVolumesList.ts
 function servingVolumesList(client, request, options) {
-  return new APIPromise($do326(client, request, options));
+  return new APIPromise($do328(client, request, options));
 }
-async function $do326(client, request, options) {
+async function $do328(client, request, options) {
   const parsed = safeParse4(request, (value) => ListVolumesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -137053,9 +137331,9 @@ List your volumes.`,
 
 // src/funcs/usageCosts.ts
 function usageCosts(client, request, options) {
-  return new APIPromise($do327(client, request, options));
+  return new APIPromise($do329(client, request, options));
 }
-async function $do327(client, request, options) {
+async function $do329(client, request, options) {
   const parsed = safeParse4(request, (value) => GetCostsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -137168,9 +137446,9 @@ Sums stored per-entry cost over [start_time, end_time), grouped by any of servic
 
 // src/funcs/usageSandbox.ts
 function usageSandbox(client, request, options) {
-  return new APIPromise($do328(client, request, options));
+  return new APIPromise($do330(client, request, options));
 }
-async function $do328(client, request, options) {
+async function $do330(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSandboxUsageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -137293,7 +137571,7 @@ Aggregate sandbox usage (session lifecycle, execution, and workspace operations)
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "SDK",
-    version: "0.51.7"
+    version: "0.51.8"
   });
   const client = new SDKCore({
     bearerAuth: deps.bearerAuth,
@@ -137422,6 +137700,8 @@ function createMCPServer(deps) {
   tool(tool$llmFeedbackGetResponseFeedback);
   tool(tool$llmFeedbackUpdateResponseFeedback);
   tool(tool$llmFeedbackBatchGetResponseFeedback);
+  tool(tool$llmFeedbackExportCompletionFeedback);
+  tool(tool$llmFeedbackExportResponseFeedback);
   tool(tool$llmFeedbackStartExport);
   tool(tool$llmFeedbackGetExportStatus);
   tool(tool$llmFilesUpload);
@@ -137775,6 +138055,8 @@ var init_server2 = __esm(() => {
   init_llmFeedbackBatchGetResponseFeedback2();
   init_llmFeedbackCreateCompletionFeedback2();
   init_llmFeedbackCreateResponseFeedback2();
+  init_llmFeedbackExportCompletionFeedback2();
+  init_llmFeedbackExportResponseFeedback2();
   init_llmFeedbackGetCompletionFeedback2();
   init_llmFeedbackGetExportStatus2();
   init_llmFeedbackGetResponseFeedback2();
@@ -139147,7 +139429,7 @@ var routes = rn({
 var app = Ve(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.51.7"
+    currentVersion: "0.51.8"
   }
 });
 _t(app, process3.argv.slice(2), buildContext(process3));
@@ -139155,5 +139437,5 @@ export {
   app
 };
 
-//# debugId=B8E1A0B7BC511F4364756E2164756E21
+//# debugId=FBE4016E3B80325464756E2164756E21
 //# sourceMappingURL=mcp-server.js.map