@meetkai/mka1 0.51.19 → 0.51.21

package/bin/mcp-server.js

@@ -52876,9 +52876,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.1.0",
-    sdkVersion: "0.51.19",
+    sdkVersion: "0.51.21",
     genVersion: "2.924.0",
-    userAgent: "speakeasy-sdk/typescript 0.51.19 2.924.0 1.1.0 @meetkai/mka1"
+    userAgent: "speakeasy-sdk/typescript 0.51.21 2.924.0 1.1.0 @meetkai/mka1"
   };
 });
 
@@ -57549,6 +57549,7 @@ var init_checkpoint = __esm(() => {
     created_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
     id: stringType(),
     path: stringType(),
+    sha256: nullableType(stringType()).optional(),
     size_bytes: nullableType(numberType().int()).optional(),
     step: nullableType(numberType().int()).optional()
   }).transform((v2) => {
@@ -57561,6 +57562,7 @@ var init_checkpoint = __esm(() => {
     createdAt: dateType().transform((v2) => v2.toISOString()),
     id: stringType(),
     path: stringType(),
+    sha256: nullableType(stringType()).optional(),
     sizeBytes: nullableType(numberType().int()).optional(),
     step: nullableType(numberType().int()).optional()
   }).transform((v2) => {
@@ -63430,7 +63432,7 @@ var init_datasetuploadtarget = __esm(() => {
   DatasetUploadTargetMethod$inboundSchema = nativeEnumType(DatasetUploadTargetMethod);
   DatasetUploadTargetMethod$outboundSchema = DatasetUploadTargetMethod$inboundSchema;
   DatasetUploadTarget$inboundSchema = objectType({
-    expires_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
+    expires_at: nullableType(stringType().datetime({ offset: true }).transform((v2) => new Date(v2))).optional(),
     key: stringType(),
     method: DatasetUploadTargetMethod$inboundSchema,
     url: stringType()
@@ -63440,7 +63442,7 @@ var init_datasetuploadtarget = __esm(() => {
     });
   });
   DatasetUploadTarget$outboundSchema = objectType({
-    expiresAt: dateType().transform((v2) => v2.toISOString()),
+    expiresAt: nullableType(dateType().transform((v2) => v2.toISOString())).optional(),
     key: stringType(),
     method: DatasetUploadTargetMethod$outboundSchema,
     url: stringType()
@@ -63452,14 +63454,22 @@ var init_datasetuploadtarget = __esm(() => {
 });
 
 // src/models/components/datasetupload.ts
-var DatasetUpload$inboundSchema, DatasetUpload$outboundSchema;
+var DatasetUploadMode, DatasetUploadMode$inboundSchema, DatasetUploadMode$outboundSchema, DatasetUpload$inboundSchema, DatasetUpload$outboundSchema;
 var init_datasetupload = __esm(() => {
   init_esm();
   init_datasetuploadtarget();
+  DatasetUploadMode = {
+    Api: "api",
+    Presigned: "presigned"
+  };
+  DatasetUploadMode$inboundSchema = nativeEnumType(DatasetUploadMode);
+  DatasetUploadMode$outboundSchema = DatasetUploadMode$inboundSchema;
   DatasetUpload$inboundSchema = objectType({
+    mode: DatasetUploadMode$inboundSchema,
     targets: arrayType(DatasetUploadTarget$inboundSchema)
   });
   DatasetUpload$outboundSchema = objectType({
+    mode: DatasetUploadMode$outboundSchema,
     targets: arrayType(DatasetUploadTarget$outboundSchema)
   });
 });
@@ -63535,6 +63545,31 @@ var init_datasetcreate = __esm(() => {
   });
 });
 
+// src/models/components/datasetuploadreceipt.ts
+var DatasetUploadReceipt$inboundSchema, DatasetUploadReceipt$outboundSchema;
+var init_datasetuploadreceipt = __esm(() => {
+  init_esm();
+  init_primitives();
+  DatasetUploadReceipt$inboundSchema = objectType({
+    key: stringType(),
+    sha256: stringType(),
+    size_bytes: numberType().int()
+  }).transform((v2) => {
+    return remap(v2, {
+      size_bytes: "sizeBytes"
+    });
+  });
+  DatasetUploadReceipt$outboundSchema = objectType({
+    key: stringType(),
+    sha256: stringType(),
+    sizeBytes: numberType().int()
+  }).transform((v2) => {
+    return remap(v2, {
+      sizeBytes: "size_bytes"
+    });
+  });
+});
+
 // src/models/components/deactivateregistryentryresponse.ts
 var DeactivateRegistryEntryResponse$inboundSchema, DeactivateRegistryEntryResponse$outboundSchema;
 var init_deactivateregistryentryresponse = __esm(() => {
@@ -77773,6 +77808,7 @@ var init_components = __esm(() => {
   init_datasetmanifest();
   init_datasetmanifestobject();
   init_datasetupload();
+  init_datasetuploadreceipt();
   init_datasetuploadtarget();
   init_deactivateregistryentryresponse();
   init_decideagentrunmcpapprovalrequest();
@@ -99564,6 +99600,45 @@ var init_uploadfile = __esm(() => {
   });
 });
 
+// src/models/operations/uploadservingdatasetcontent.ts
+var UploadServingDatasetContentRequest$inboundSchema, UploadServingDatasetContentRequest$outboundSchema;
+var init_uploadservingdatasetcontent = __esm(() => {
+  init_esm();
+  init_primitives();
+  UploadServingDatasetContentRequest$inboundSchema = objectType({
+    dataset_id: stringType(),
+    "X-On-Behalf-Of": stringType().optional(),
+    RequestBody: unionType([
+      instanceOfType(ReadableStream),
+      instanceOfType(Blob),
+      instanceOfType(ArrayBuffer),
+      instanceOfType(Uint8Array)
+    ])
+  }).transform((v2) => {
+    return remap(v2, {
+      dataset_id: "datasetId",
+      "X-On-Behalf-Of": "xOnBehalfOf",
+      RequestBody: "requestBody"
+    });
+  });
+  UploadServingDatasetContentRequest$outboundSchema = objectType({
+    datasetId: stringType(),
+    xOnBehalfOf: stringType().optional(),
+    requestBody: unionType([
+      instanceOfType(ReadableStream),
+      instanceOfType(Blob),
+      instanceOfType(ArrayBuffer),
+      instanceOfType(Uint8Array)
+    ])
+  }).transform((v2) => {
+    return remap(v2, {
+      datasetId: "dataset_id",
+      xOnBehalfOf: "X-On-Behalf-Of",
+      requestBody: "RequestBody"
+    });
+  });
+});
+
 // src/models/operations/uploadworkspacearchive.ts
 var UploadWorkspaceArchiveRequest$inboundSchema, UploadWorkspaceArchiveRequest$outboundSchema;
 var init_uploadworkspacearchive = __esm(() => {
@@ -100079,6 +100154,7 @@ var init_operations = __esm(() => {
   init_updateteam2();
   init_updatevectorstorefileattributes();
   init_uploadfile();
+  init_uploadservingdatasetcontent();
   init_uploadworkspacearchive();
   init_uploadworkspacefile();
   init_wakeagentrun();
@@ -134477,7 +134553,7 @@ var init_servingDatasetsCreate2 = __esm(() => {
     name: "serving-datasets-create",
     description: `Register or begin uploading a dataset
 
-Register a dataset by reference (\`source\`: an external dataset reference passed to the trainer as-is, or a \`repo://{repo}[@{revision}][/{path}]\` reference reserved for the versioned dataset store) — the dataset is \`ready\` immediately. Omit \`source\` to upload instead: the response is \`pending_upload\` and carries an \`upload\` block of presigned PUT targets; PUT the data, then call commit to seal the immutable manifest.`,
+Register a dataset by reference (\`source\`: an external dataset reference passed to the trainer as-is, or a \`repo://{repo}[@{revision}][/{path}]\` reference reserved for the versioned dataset store) — the dataset is \`ready\` immediately. Omit \`source\` to upload instead: the response is \`pending_upload\` and carries an \`upload\` block describing where to PUT the data. When the artifact store is not internet-exposed (the default posture) the block is \`mode: api\` and the target is the API upload path; when a public artifact endpoint is configured it is \`mode: presigned\` with time-bounded presigned PUT URLs. PUT the data, then call commit to seal the immutable manifest.`,
     args: args283,
     tool: async (client, args284, ctx) => {
       const [result, apiCall] = await servingDatasetsCreate(client, args284.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
@@ -134853,11 +134929,132 @@ List your datasets.`,
   };
 });
 
-// src/funcs/servingDeploymentsCreate.ts
-function servingDeploymentsCreate(client, request, options) {
+// src/funcs/servingDatasetsUploadContent.ts
+function servingDatasetsUploadContent(client, request, options) {
   return new APIPromise($do296(client, request, options));
 }
 async function $do296(client, request, options) {
+  const parsed = safeParse4(request, (value) => UploadServingDatasetContentRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = payload.RequestBody instanceof Uint8Array ? new Uint8Array(payload.RequestBody).buffer : payload.RequestBody;
+  const pathParams = {
+    dataset_id: encodeSimple("dataset_id", payload.dataset_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/api/v1/serving/datasets/{dataset_id}/content")(pathParams);
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/octet-stream",
+    Accept: "application/json",
+    "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: "uploadServingDatasetContent",
+    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: "PUT",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    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(json(200, DatasetUploadReceipt$inboundSchema), jsonErr([403, 404, 409, 413], ServingError$inboundSchema), jsonErr(422, ServingHTTPValidationError$inboundSchema), fail([401, "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_servingDatasetsUploadContent = __esm(() => {
+  init_encodings();
+  init_http();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_components();
+  init_errors4();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/servingDatasetsUploadContent.ts
+var args287, tool$servingDatasetsUploadContent;
+var init_servingDatasetsUploadContent2 = __esm(() => {
+  init_servingDatasetsUploadContent();
+  init_operations();
+  init_tools();
+  args287 = {
+    request: UploadServingDatasetContentRequest$inboundSchema
+  };
+  tool$servingDatasetsUploadContent = {
+    name: "serving-datasets-upload-content",
+    description: `Upload dataset content through the API
+
+Stream the raw dataset bytes through the serving API into the dataset's object storage. Valid only while the dataset is \`pending_upload\`; repeating the upload before commit overwrites the previous bytes. The response receipt carries the stored size and SHA-256 digest so the client can verify the bytes before calling commit. Uploads are capped by the cluster's configured maximum dataset size.`,
+    args: args287,
+    tool: async (client, args288, ctx) => {
+      const [result, apiCall] = await servingDatasetsUploadContent(client, args288.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/servingDeploymentsCreate.ts
+function servingDeploymentsCreate(client, request, options) {
+  return new APIPromise($do297(client, request, options));
+}
+async function $do297(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateDeploymentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -134940,12 +135137,12 @@ var init_servingDeploymentsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/servingDeploymentsCreate.ts
-var args287, tool$servingDeploymentsCreate;
+var args288, tool$servingDeploymentsCreate;
 var init_servingDeploymentsCreate2 = __esm(() => {
   init_servingDeploymentsCreate();
   init_operations();
   init_tools();
-  args287 = {
+  args288 = {
     request: CreateDeploymentRequest$inboundSchema
   };
   tool$servingDeploymentsCreate = {
@@ -134953,9 +135150,9 @@ var init_servingDeploymentsCreate2 = __esm(() => {
     description: `Create an inference deployment
 
 Create and start an inference deployment for a model, and return its endpoint.`,
-    args: args287,
-    tool: async (client, args288, ctx) => {
-      const [result, apiCall] = await servingDeploymentsCreate(client, args288.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args288,
+    tool: async (client, args289, ctx) => {
+      const [result, apiCall] = await servingDeploymentsCreate(client, args289.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -134970,9 +135167,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($do297(client, request, options));
+  return new APIPromise($do298(client, request, options));
 }
-async function $do297(client, request, options) {
+async function $do298(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteDeploymentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135060,12 +135257,12 @@ var init_servingDeploymentsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/servingDeploymentsDelete.ts
-var args288, tool$servingDeploymentsDelete;
+var args289, tool$servingDeploymentsDelete;
 var init_servingDeploymentsDelete2 = __esm(() => {
   init_servingDeploymentsDelete();
   init_operations();
   init_tools();
-  args288 = {
+  args289 = {
     request: DeleteDeploymentRequest$inboundSchema
   };
   tool$servingDeploymentsDelete = {
@@ -135073,9 +135270,9 @@ var init_servingDeploymentsDelete2 = __esm(() => {
     description: `Tear down a deployment
 
 Tear down a deployment and release its resources.`,
-    args: args288,
-    tool: async (client, args289, ctx) => {
-      const [result, apiCall] = await servingDeploymentsDelete(client, args289.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args289,
+    tool: async (client, args290, ctx) => {
+      const [result, apiCall] = await servingDeploymentsDelete(client, args290.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -135089,9 +135286,9 @@ Tear down a deployment and release its resources.`,
 
 // src/funcs/servingDeploymentsDeregister.ts
 function servingDeploymentsDeregister(client, request, options) {
-  return new APIPromise($do298(client, request, options));
+  return new APIPromise($do299(client, request, options));
 }
-async function $do298(client, request, options) {
+async function $do299(client, request, options) {
   const parsed = safeParse4(request, (value) => DeregisterDeploymentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135179,12 +135376,12 @@ var init_servingDeploymentsDeregister = __esm(() => {
 });
 
 // src/mcp-server/tools/servingDeploymentsDeregister.ts
-var args289, tool$servingDeploymentsDeregister;
+var args290, tool$servingDeploymentsDeregister;
 var init_servingDeploymentsDeregister2 = __esm(() => {
   init_servingDeploymentsDeregister();
   init_operations();
   init_tools();
-  args289 = {
+  args290 = {
     request: DeregisterDeploymentRequest$inboundSchema
   };
   tool$servingDeploymentsDeregister = {
@@ -135192,9 +135389,9 @@ var init_servingDeploymentsDeregister2 = __esm(() => {
     description: `Deregister the model from the LLM gateway
 
 Withdraw the deployment's model from the LLM gateway registry: inference stops resolving, compute keeps running (re-register any time).`,
-    args: args289,
-    tool: async (client, args290, ctx) => {
-      const [result, apiCall] = await servingDeploymentsDeregister(client, args290.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args290,
+    tool: async (client, args291, ctx) => {
+      const [result, apiCall] = await servingDeploymentsDeregister(client, args291.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -135208,9 +135405,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($do299(client, request, options));
+  return new APIPromise($do300(client, request, options));
 }
-async function $do299(client, request, options) {
+async function $do300(client, request, options) {
   const parsed = safeParse4(request, (value) => GetDeploymentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135298,12 +135495,12 @@ var init_servingDeploymentsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/servingDeploymentsGet.ts
-var args290, tool$servingDeploymentsGet;
+var args291, tool$servingDeploymentsGet;
 var init_servingDeploymentsGet2 = __esm(() => {
   init_servingDeploymentsGet();
   init_operations();
   init_tools();
-  args290 = {
+  args291 = {
     request: GetDeploymentRequest$inboundSchema
   };
   tool$servingDeploymentsGet = {
@@ -135311,9 +135508,9 @@ var init_servingDeploymentsGet2 = __esm(() => {
     description: `Get a deployment
 
 Retrieve a single deployment, including its status and endpoint URL.`,
-    args: args290,
-    tool: async (client, args291, ctx) => {
-      const [result, apiCall] = await servingDeploymentsGet(client, args291.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args291,
+    tool: async (client, args292, ctx) => {
+      const [result, apiCall] = await servingDeploymentsGet(client, args292.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -135328,9 +135525,9 @@ Retrieve a single deployment, including its status and endpoint URL.`,
 
 // src/funcs/servingDeploymentsGetLogs.ts
 function servingDeploymentsGetLogs(client, request, options) {
-  return new APIPromise($do300(client, request, options));
+  return new APIPromise($do301(client, request, options));
 }
-async function $do300(client, request, options) {
+async function $do301(client, request, options) {
   const parsed = safeParse4(request, (value) => GetDeploymentLogsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135422,12 +135619,12 @@ var init_servingDeploymentsGetLogs = __esm(() => {
 });
 
 // src/mcp-server/tools/servingDeploymentsGetLogs.ts
-var args291, tool$servingDeploymentsGetLogs;
+var args292, tool$servingDeploymentsGetLogs;
 var init_servingDeploymentsGetLogs2 = __esm(() => {
   init_servingDeploymentsGetLogs();
   init_operations();
   init_tools();
-  args291 = {
+  args292 = {
     request: GetDeploymentLogsRequest$inboundSchema
   };
   tool$servingDeploymentsGetLogs = {
@@ -135435,9 +135632,9 @@ var init_servingDeploymentsGetLogs2 = __esm(() => {
     description: `Fetch deployment logs
 
 Fetch recent log lines from a deployment's replicas.`,
-    args: args291,
-    tool: async (client, args292, ctx) => {
-      const [result, apiCall] = await servingDeploymentsGetLogs(client, args292.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args292,
+    tool: async (client, args293, ctx) => {
+      const [result, apiCall] = await servingDeploymentsGetLogs(client, args293.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -135452,9 +135649,9 @@ Fetch recent log lines from a deployment's replicas.`,
 
 // src/funcs/servingDeploymentsGetMetrics.ts
 function servingDeploymentsGetMetrics(client, request, options) {
-  return new APIPromise($do301(client, request, options));
+  return new APIPromise($do302(client, request, options));
 }
-async function $do301(client, request, options) {
+async function $do302(client, request, options) {
   const parsed = safeParse4(request, (value) => GetDeploymentMetricsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135542,12 +135739,12 @@ var init_servingDeploymentsGetMetrics = __esm(() => {
 });
 
 // src/mcp-server/tools/servingDeploymentsGetMetrics.ts
-var args292, tool$servingDeploymentsGetMetrics;
+var args293, tool$servingDeploymentsGetMetrics;
 var init_servingDeploymentsGetMetrics2 = __esm(() => {
   init_servingDeploymentsGetMetrics();
   init_operations();
   init_tools();
-  args292 = {
+  args293 = {
     request: GetDeploymentMetricsRequest$inboundSchema
   };
   tool$servingDeploymentsGetMetrics = {
@@ -135555,9 +135752,9 @@ var init_servingDeploymentsGetMetrics2 = __esm(() => {
     description: `Live serving metrics
 
 Return live serving metrics (throughput, queue depth, accelerator usage).`,
-    args: args292,
-    tool: async (client, args293, ctx) => {
-      const [result, apiCall] = await servingDeploymentsGetMetrics(client, args293.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args293,
+    tool: async (client, args294, ctx) => {
+      const [result, apiCall] = await servingDeploymentsGetMetrics(client, args294.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -135572,9 +135769,9 @@ Return live serving metrics (throughput, queue depth, accelerator usage).`,
 
 // src/funcs/servingDeploymentsList.ts
 function servingDeploymentsList(client, request, options) {
-  return new APIPromise($do302(client, request, options));
+  return new APIPromise($do303(client, request, options));
 }
-async function $do302(client, request, options) {
+async function $do303(client, request, options) {
   const parsed = safeParse4(request, (value) => ListDeploymentsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135661,12 +135858,12 @@ var init_servingDeploymentsList = __esm(() => {
 });
 
 // src/mcp-server/tools/servingDeploymentsList.ts
-var args293, tool$servingDeploymentsList;
+var args294, tool$servingDeploymentsList;
 var init_servingDeploymentsList2 = __esm(() => {
   init_servingDeploymentsList();
   init_operations();
   init_tools();
-  args293 = {
+  args294 = {
     request: ListDeploymentsRequest$inboundSchema
   };
   tool$servingDeploymentsList = {
@@ -135674,9 +135871,9 @@ var init_servingDeploymentsList2 = __esm(() => {
     description: `List deployments
 
 List your inference deployments.`,
-    args: args293,
-    tool: async (client, args294, ctx) => {
-      const [result, apiCall] = await servingDeploymentsList(client, args294.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args294,
+    tool: async (client, args295, ctx) => {
+      const [result, apiCall] = await servingDeploymentsList(client, args295.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -135691,9 +135888,9 @@ List your inference deployments.`,
 
 // src/funcs/servingDeploymentsListReplicas.ts
 function servingDeploymentsListReplicas(client, request, options) {
-  return new APIPromise($do303(client, request, options));
+  return new APIPromise($do304(client, request, options));
 }
-async function $do303(client, request, options) {
+async function $do304(client, request, options) {
   const parsed = safeParse4(request, (value) => ListReplicasRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135781,12 +135978,12 @@ var init_servingDeploymentsListReplicas = __esm(() => {
 });
 
 // src/mcp-server/tools/servingDeploymentsListReplicas.ts
-var args294, tool$servingDeploymentsListReplicas;
+var args295, tool$servingDeploymentsListReplicas;
 var init_servingDeploymentsListReplicas2 = __esm(() => {
   init_servingDeploymentsListReplicas();
   init_operations();
   init_tools();
-  args294 = {
+  args295 = {
     request: ListReplicasRequest$inboundSchema
   };
   tool$servingDeploymentsListReplicas = {
@@ -135794,9 +135991,9 @@ var init_servingDeploymentsListReplicas2 = __esm(() => {
     description: `List running replicas
 
 List the replicas currently backing a deployment.`,
-    args: args294,
-    tool: async (client, args295, ctx) => {
-      const [result, apiCall] = await servingDeploymentsListReplicas(client, args295.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args295,
+    tool: async (client, args296, ctx) => {
+      const [result, apiCall] = await servingDeploymentsListReplicas(client, args296.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -135811,9 +136008,9 @@ List the replicas currently backing a deployment.`,
 
 // src/funcs/servingDeploymentsListRevisions.ts
 function servingDeploymentsListRevisions(client, request, options) {
-  return new APIPromise($do304(client, request, options));
+  return new APIPromise($do305(client, request, options));
 }
-async function $do304(client, request, options) {
+async function $do305(client, request, options) {
   const parsed = safeParse4(request, (value) => ListRevisionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135901,12 +136098,12 @@ var init_servingDeploymentsListRevisions = __esm(() => {
 });
 
 // src/mcp-server/tools/servingDeploymentsListRevisions.ts
-var args295, tool$servingDeploymentsListRevisions;
+var args296, tool$servingDeploymentsListRevisions;
 var init_servingDeploymentsListRevisions2 = __esm(() => {
   init_servingDeploymentsListRevisions();
   init_operations();
   init_tools();
-  args295 = {
+  args296 = {
     request: ListRevisionsRequest$inboundSchema
   };
   tool$servingDeploymentsListRevisions = {
@@ -135914,9 +136111,9 @@ var init_servingDeploymentsListRevisions2 = __esm(() => {
     description: `List config revisions
 
 List a deployment's configuration revisions, most recent first.`,
-    args: args295,
-    tool: async (client, args296, ctx) => {
-      const [result, apiCall] = await servingDeploymentsListRevisions(client, args296.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args296,
+    tool: async (client, args297, ctx) => {
+      const [result, apiCall] = await servingDeploymentsListRevisions(client, args297.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -135931,9 +136128,9 @@ List a deployment's configuration revisions, most recent first.`,
 
 // src/funcs/servingDeploymentsRegister.ts
 function servingDeploymentsRegister(client, request, options) {
-  return new APIPromise($do305(client, request, options));
+  return new APIPromise($do306(client, request, options));
 }
-async function $do305(client, request, options) {
+async function $do306(client, request, options) {
   const parsed = safeParse4(request, (value) => RegisterDeploymentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -136021,12 +136218,12 @@ var init_servingDeploymentsRegister = __esm(() => {
 });
 
 // src/mcp-server/tools/servingDeploymentsRegister.ts
-var args296, tool$servingDeploymentsRegister;
+var args297, tool$servingDeploymentsRegister;
 var init_servingDeploymentsRegister2 = __esm(() => {
   init_servingDeploymentsRegister();
   init_operations();
   init_tools();
-  args296 = {
+  args297 = {
     request: RegisterDeploymentRequest$inboundSchema
   };
   tool$servingDeploymentsRegister = {
@@ -136034,9 +136231,9 @@ var init_servingDeploymentsRegister2 = __esm(() => {
     description: `Register the model with the LLM gateway
 
 Make the deployment's model available for inference: registers it in the LLM gateway's model registry under the deployment's name. Deployment must be ready. Registration is deliberately decoupled from deployment so pricing, budgets, and rate limits can be configured before the model becomes callable.`,
-    args: args296,
-    tool: async (client, args297, ctx) => {
-      const [result, apiCall] = await servingDeploymentsRegister(client, args297.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args297,
+    tool: async (client, args298, ctx) => {
+      const [result, apiCall] = await servingDeploymentsRegister(client, args298.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -136051,9 +136248,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($do306(client, request, options));
+  return new APIPromise($do307(client, request, options));
 }
-async function $do306(client, request, options) {
+async function $do307(client, request, options) {
   const parsed = safeParse4(request, (value) => RollbackDeploymentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -136144,12 +136341,12 @@ var init_servingDeploymentsRollback = __esm(() => {
 });
 
 // src/mcp-server/tools/servingDeploymentsRollback.ts
-var args297, tool$servingDeploymentsRollback;
+var args298, tool$servingDeploymentsRollback;
 var init_servingDeploymentsRollback2 = __esm(() => {
   init_servingDeploymentsRollback();
   init_operations();
   init_tools();
-  args297 = {
+  args298 = {
     request: RollbackDeploymentRequest$inboundSchema
   };
   tool$servingDeploymentsRollback = {
@@ -136157,9 +136354,9 @@ var init_servingDeploymentsRollback2 = __esm(() => {
     description: `Roll back to a previous revision
 
 Roll a deployment back to a previous configuration revision.`,
-    args: args297,
-    tool: async (client, args298, ctx) => {
-      const [result, apiCall] = await servingDeploymentsRollback(client, args298.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args298,
+    tool: async (client, args299, ctx) => {
+      const [result, apiCall] = await servingDeploymentsRollback(client, args299.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -136174,9 +136371,9 @@ Roll a deployment back to a previous configuration revision.`,
 
 // src/funcs/servingDeploymentsUpdate.ts
 function servingDeploymentsUpdate(client, request, options) {
-  return new APIPromise($do307(client, request, options));
+  return new APIPromise($do308(client, request, options));
 }
-async function $do307(client, request, options) {
+async function $do308(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateDeploymentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -136265,12 +136462,12 @@ var init_servingDeploymentsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/servingDeploymentsUpdate.ts
-var args298, tool$servingDeploymentsUpdate;
+var args299, tool$servingDeploymentsUpdate;
 var init_servingDeploymentsUpdate2 = __esm(() => {
   init_servingDeploymentsUpdate();
   init_operations();
   init_tools();
-  args298 = {
+  args299 = {
     request: UpdateDeploymentRequest$inboundSchema
   };
   tool$servingDeploymentsUpdate = {
@@ -136278,9 +136475,9 @@ var init_servingDeploymentsUpdate2 = __esm(() => {
     description: `Update a deployment (new revision)
 
 Update a deployment's configuration, rolling out a new revision.`,
-    args: args298,
-    tool: async (client, args299, ctx) => {
-      const [result, apiCall] = await servingDeploymentsUpdate(client, args299.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args299,
+    tool: async (client, args300, ctx) => {
+      const [result, apiCall] = await servingDeploymentsUpdate(client, args300.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -136295,9 +136492,9 @@ Update a deployment's configuration, rolling out a new revision.`,
 
 // src/funcs/servingDeploymentsUpdateScaling.ts
 function servingDeploymentsUpdateScaling(client, request, options) {
-  return new APIPromise($do308(client, request, options));
+  return new APIPromise($do309(client, request, options));
 }
-async function $do308(client, request, options) {
+async function $do309(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateScalingRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -136388,12 +136585,12 @@ var init_servingDeploymentsUpdateScaling = __esm(() => {
 });
 
 // src/mcp-server/tools/servingDeploymentsUpdateScaling.ts
-var args299, tool$servingDeploymentsUpdateScaling;
+var args300, tool$servingDeploymentsUpdateScaling;
 var init_servingDeploymentsUpdateScaling2 = __esm(() => {
   init_servingDeploymentsUpdateScaling();
   init_operations();
   init_tools();
-  args299 = {
+  args300 = {
     request: UpdateScalingRequest$inboundSchema
   };
   tool$servingDeploymentsUpdateScaling = {
@@ -136401,9 +136598,9 @@ var init_servingDeploymentsUpdateScaling2 = __esm(() => {
     description: `Update autoscaling live (no redeploy)
 
 Change a deployment's autoscaling limits in place, without redeploying.`,
-    args: args299,
-    tool: async (client, args300, ctx) => {
-      const [result, apiCall] = await servingDeploymentsUpdateScaling(client, args300.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args300,
+    tool: async (client, args301, ctx) => {
+      const [result, apiCall] = await servingDeploymentsUpdateScaling(client, args301.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -136418,9 +136615,9 @@ Change a deployment's autoscaling limits in place, without redeploying.`,
 
 // src/funcs/servingEligibilityPreview.ts
 function servingEligibilityPreview(client, request, options) {
-  return new APIPromise($do309(client, request, options));
+  return new APIPromise($do310(client, request, options));
 }
-async function $do309(client, request, options) {
+async function $do310(client, request, options) {
   const parsed = safeParse4(request, (value) => PreviewEligibilityRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -136505,12 +136702,12 @@ var init_servingEligibilityPreview = __esm(() => {
 });
 
 // src/mcp-server/tools/servingEligibilityPreview.ts
-var args300, tool$servingEligibilityPreview;
+var args301, tool$servingEligibilityPreview;
 var init_servingEligibilityPreview2 = __esm(() => {
   init_servingEligibilityPreview();
   init_operations();
   init_tools();
-  args300 = {
+  args301 = {
     request: PreviewEligibilityRequest$inboundSchema
   };
   tool$servingEligibilityPreview = {
@@ -136518,9 +136715,9 @@ var init_servingEligibilityPreview2 = __esm(() => {
     description: `Preview accelerator eligibility
 
 Preview, before submitting a job or deployment, how much matching capacity the cluster can currently acquire and how likely it is to start. The response is provider-anonymous: counts, price bands, and advice only. This is an advisory read; it reserves nothing.`,
-    args: args300,
-    tool: async (client, args301, ctx) => {
-      const [result, apiCall] = await servingEligibilityPreview(client, args301.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args301,
+    tool: async (client, args302, ctx) => {
+      const [result, apiCall] = await servingEligibilityPreview(client, args302.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -136535,9 +136732,9 @@ Preview, before submitting a job or deployment, how much matching capacity the c
 
 // src/funcs/servingFinetuneJobsCancel.ts
 function servingFinetuneJobsCancel(client, request, options) {
-  return new APIPromise($do310(client, request, options));
+  return new APIPromise($do311(client, request, options));
 }
-async function $do310(client, request, options) {
+async function $do311(client, request, options) {
   const parsed = safeParse4(request, (value) => CancelFinetuneJobRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -136625,12 +136822,12 @@ var init_servingFinetuneJobsCancel = __esm(() => {
 });
 
 // src/mcp-server/tools/servingFinetuneJobsCancel.ts
-var args301, tool$servingFinetuneJobsCancel;
+var args302, tool$servingFinetuneJobsCancel;
 var init_servingFinetuneJobsCancel2 = __esm(() => {
   init_servingFinetuneJobsCancel();
   init_operations();
   init_tools();
-  args301 = {
+  args302 = {
     request: CancelFinetuneJobRequest$inboundSchema
   };
   tool$servingFinetuneJobsCancel = {
@@ -136638,9 +136835,9 @@ var init_servingFinetuneJobsCancel2 = __esm(() => {
     description: `Cancel a fine-tune job
 
 Cancel a running fine-tune job and return the updated job. Fine-tune records are never deleted: the cancelled job, its events, and its spend history stay readable.`,
-    args: args301,
-    tool: async (client, args302, ctx) => {
-      const [result, apiCall] = await servingFinetuneJobsCancel(client, args302.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args302,
+    tool: async (client, args303, ctx) => {
+      const [result, apiCall] = await servingFinetuneJobsCancel(client, args303.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -136655,9 +136852,9 @@ Cancel a running fine-tune job and return the updated job. Fine-tune records are
 
 // src/funcs/servingFinetuneJobsCreate.ts
 function servingFinetuneJobsCreate(client, request, options) {
-  return new APIPromise($do311(client, request, options));
+  return new APIPromise($do312(client, request, options));
 }
-async function $do311(client, request, options) {
+async function $do312(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateFinetuneJobRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -136740,12 +136937,12 @@ var init_servingFinetuneJobsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/servingFinetuneJobsCreate.ts
-var args302, tool$servingFinetuneJobsCreate;
+var args303, tool$servingFinetuneJobsCreate;
 var init_servingFinetuneJobsCreate2 = __esm(() => {
   init_servingFinetuneJobsCreate();
   init_operations();
   init_tools();
-  args302 = {
+  args303 = {
     request: CreateFinetuneJobRequest$inboundSchema
   };
   tool$servingFinetuneJobsCreate = {
@@ -136753,9 +136950,9 @@ var init_servingFinetuneJobsCreate2 = __esm(() => {
     description: `Submit a fine-tune job
 
 Submit a fine-tune job for a base model and dataset, and return its id.`,
-    args: args302,
-    tool: async (client, args303, ctx) => {
-      const [result, apiCall] = await servingFinetuneJobsCreate(client, args303.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args303,
+    tool: async (client, args304, ctx) => {
+      const [result, apiCall] = await servingFinetuneJobsCreate(client, args304.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -136770,9 +136967,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($do312(client, request, options));
+  return new APIPromise($do313(client, request, options));
 }
-async function $do312(client, request, options) {
+async function $do313(client, request, options) {
   const parsed = safeParse4(request, (value) => GetFinetuneJobRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -136860,12 +137057,12 @@ var init_servingFinetuneJobsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/servingFinetuneJobsGet.ts
-var args303, tool$servingFinetuneJobsGet;
+var args304, tool$servingFinetuneJobsGet;
 var init_servingFinetuneJobsGet2 = __esm(() => {
   init_servingFinetuneJobsGet();
   init_operations();
   init_tools();
-  args303 = {
+  args304 = {
     request: GetFinetuneJobRequest$inboundSchema
   };
   tool$servingFinetuneJobsGet = {
@@ -136873,9 +137070,9 @@ var init_servingFinetuneJobsGet2 = __esm(() => {
     description: `Get a fine-tune job
 
 Retrieve a fine-tune job, including its status and progress.`,
-    args: args303,
-    tool: async (client, args304, ctx) => {
-      const [result, apiCall] = await servingFinetuneJobsGet(client, args304.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args304,
+    tool: async (client, args305, ctx) => {
+      const [result, apiCall] = await servingFinetuneJobsGet(client, args305.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -136890,9 +137087,9 @@ Retrieve a fine-tune job, including its status and progress.`,
 
 // src/funcs/servingFinetuneJobsGetEvents.ts
 function servingFinetuneJobsGetEvents(client, request, options) {
-  return new APIPromise($do313(client, request, options));
+  return new APIPromise($do314(client, request, options));
 }
-async function $do313(client, request, options) {
+async function $do314(client, request, options) {
   const parsed = safeParse4(request, (value) => GetFinetuneEventsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -136986,12 +137183,12 @@ var init_servingFinetuneJobsGetEvents = __esm(() => {
 });
 
 // src/mcp-server/tools/servingFinetuneJobsGetEvents.ts
-var args304, tool$servingFinetuneJobsGetEvents;
+var args305, tool$servingFinetuneJobsGetEvents;
 var init_servingFinetuneJobsGetEvents2 = __esm(() => {
   init_servingFinetuneJobsGetEvents();
   init_operations();
   init_tools();
-  args304 = {
+  args305 = {
     request: GetFinetuneEventsRequest$inboundSchema
   };
   tool$servingFinetuneJobsGetEvents = {
@@ -136999,9 +137196,9 @@ var init_servingFinetuneJobsGetEvents2 = __esm(() => {
     description: `Status timeline
 
 Return the job's status timeline (queued, running, checkpoints, completion).`,
-    args: args304,
-    tool: async (client, args305, ctx) => {
-      const [result, apiCall] = await servingFinetuneJobsGetEvents(client, args305.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args305,
+    tool: async (client, args306, ctx) => {
+      const [result, apiCall] = await servingFinetuneJobsGetEvents(client, args306.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -137016,9 +137213,9 @@ Return the job's status timeline (queued, running, checkpoints, completion).`,
 
 // src/funcs/servingFinetuneJobsGetLogs.ts
 function servingFinetuneJobsGetLogs(client, request, options) {
-  return new APIPromise($do314(client, request, options));
+  return new APIPromise($do315(client, request, options));
 }
-async function $do314(client, request, options) {
+async function $do315(client, request, options) {
   const parsed = safeParse4(request, (value) => GetFinetuneLogsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -137110,12 +137307,12 @@ var init_servingFinetuneJobsGetLogs = __esm(() => {
 });
 
 // src/mcp-server/tools/servingFinetuneJobsGetLogs.ts
-var args305, tool$servingFinetuneJobsGetLogs;
+var args306, tool$servingFinetuneJobsGetLogs;
 var init_servingFinetuneJobsGetLogs2 = __esm(() => {
   init_servingFinetuneJobsGetLogs();
   init_operations();
   init_tools();
-  args305 = {
+  args306 = {
     request: GetFinetuneLogsRequest$inboundSchema
   };
   tool$servingFinetuneJobsGetLogs = {
@@ -137123,9 +137320,9 @@ var init_servingFinetuneJobsGetLogs2 = __esm(() => {
     description: `Fetch training logs
 
 Fetch recent training log lines for a job.`,
-    args: args305,
-    tool: async (client, args306, ctx) => {
-      const [result, apiCall] = await servingFinetuneJobsGetLogs(client, args306.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args306,
+    tool: async (client, args307, ctx) => {
+      const [result, apiCall] = await servingFinetuneJobsGetLogs(client, args307.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -137140,9 +137337,9 @@ Fetch recent training log lines for a job.`,
 
 // src/funcs/servingFinetuneJobsGetMetrics.ts
 function servingFinetuneJobsGetMetrics(client, request, options) {
-  return new APIPromise($do315(client, request, options));
+  return new APIPromise($do316(client, request, options));
 }
-async function $do315(client, request, options) {
+async function $do316(client, request, options) {
   const parsed = safeParse4(request, (value) => GetFinetuneMetricsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -137235,12 +137432,12 @@ var init_servingFinetuneJobsGetMetrics = __esm(() => {
 });
 
 // src/mcp-server/tools/servingFinetuneJobsGetMetrics.ts
-var args306, tool$servingFinetuneJobsGetMetrics;
+var args307, tool$servingFinetuneJobsGetMetrics;
 var init_servingFinetuneJobsGetMetrics2 = __esm(() => {
   init_servingFinetuneJobsGetMetrics();
   init_operations();
   init_tools();
-  args306 = {
+  args307 = {
     request: GetFinetuneMetricsRequest$inboundSchema
   };
   tool$servingFinetuneJobsGetMetrics = {
@@ -137248,9 +137445,9 @@ var init_servingFinetuneJobsGetMetrics2 = __esm(() => {
     description: `Training metrics
 
 Return the training metric series (loss, learning rate, ...) pushed by the training run.`,
-    args: args306,
-    tool: async (client, args307, ctx) => {
-      const [result, apiCall] = await servingFinetuneJobsGetMetrics(client, args307.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args307,
+    tool: async (client, args308, ctx) => {
+      const [result, apiCall] = await servingFinetuneJobsGetMetrics(client, args308.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -137265,9 +137462,9 @@ Return the training metric series (loss, learning rate, ...) pushed by the train
 
 // src/funcs/servingFinetuneJobsList.ts
 function servingFinetuneJobsList(client, request, options) {
-  return new APIPromise($do316(client, request, options));
+  return new APIPromise($do317(client, request, options));
 }
-async function $do316(client, request, options) {
+async function $do317(client, request, options) {
   const parsed = safeParse4(request, (value) => ListFinetuneJobsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -137354,12 +137551,12 @@ var init_servingFinetuneJobsList = __esm(() => {
 });
 
 // src/mcp-server/tools/servingFinetuneJobsList.ts
-var args307, tool$servingFinetuneJobsList;
+var args308, tool$servingFinetuneJobsList;
 var init_servingFinetuneJobsList2 = __esm(() => {
   init_servingFinetuneJobsList();
   init_operations();
   init_tools();
-  args307 = {
+  args308 = {
     request: ListFinetuneJobsRequest$inboundSchema
   };
   tool$servingFinetuneJobsList = {
@@ -137367,9 +137564,9 @@ var init_servingFinetuneJobsList2 = __esm(() => {
     description: `List fine-tune jobs
 
 List your fine-tune jobs.`,
-    args: args307,
-    tool: async (client, args308, ctx) => {
-      const [result, apiCall] = await servingFinetuneJobsList(client, args308.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args308,
+    tool: async (client, args309, ctx) => {
+      const [result, apiCall] = await servingFinetuneJobsList(client, args309.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -137384,9 +137581,9 @@ List your fine-tune jobs.`,
 
 // src/funcs/servingFinetuneJobsListCheckpoints.ts
 function servingFinetuneJobsListCheckpoints(client, request, options) {
-  return new APIPromise($do317(client, request, options));
+  return new APIPromise($do318(client, request, options));
 }
-async function $do317(client, request, options) {
+async function $do318(client, request, options) {
   const parsed = safeParse4(request, (value) => ListFinetuneCheckpointsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -137479,12 +137676,12 @@ var init_servingFinetuneJobsListCheckpoints = __esm(() => {
 });
 
 // src/mcp-server/tools/servingFinetuneJobsListCheckpoints.ts
-var args308, tool$servingFinetuneJobsListCheckpoints;
+var args309, tool$servingFinetuneJobsListCheckpoints;
 var init_servingFinetuneJobsListCheckpoints2 = __esm(() => {
   init_servingFinetuneJobsListCheckpoints();
   init_operations();
   init_tools();
-  args308 = {
+  args309 = {
     request: ListFinetuneCheckpointsRequest$inboundSchema
   };
   tool$servingFinetuneJobsListCheckpoints = {
@@ -137492,9 +137689,9 @@ var init_servingFinetuneJobsListCheckpoints2 = __esm(() => {
     description: `List output checkpoints
 
 List the checkpoints a fine-tune job has produced.`,
-    args: args308,
-    tool: async (client, args309, ctx) => {
-      const [result, apiCall] = await servingFinetuneJobsListCheckpoints(client, args309.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args309,
+    tool: async (client, args310, ctx) => {
+      const [result, apiCall] = await servingFinetuneJobsListCheckpoints(client, args310.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -137509,9 +137706,9 @@ List the checkpoints a fine-tune job has produced.`,
 
 // src/funcs/servingImagesDelete.ts
 function servingImagesDelete(client, request, options) {
-  return new APIPromise($do318(client, request, options));
+  return new APIPromise($do319(client, request, options));
 }
-async function $do318(client, request, options) {
+async function $do319(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteImageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -137599,12 +137796,12 @@ var init_servingImagesDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/servingImagesDelete.ts
-var args309, tool$servingImagesDelete;
+var args310, tool$servingImagesDelete;
 var init_servingImagesDelete2 = __esm(() => {
   init_servingImagesDelete();
   init_operations();
   init_tools();
-  args309 = {
+  args310 = {
     request: DeleteImageRequest$inboundSchema
   };
   tool$servingImagesDelete = {
@@ -137612,9 +137809,9 @@ var init_servingImagesDelete2 = __esm(() => {
     description: `Delete an image
 
 Delete a container image.`,
-    args: args309,
-    tool: async (client, args310, ctx) => {
-      const [result, apiCall] = await servingImagesDelete(client, args310.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args310,
+    tool: async (client, args311, ctx) => {
+      const [result, apiCall] = await servingImagesDelete(client, args311.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -137628,9 +137825,9 @@ Delete a container image.`,
 
 // src/funcs/servingImagesGet.ts
 function servingImagesGet(client, request, options) {
-  return new APIPromise($do319(client, request, options));
+  return new APIPromise($do320(client, request, options));
 }
-async function $do319(client, request, options) {
+async function $do320(client, request, options) {
   const parsed = safeParse4(request, (value) => GetImageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -137718,12 +137915,12 @@ var init_servingImagesGet = __esm(() => {
 });
 
 // src/mcp-server/tools/servingImagesGet.ts
-var args310, tool$servingImagesGet;
+var args311, tool$servingImagesGet;
 var init_servingImagesGet2 = __esm(() => {
   init_servingImagesGet();
   init_operations();
   init_tools();
-  args310 = {
+  args311 = {
     request: GetImageRequest$inboundSchema
   };
   tool$servingImagesGet = {
@@ -137731,9 +137928,9 @@ var init_servingImagesGet2 = __esm(() => {
     description: `Get an image
 
 Retrieve an image, including its build status.`,
-    args: args310,
-    tool: async (client, args311, ctx) => {
-      const [result, apiCall] = await servingImagesGet(client, args311.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args311,
+    tool: async (client, args312, ctx) => {
+      const [result, apiCall] = await servingImagesGet(client, args312.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -137748,9 +137945,9 @@ Retrieve an image, including its build status.`,
 
 // src/funcs/servingImagesList.ts
 function servingImagesList(client, request, options) {
-  return new APIPromise($do320(client, request, options));
+  return new APIPromise($do321(client, request, options));
 }
-async function $do320(client, request, options) {
+async function $do321(client, request, options) {
   const parsed = safeParse4(request, (value) => ListImagesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -137837,12 +138034,12 @@ var init_servingImagesList = __esm(() => {
 });
 
 // src/mcp-server/tools/servingImagesList.ts
-var args311, tool$servingImagesList;
+var args312, tool$servingImagesList;
 var init_servingImagesList2 = __esm(() => {
   init_servingImagesList();
   init_operations();
   init_tools();
-  args311 = {
+  args312 = {
     request: ListImagesRequest$inboundSchema
   };
   tool$servingImagesList = {
@@ -137850,9 +138047,9 @@ var init_servingImagesList2 = __esm(() => {
     description: `List images
 
 List your container images.`,
-    args: args311,
-    tool: async (client, args312, ctx) => {
-      const [result, apiCall] = await servingImagesList(client, args312.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args312,
+    tool: async (client, args313, ctx) => {
+      const [result, apiCall] = await servingImagesList(client, args313.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -137867,9 +138064,9 @@ List your container images.`,
 
 // src/funcs/servingImagesRegister.ts
 function servingImagesRegister(client, request, options) {
-  return new APIPromise($do321(client, request, options));
+  return new APIPromise($do322(client, request, options));
 }
-async function $do321(client, request, options) {
+async function $do322(client, request, options) {
   const parsed = safeParse4(request, (value) => RegisterImageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -137952,12 +138149,12 @@ var init_servingImagesRegister = __esm(() => {
 });
 
 // src/mcp-server/tools/servingImagesRegister.ts
-var args312, tool$servingImagesRegister;
+var args313, tool$servingImagesRegister;
 var init_servingImagesRegister2 = __esm(() => {
   init_servingImagesRegister();
   init_operations();
   init_tools();
-  args312 = {
+  args313 = {
     request: RegisterImageRequest$inboundSchema
   };
   tool$servingImagesRegister = {
@@ -137965,9 +138162,9 @@ var init_servingImagesRegister2 = __esm(() => {
     description: `Register a container image
 
 Register a container image by reference so it can back a BYO deployment or a recipe. (Data upload and build-with-weight-baking are future additions.)`,
-    args: args312,
-    tool: async (client, args313, ctx) => {
-      const [result, apiCall] = await servingImagesRegister(client, args313.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args313,
+    tool: async (client, args314, ctx) => {
+      const [result, apiCall] = await servingImagesRegister(client, args314.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -137982,9 +138179,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($do322(client, request, options));
+  return new APIPromise($do323(client, request, options));
 }
-async function $do322(client, request, options) {
+async function $do323(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteServingModelRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -138072,12 +138269,12 @@ var init_servingModelsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/servingModelsDelete.ts
-var args313, tool$servingModelsDelete;
+var args314, tool$servingModelsDelete;
 var init_servingModelsDelete2 = __esm(() => {
   init_servingModelsDelete();
   init_operations();
   init_tools();
-  args313 = {
+  args314 = {
     request: DeleteServingModelRequest$inboundSchema
   };
   tool$servingModelsDelete = {
@@ -138085,9 +138282,9 @@ var init_servingModelsDelete2 = __esm(() => {
     description: `Deregister a model
 
 Deregister a model from the catalog.`,
-    args: args313,
-    tool: async (client, args314, ctx) => {
-      const [result, apiCall] = await servingModelsDelete(client, args314.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args314,
+    tool: async (client, args315, ctx) => {
+      const [result, apiCall] = await servingModelsDelete(client, args315.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -138101,9 +138298,9 @@ Deregister a model from the catalog.`,
 
 // src/funcs/servingModelsGet.ts
 function servingModelsGet(client, request, options) {
-  return new APIPromise($do323(client, request, options));
+  return new APIPromise($do324(client, request, options));
 }
-async function $do323(client, request, options) {
+async function $do324(client, request, options) {
   const parsed = safeParse4(request, (value) => GetServingModelRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -138191,12 +138388,12 @@ var init_servingModelsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/servingModelsGet.ts
-var args314, tool$servingModelsGet;
+var args315, tool$servingModelsGet;
 var init_servingModelsGet2 = __esm(() => {
   init_servingModelsGet();
   init_operations();
   init_tools();
-  args314 = {
+  args315 = {
     request: GetServingModelRequest$inboundSchema
   };
   tool$servingModelsGet = {
@@ -138204,9 +138401,9 @@ var init_servingModelsGet2 = __esm(() => {
     description: `Get a model
 
 Retrieve a registered model.`,
-    args: args314,
-    tool: async (client, args315, ctx) => {
-      const [result, apiCall] = await servingModelsGet(client, args315.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args315,
+    tool: async (client, args316, ctx) => {
+      const [result, apiCall] = await servingModelsGet(client, args316.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -138221,9 +138418,9 @@ Retrieve a registered model.`,
 
 // src/funcs/servingModelsList.ts
 function servingModelsList(client, request, options) {
-  return new APIPromise($do324(client, request, options));
+  return new APIPromise($do325(client, request, options));
 }
-async function $do324(client, request, options) {
+async function $do325(client, request, options) {
   const parsed = safeParse4(request, (value) => ListServingModelsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -138310,12 +138507,12 @@ var init_servingModelsList = __esm(() => {
 });
 
 // src/mcp-server/tools/servingModelsList.ts
-var args315, tool$servingModelsList;
+var args316, tool$servingModelsList;
 var init_servingModelsList2 = __esm(() => {
   init_servingModelsList();
   init_operations();
   init_tools();
-  args315 = {
+  args316 = {
     request: ListServingModelsRequest$inboundSchema
   };
   tool$servingModelsList = {
@@ -138323,9 +138520,9 @@ var init_servingModelsList2 = __esm(() => {
     description: `List models
 
 List your registered models.`,
-    args: args315,
-    tool: async (client, args316, ctx) => {
-      const [result, apiCall] = await servingModelsList(client, args316.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args316,
+    tool: async (client, args317, ctx) => {
+      const [result, apiCall] = await servingModelsList(client, args317.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -138340,9 +138537,9 @@ List your registered models.`,
 
 // src/funcs/servingModelsRegister.ts
 function servingModelsRegister(client, request, options) {
-  return new APIPromise($do325(client, request, options));
+  return new APIPromise($do326(client, request, options));
 }
-async function $do325(client, request, options) {
+async function $do326(client, request, options) {
   const parsed = safeParse4(request, (value) => RegisterServingModelRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -138425,12 +138622,12 @@ var init_servingModelsRegister = __esm(() => {
 });
 
 // src/mcp-server/tools/servingModelsRegister.ts
-var args316, tool$servingModelsRegister;
+var args317, tool$servingModelsRegister;
 var init_servingModelsRegister2 = __esm(() => {
   init_servingModelsRegister();
   init_operations();
   init_tools();
-  args316 = {
+  args317 = {
     request: RegisterServingModelRequest$inboundSchema
   };
   tool$servingModelsRegister = {
@@ -138438,9 +138635,9 @@ var init_servingModelsRegister2 = __esm(() => {
     description: `Register a model
 
 Register a model (from a source or volume) so it can be deployed or fine-tuned.`,
-    args: args316,
-    tool: async (client, args317, ctx) => {
-      const [result, apiCall] = await servingModelsRegister(client, args317.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args317,
+    tool: async (client, args318, ctx) => {
+      const [result, apiCall] = await servingModelsRegister(client, args318.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -138455,9 +138652,9 @@ Register a model (from a source or volume) so it can be deployed or fine-tuned.`
 
 // src/funcs/servingRecipesDelete.ts
 function servingRecipesDelete(client, request, options) {
-  return new APIPromise($do326(client, request, options));
+  return new APIPromise($do327(client, request, options));
 }
-async function $do326(client, request, options) {
+async function $do327(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteServingRecipeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -138545,12 +138742,12 @@ var init_servingRecipesDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/servingRecipesDelete.ts
-var args317, tool$servingRecipesDelete;
+var args318, tool$servingRecipesDelete;
 var init_servingRecipesDelete2 = __esm(() => {
   init_servingRecipesDelete();
   init_operations();
   init_tools();
-  args317 = {
+  args318 = {
     request: DeleteServingRecipeRequest$inboundSchema
   };
   tool$servingRecipesDelete = {
@@ -138558,9 +138755,9 @@ var init_servingRecipesDelete2 = __esm(() => {
     description: `Delete a serving recipe
 
 Remove a recipe from the catalog. Rejected while any live deployment's active revision references the recipe. Cluster administrators only.`,
-    args: args317,
-    tool: async (client, args318, ctx) => {
-      const [result, apiCall] = await servingRecipesDelete(client, args318.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args318,
+    tool: async (client, args319, ctx) => {
+      const [result, apiCall] = await servingRecipesDelete(client, args319.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -138574,9 +138771,9 @@ Remove a recipe from the catalog. Rejected while any live deployment's active re
 
 // src/funcs/servingRecipesGet.ts
 function servingRecipesGet(client, request, options) {
-  return new APIPromise($do327(client, request, options));
+  return new APIPromise($do328(client, request, options));
 }
-async function $do327(client, request, options) {
+async function $do328(client, request, options) {
   const parsed = safeParse4(request, (value) => GetServingRecipeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -138664,12 +138861,12 @@ var init_servingRecipesGet = __esm(() => {
 });
 
 // src/mcp-server/tools/servingRecipesGet.ts
-var args318, tool$servingRecipesGet;
+var args319, tool$servingRecipesGet;
 var init_servingRecipesGet2 = __esm(() => {
   init_servingRecipesGet();
   init_operations();
   init_tools();
-  args318 = {
+  args319 = {
     request: GetServingRecipeRequest$inboundSchema
   };
   tool$servingRecipesGet = {
@@ -138677,9 +138874,9 @@ var init_servingRecipesGet2 = __esm(() => {
     description: `Get a serving recipe
 
 Get one recipe catalog record. Tenants can read enabled recipes; disabled recipes are visible to cluster administrators only.`,
-    args: args318,
-    tool: async (client, args319, ctx) => {
-      const [result, apiCall] = await servingRecipesGet(client, args319.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args319,
+    tool: async (client, args320, ctx) => {
+      const [result, apiCall] = await servingRecipesGet(client, args320.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -138694,9 +138891,9 @@ Get one recipe catalog record. Tenants can read enabled recipes; disabled recipe
 
 // src/funcs/servingRecipesList.ts
 function servingRecipesList(client, request, options) {
-  return new APIPromise($do328(client, request, options));
+  return new APIPromise($do329(client, request, options));
 }
-async function $do328(client, request, options) {
+async function $do329(client, request, options) {
   const parsed = safeParse4(request, (value) => ListServingRecipesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -138783,12 +138980,12 @@ var init_servingRecipesList = __esm(() => {
 });
 
 // src/mcp-server/tools/servingRecipesList.ts
-var args319, tool$servingRecipesList;
+var args320, tool$servingRecipesList;
 var init_servingRecipesList2 = __esm(() => {
   init_servingRecipesList();
   init_operations();
   init_tools();
-  args319 = {
+  args320 = {
     request: ListServingRecipesRequest$inboundSchema
   };
   tool$servingRecipesList = {
@@ -138796,9 +138993,9 @@ var init_servingRecipesList2 = __esm(() => {
     description: `List serving recipes
 
 List the cluster-global serving recipe catalog. Tenants see only enabled (deployable) recipes; cluster administrators see every registered recipe including disabled ones.`,
-    args: args319,
-    tool: async (client, args320, ctx) => {
-      const [result, apiCall] = await servingRecipesList(client, args320.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args320,
+    tool: async (client, args321, ctx) => {
+      const [result, apiCall] = await servingRecipesList(client, args321.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -138813,9 +139010,9 @@ List the cluster-global serving recipe catalog. Tenants see only enabled (deploy
 
 // src/funcs/servingRecipesRegister.ts
 function servingRecipesRegister(client, request, options) {
-  return new APIPromise($do329(client, request, options));
+  return new APIPromise($do330(client, request, options));
 }
-async function $do329(client, request, options) {
+async function $do330(client, request, options) {
   const parsed = safeParse4(request, (value) => RegisterServingRecipeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -138906,12 +139103,12 @@ var init_servingRecipesRegister = __esm(() => {
 });
 
 // src/mcp-server/tools/servingRecipesRegister.ts
-var args320, tool$servingRecipesRegister;
+var args321, tool$servingRecipesRegister;
 var init_servingRecipesRegister2 = __esm(() => {
   init_servingRecipesRegister();
   init_operations();
   init_tools();
-  args320 = {
+  args321 = {
     request: RegisterServingRecipeRequest$inboundSchema
   };
   tool$servingRecipesRegister = {
@@ -138919,9 +139116,9 @@ var init_servingRecipesRegister2 = __esm(() => {
     description: `Register a serving recipe
 
 Register (or re-register) a digest-pinned recipe manifest in the catalog. A new recipe registers disabled; re-registration replaces the manifest and preserves enablement. Cluster administrators only.`,
-    args: args320,
-    tool: async (client, args321, ctx) => {
-      const [result, apiCall] = await servingRecipesRegister(client, args321.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args321,
+    tool: async (client, args322, ctx) => {
+      const [result, apiCall] = await servingRecipesRegister(client, args322.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -138936,9 +139133,9 @@ Register (or re-register) a digest-pinned recipe manifest in the catalog. A new
 
 // src/funcs/servingRecipesSetEnabled.ts
 function servingRecipesSetEnabled(client, request, options) {
-  return new APIPromise($do330(client, request, options));
+  return new APIPromise($do331(client, request, options));
 }
-async function $do330(client, request, options) {
+async function $do331(client, request, options) {
   const parsed = safeParse4(request, (value) => SetServingRecipeEnabledRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -139029,12 +139226,12 @@ var init_servingRecipesSetEnabled = __esm(() => {
 });
 
 // src/mcp-server/tools/servingRecipesSetEnabled.ts
-var args321, tool$servingRecipesSetEnabled;
+var args322, tool$servingRecipesSetEnabled;
 var init_servingRecipesSetEnabled2 = __esm(() => {
   init_servingRecipesSetEnabled();
   init_operations();
   init_tools();
-  args321 = {
+  args322 = {
     request: SetServingRecipeEnabledRequest$inboundSchema
   };
   tool$servingRecipesSetEnabled = {
@@ -139042,9 +139239,9 @@ var init_servingRecipesSetEnabled2 = __esm(() => {
     description: `Enable or disable a serving recipe
 
 Toggle cluster-wide deployability of a registered recipe. Disabling does not stop deployments already running the recipe. Cluster administrators only.`,
-    args: args321,
-    tool: async (client, args322, ctx) => {
-      const [result, apiCall] = await servingRecipesSetEnabled(client, args322.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args322,
+    tool: async (client, args323, ctx) => {
+      const [result, apiCall] = await servingRecipesSetEnabled(client, args323.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -139059,9 +139256,9 @@ Toggle cluster-wide deployability of a registered recipe. Disabling does not sto
 
 // src/funcs/servingSecretsCreate.ts
 function servingSecretsCreate(client, request, options) {
-  return new APIPromise($do331(client, request, options));
+  return new APIPromise($do332(client, request, options));
 }
-async function $do331(client, request, options) {
+async function $do332(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateSecretRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -139144,12 +139341,12 @@ var init_servingSecretsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/servingSecretsCreate.ts
-var args322, tool$servingSecretsCreate;
+var args323, tool$servingSecretsCreate;
 var init_servingSecretsCreate2 = __esm(() => {
   init_servingSecretsCreate();
   init_operations();
   init_tools();
-  args322 = {
+  args323 = {
     request: CreateSecretRequest$inboundSchema
   };
   tool$servingSecretsCreate = {
@@ -139157,9 +139354,9 @@ var init_servingSecretsCreate2 = __esm(() => {
     description: `Create a secret
 
 Create a secret whose values are injected into your workloads as env vars.`,
-    args: args322,
-    tool: async (client, args323, ctx) => {
-      const [result, apiCall] = await servingSecretsCreate(client, args323.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args323,
+    tool: async (client, args324, ctx) => {
+      const [result, apiCall] = await servingSecretsCreate(client, args324.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -139174,9 +139371,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($do332(client, request, options));
+  return new APIPromise($do333(client, request, options));
 }
-async function $do332(client, request, options) {
+async function $do333(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteSecretRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -139264,12 +139461,12 @@ var init_servingSecretsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/servingSecretsDelete.ts
-var args323, tool$servingSecretsDelete;
+var args324, tool$servingSecretsDelete;
 var init_servingSecretsDelete2 = __esm(() => {
   init_servingSecretsDelete();
   init_operations();
   init_tools();
-  args323 = {
+  args324 = {
     request: DeleteSecretRequest$inboundSchema
   };
   tool$servingSecretsDelete = {
@@ -139277,9 +139474,9 @@ var init_servingSecretsDelete2 = __esm(() => {
     description: `Delete a secret
 
 Delete a secret.`,
-    args: args323,
-    tool: async (client, args324, ctx) => {
-      const [result, apiCall] = await servingSecretsDelete(client, args324.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args324,
+    tool: async (client, args325, ctx) => {
+      const [result, apiCall] = await servingSecretsDelete(client, args325.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -139293,9 +139490,9 @@ Delete a secret.`,
 
 // src/funcs/servingSecretsGet.ts
 function servingSecretsGet(client, request, options) {
-  return new APIPromise($do333(client, request, options));
+  return new APIPromise($do334(client, request, options));
 }
-async function $do333(client, request, options) {
+async function $do334(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSecretRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -139383,12 +139580,12 @@ var init_servingSecretsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/servingSecretsGet.ts
-var args324, tool$servingSecretsGet;
+var args325, tool$servingSecretsGet;
 var init_servingSecretsGet2 = __esm(() => {
   init_servingSecretsGet();
   init_operations();
   init_tools();
-  args324 = {
+  args325 = {
     request: GetSecretRequest$inboundSchema
   };
   tool$servingSecretsGet = {
@@ -139396,9 +139593,9 @@ var init_servingSecretsGet2 = __esm(() => {
     description: `Get a secret
 
 Retrieve secret metadata: key names and allowed use. Values are never returned.`,
-    args: args324,
-    tool: async (client, args325, ctx) => {
-      const [result, apiCall] = await servingSecretsGet(client, args325.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args325,
+    tool: async (client, args326, ctx) => {
+      const [result, apiCall] = await servingSecretsGet(client, args326.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -139413,9 +139610,9 @@ Retrieve secret metadata: key names and allowed use. Values are never returned.`
 
 // src/funcs/servingSecretsList.ts
 function servingSecretsList(client, request, options) {
-  return new APIPromise($do334(client, request, options));
+  return new APIPromise($do335(client, request, options));
 }
-async function $do334(client, request, options) {
+async function $do335(client, request, options) {
   const parsed = safeParse4(request, (value) => ListSecretsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -139502,12 +139699,12 @@ var init_servingSecretsList = __esm(() => {
 });
 
 // src/mcp-server/tools/servingSecretsList.ts
-var args325, tool$servingSecretsList;
+var args326, tool$servingSecretsList;
 var init_servingSecretsList2 = __esm(() => {
   init_servingSecretsList();
   init_operations();
   init_tools();
-  args325 = {
+  args326 = {
     request: ListSecretsRequest$inboundSchema
   };
   tool$servingSecretsList = {
@@ -139515,9 +139712,9 @@ var init_servingSecretsList2 = __esm(() => {
     description: `List secrets (names only)
 
 List your secrets by name (values are never returned).`,
-    args: args325,
-    tool: async (client, args326, ctx) => {
-      const [result, apiCall] = await servingSecretsList(client, args326.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args326,
+    tool: async (client, args327, ctx) => {
+      const [result, apiCall] = await servingSecretsList(client, args327.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -139532,9 +139729,9 @@ List your secrets by name (values are never returned).`,
 
 // src/funcs/servingSpendGet.ts
 function servingSpendGet(client, request, options) {
-  return new APIPromise($do335(client, request, options));
+  return new APIPromise($do336(client, request, options));
 }
-async function $do335(client, request, options) {
+async function $do336(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSpendRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -139621,12 +139818,12 @@ var init_servingSpendGet = __esm(() => {
 });
 
 // src/mcp-server/tools/servingSpendGet.ts
-var args326, tool$servingSpendGet;
+var args327, tool$servingSpendGet;
 var init_servingSpendGet2 = __esm(() => {
   init_servingSpendGet();
   init_operations();
   init_tools();
-  args326 = {
+  args327 = {
     request: GetSpendRequest$inboundSchema
   };
   tool$servingSpendGet = {
@@ -139634,9 +139831,9 @@ var init_servingSpendGet2 = __esm(() => {
     description: `Cost and spend summary
 
 Aggregate spend for your organization, computed from retained compute ledgers as price × runtime overlap with the requested window. Spend is derived on read and is never stored.`,
-    args: args326,
-    tool: async (client, args327, ctx) => {
-      const [result, apiCall] = await servingSpendGet(client, args327.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args327,
+    tool: async (client, args328, ctx) => {
+      const [result, apiCall] = await servingSpendGet(client, args328.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -139651,9 +139848,9 @@ Aggregate spend for your organization, computed from retained compute ledgers as
 
 // src/funcs/servingTenantsDeleteOrganization.ts
 function servingTenantsDeleteOrganization(client, request, options) {
-  return new APIPromise($do336(client, request, options));
+  return new APIPromise($do337(client, request, options));
 }
-async function $do336(client, request, options) {
+async function $do337(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteServingOrganizationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -139744,22 +139941,22 @@ var init_servingTenantsDeleteOrganization = __esm(() => {
 });
 
 // src/mcp-server/tools/servingTenantsDeleteOrganization.ts
-var args327, tool$servingTenantsDeleteOrganization;
+var args328, tool$servingTenantsDeleteOrganization;
 var init_servingTenantsDeleteOrganization2 = __esm(() => {
   init_servingTenantsDeleteOrganization();
   init_operations();
   init_tools();
-  args327 = {
+  args328 = {
     request: DeleteServingOrganizationRequest$inboundSchema
   };
   tool$servingTenantsDeleteOrganization = {
     name: "serving-tenants-delete-organization",
     description: `Trigger organization deletion teardown
 
-Durably records an organization.deleted.v1 event and starts (or adopts) the mandatory teardown cascade: the organization is fenced against new work and every deployment is tombstoned and wound down, while all pricing, budget, spend, and usage records are preserved. Idempotent by event id. Cluster administrators only.`,
-    args: args327,
-    tool: async (client, args328, ctx) => {
-      const [result, apiCall] = await servingTenantsDeleteOrganization(client, args328.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+Durably records an organization.deleted.v1 event and starts (or adopts) the mandatory teardown cascade: the organization is fenced against new work and every deployment is tombstoned and wound down, while all pricing, budget, spend, and usage records are preserved. Idempotent by event id. Cluster administrators only. Deprecated: this operation has moved to the operator admin plane at \`POST /api/v1/admin/tenants/{org_id}/deletion\`. This path keeps working for one transition release (responses carry \`Deprecation: true\` and a \`Link\` successor header) and is removed from this document in the next SDK major.`,
+    args: args328,
+    tool: async (client, args329, ctx) => {
+      const [result, apiCall] = await servingTenantsDeleteOrganization(client, args329.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -139774,9 +139971,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($do337(client, request, options));
+  return new APIPromise($do338(client, request, options));
 }
-async function $do337(client, request, options) {
+async function $do338(client, request, options) {
   const parsed = safeParse4(request, (value) => GetServingTenantRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -139864,22 +140061,22 @@ var init_servingTenantsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/servingTenantsGet.ts
-var args328, tool$servingTenantsGet;
+var args329, tool$servingTenantsGet;
 var init_servingTenantsGet2 = __esm(() => {
   init_servingTenantsGet();
   init_operations();
   init_tools();
-  args328 = {
+  args329 = {
     request: GetServingTenantRequest$inboundSchema
   };
   tool$servingTenantsGet = {
     name: "serving-tenants-get",
     description: `Get a serving tenant
 
-Get one organization's serving enablement record. Cluster administrators only.`,
-    args: args328,
-    tool: async (client, args329, ctx) => {
-      const [result, apiCall] = await servingTenantsGet(client, args329.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+Get one organization's serving enablement record. Cluster administrators only. Deprecated: this operation has moved to the operator admin plane at \`GET /api/v1/admin/tenants/{org_id}\`. This path keeps working for one transition release (responses carry \`Deprecation: true\` and a \`Link\` successor header) and is removed from this document in the next SDK major.`,
+    args: args329,
+    tool: async (client, args330, ctx) => {
+      const [result, apiCall] = await servingTenantsGet(client, args330.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -139894,9 +140091,9 @@ Get one organization's serving enablement record. Cluster administrators only.`,
 
 // src/funcs/servingTenantsGetOrganizationDeletion.ts
 function servingTenantsGetOrganizationDeletion(client, request, options) {
-  return new APIPromise($do338(client, request, options));
+  return new APIPromise($do339(client, request, options));
 }
-async function $do338(client, request, options) {
+async function $do339(client, request, options) {
   const parsed = safeParse4(request, (value) => GetServingOrganizationDeletionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -139984,22 +140181,22 @@ var init_servingTenantsGetOrganizationDeletion = __esm(() => {
 });
 
 // src/mcp-server/tools/servingTenantsGetOrganizationDeletion.ts
-var args329, tool$servingTenantsGetOrganizationDeletion;
+var args330, tool$servingTenantsGetOrganizationDeletion;
 var init_servingTenantsGetOrganizationDeletion2 = __esm(() => {
   init_servingTenantsGetOrganizationDeletion();
   init_operations();
   init_tools();
-  args329 = {
+  args330 = {
     request: GetServingOrganizationDeletionRequest$inboundSchema
   };
   tool$servingTenantsGetOrganizationDeletion = {
     name: "serving-tenants-get-organization-deletion",
     description: `Get organization deletion teardown state
 
-Returns the durable teardown-cascade state for an organization (running or complete), so a cluster administrator can confirm offboarding progressed to completion. 404 if the organization has no teardown. Cluster administrators only.`,
-    args: args329,
-    tool: async (client, args330, ctx) => {
-      const [result, apiCall] = await servingTenantsGetOrganizationDeletion(client, args330.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+Returns the durable teardown-cascade state for an organization (running or complete), so a cluster administrator can confirm offboarding progressed to completion. 404 if the organization has no teardown. Cluster administrators only. Deprecated: this operation has moved to the operator admin plane at \`GET /api/v1/admin/tenants/{org_id}/deletion\`. This path keeps working for one transition release (responses carry \`Deprecation: true\` and a \`Link\` successor header) and is removed from this document in the next SDK major.`,
+    args: args330,
+    tool: async (client, args331, ctx) => {
+      const [result, apiCall] = await servingTenantsGetOrganizationDeletion(client, args331.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -140014,9 +140211,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($do339(client, request, options));
+  return new APIPromise($do340(client, request, options));
 }
-async function $do339(client, request, options) {
+async function $do340(client, request, options) {
   const parsed = safeParse4(request, (value) => ListServingTenantsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -140103,22 +140300,22 @@ var init_servingTenantsList = __esm(() => {
 });
 
 // src/mcp-server/tools/servingTenantsList.ts
-var args330, tool$servingTenantsList;
+var args331, tool$servingTenantsList;
 var init_servingTenantsList2 = __esm(() => {
   init_servingTenantsList();
   init_operations();
   init_tools();
-  args330 = {
+  args331 = {
     request: ListServingTenantsRequest$inboundSchema
   };
   tool$servingTenantsList = {
     name: "serving-tenants-list",
     description: `List serving tenants
 
-List organization-wide serving enablement records. Cluster administrators only; a missing organization is not provisioned.`,
-    args: args330,
-    tool: async (client, args331, ctx) => {
-      const [result, apiCall] = await servingTenantsList(client, args331.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+List organization-wide serving enablement records. Cluster administrators only; a missing organization is not provisioned. Deprecated: this operation has moved to the operator admin plane at \`GET /api/v1/admin/tenants\`. This path keeps working for one transition release (responses carry \`Deprecation: true\` and a \`Link\` successor header) and is removed from this document in the next SDK major.`,
+    args: args331,
+    tool: async (client, args332, ctx) => {
+      const [result, apiCall] = await servingTenantsList(client, args332.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -140133,9 +140330,9 @@ List organization-wide serving enablement records. Cluster administrators only;
 
 // src/funcs/servingTenantsSet.ts
 function servingTenantsSet(client, request, options) {
-  return new APIPromise($do340(client, request, options));
+  return new APIPromise($do341(client, request, options));
 }
-async function $do340(client, request, options) {
+async function $do341(client, request, options) {
   const parsed = safeParse4(request, (value) => SetServingTenantRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -140224,22 +140421,22 @@ var init_servingTenantsSet = __esm(() => {
 });
 
 // src/mcp-server/tools/servingTenantsSet.ts
-var args331, tool$servingTenantsSet;
+var args332, tool$servingTenantsSet;
 var init_servingTenantsSet2 = __esm(() => {
   init_servingTenantsSet();
   init_operations();
   init_tools();
-  args331 = {
+  args332 = {
     request: SetServingTenantRequest$inboundSchema
   };
   tool$servingTenantsSet = {
     name: "serving-tenants-set",
     description: `Set serving tenant enablement
 
-Enable or disable serving for an organization and all of its teams. Disabling blocks product API access but does not stop existing workloads or callbacks. Cluster administrators only.`,
-    args: args331,
-    tool: async (client, args332, ctx) => {
-      const [result, apiCall] = await servingTenantsSet(client, args332.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+Enable or disable serving for an organization and all of its teams. Disabling blocks product API access but does not stop existing workloads or callbacks. Cluster administrators only. Deprecated: this operation has moved to the operator admin plane at \`PUT /api/v1/admin/tenants/{org_id}\`. This path keeps working for one transition release (responses carry \`Deprecation: true\` and a \`Link\` successor header) and is removed from this document in the next SDK major.`,
+    args: args332,
+    tool: async (client, args333, ctx) => {
+      const [result, apiCall] = await servingTenantsSet(client, args333.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -140254,9 +140451,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($do341(client, request, options));
+  return new APIPromise($do342(client, request, options));
 }
-async function $do341(client, request, options) {
+async function $do342(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateVolumeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -140339,12 +140536,12 @@ var init_servingVolumesCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/servingVolumesCreate.ts
-var args332, tool$servingVolumesCreate;
+var args333, tool$servingVolumesCreate;
 var init_servingVolumesCreate2 = __esm(() => {
   init_servingVolumesCreate();
   init_operations();
   init_tools();
-  args332 = {
+  args333 = {
     request: CreateVolumeRequest$inboundSchema
   };
   tool$servingVolumesCreate = {
@@ -140352,9 +140549,9 @@ var init_servingVolumesCreate2 = __esm(() => {
     description: `Create a volume
 
 Create a persistent volume for weights, datasets, or checkpoints.`,
-    args: args332,
-    tool: async (client, args333, ctx) => {
-      const [result, apiCall] = await servingVolumesCreate(client, args333.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args333,
+    tool: async (client, args334, ctx) => {
+      const [result, apiCall] = await servingVolumesCreate(client, args334.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -140369,9 +140566,9 @@ Create a persistent volume for weights, datasets, or checkpoints.`,
 
 // src/funcs/servingVolumesDelete.ts
 function servingVolumesDelete(client, request, options) {
-  return new APIPromise($do342(client, request, options));
+  return new APIPromise($do343(client, request, options));
 }
-async function $do342(client, request, options) {
+async function $do343(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteVolumeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -140459,12 +140656,12 @@ var init_servingVolumesDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/servingVolumesDelete.ts
-var args333, tool$servingVolumesDelete;
+var args334, tool$servingVolumesDelete;
 var init_servingVolumesDelete2 = __esm(() => {
   init_servingVolumesDelete();
   init_operations();
   init_tools();
-  args333 = {
+  args334 = {
     request: DeleteVolumeRequest$inboundSchema
   };
   tool$servingVolumesDelete = {
@@ -140472,9 +140669,9 @@ var init_servingVolumesDelete2 = __esm(() => {
     description: `Delete a volume
 
 Delete a volume and its contents.`,
-    args: args333,
-    tool: async (client, args334, ctx) => {
-      const [result, apiCall] = await servingVolumesDelete(client, args334.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args334,
+    tool: async (client, args335, ctx) => {
+      const [result, apiCall] = await servingVolumesDelete(client, args335.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -140488,9 +140685,9 @@ Delete a volume and its contents.`,
 
 // src/funcs/servingVolumesGet.ts
 function servingVolumesGet(client, request, options) {
-  return new APIPromise($do343(client, request, options));
+  return new APIPromise($do344(client, request, options));
 }
-async function $do343(client, request, options) {
+async function $do344(client, request, options) {
   const parsed = safeParse4(request, (value) => GetVolumeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -140578,12 +140775,12 @@ var init_servingVolumesGet = __esm(() => {
 });
 
 // src/mcp-server/tools/servingVolumesGet.ts
-var args334, tool$servingVolumesGet;
+var args335, tool$servingVolumesGet;
 var init_servingVolumesGet2 = __esm(() => {
   init_servingVolumesGet();
   init_operations();
   init_tools();
-  args334 = {
+  args335 = {
     request: GetVolumeRequest$inboundSchema
   };
   tool$servingVolumesGet = {
@@ -140591,9 +140788,9 @@ var init_servingVolumesGet2 = __esm(() => {
     description: `Get a volume
 
 Retrieve a volume.`,
-    args: args334,
-    tool: async (client, args335, ctx) => {
-      const [result, apiCall] = await servingVolumesGet(client, args335.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args335,
+    tool: async (client, args336, ctx) => {
+      const [result, apiCall] = await servingVolumesGet(client, args336.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -140608,9 +140805,9 @@ Retrieve a volume.`,
 
 // src/funcs/servingVolumesList.ts
 function servingVolumesList(client, request, options) {
-  return new APIPromise($do344(client, request, options));
+  return new APIPromise($do345(client, request, options));
 }
-async function $do344(client, request, options) {
+async function $do345(client, request, options) {
   const parsed = safeParse4(request, (value) => ListVolumesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -140697,12 +140894,12 @@ var init_servingVolumesList = __esm(() => {
 });
 
 // src/mcp-server/tools/servingVolumesList.ts
-var args335, tool$servingVolumesList;
+var args336, tool$servingVolumesList;
 var init_servingVolumesList2 = __esm(() => {
   init_servingVolumesList();
   init_operations();
   init_tools();
-  args335 = {
+  args336 = {
     request: ListVolumesRequest$inboundSchema
   };
   tool$servingVolumesList = {
@@ -140710,9 +140907,9 @@ var init_servingVolumesList2 = __esm(() => {
     description: `List volumes
 
 List your volumes.`,
-    args: args335,
-    tool: async (client, args336, ctx) => {
-      const [result, apiCall] = await servingVolumesList(client, args336.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args336,
+    tool: async (client, args337, ctx) => {
+      const [result, apiCall] = await servingVolumesList(client, args337.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -140727,9 +140924,9 @@ List your volumes.`,
 
 // src/funcs/usageCosts.ts
 function usageCosts(client, request, options) {
-  return new APIPromise($do345(client, request, options));
+  return new APIPromise($do346(client, request, options));
 }
-async function $do345(client, request, options) {
+async function $do346(client, request, options) {
   const parsed = safeParse4(request, (value) => GetCostsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -140812,12 +141009,12 @@ var init_usageCosts = __esm(() => {
 });
 
 // src/mcp-server/tools/usageCosts.ts
-var args336, tool$usageCosts;
+var args337, tool$usageCosts;
 var init_usageCosts2 = __esm(() => {
   init_usageCosts();
   init_operations();
   init_tools();
-  args336 = {
+  args337 = {
     request: GetCostsRequest$inboundSchema
   };
   tool$usageCosts = {
@@ -140825,9 +141022,9 @@ var init_usageCosts2 = __esm(() => {
     description: `Aggregate cost by dimension
 
 Sums stored per-entry cost over [start_time, end_time), grouped by any of service, task_type, model, api_key_id, team_id, user_id, external_user_id, org_id. Point-in-time correct for chargeback/showback.`,
-    args: args336,
-    tool: async (client, args337, ctx) => {
-      const [result, apiCall] = await usageCosts(client, args337.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args337,
+    tool: async (client, args338, ctx) => {
+      const [result, apiCall] = await usageCosts(client, args338.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -140842,9 +141039,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($do346(client, request, options));
+  return new APIPromise($do347(client, request, options));
 }
-async function $do346(client, request, options) {
+async function $do347(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSandboxUsageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -140935,12 +141132,12 @@ var init_usageSandbox = __esm(() => {
 });
 
 // src/mcp-server/tools/usageSandbox.ts
-var args337, tool$usageSandbox;
+var args338, tool$usageSandbox;
 var init_usageSandbox2 = __esm(() => {
   init_usageSandbox();
   init_operations();
   init_tools();
-  args337 = {
+  args338 = {
     request: GetSandboxUsageRequest$inboundSchema
   };
   tool$usageSandbox = {
@@ -140948,9 +141145,9 @@ var init_usageSandbox2 = __esm(() => {
     description: `Get Sandbox Usage
 
 Aggregate sandbox usage (session lifecycle, execution, and workspace operations) over a time range, bucketed and optionally grouped. Org-scoped: callers see their own usage, org admins their team's; cluster admins may pass \`all_orgs\` or \`org_ids\`. Cost and spend reporting lives in the budgeting API (\`/api/v1/budgeting/usage/costs\`).`,
-    args: args337,
-    tool: async (client, args338, ctx) => {
-      const [result, apiCall] = await usageSandbox(client, args338.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args338,
+    tool: async (client, args339, ctx) => {
+      const [result, apiCall] = await usageSandbox(client, args339.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -140967,7 +141164,7 @@ Aggregate sandbox usage (session lifecycle, execution, and workspace operations)
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "SDK",
-    version: "0.51.19"
+    version: "0.51.21"
   });
   const client = new SDKCore({
     bearerAuth: deps.bearerAuth,
@@ -141278,6 +141475,7 @@ function createMCPServer(deps) {
   tool(tool$servingDatasetsDelete);
   tool(tool$servingDatasetsGet);
   tool(tool$servingDatasetsCommit);
+  tool(tool$servingDatasetsUploadContent);
   tool(tool$servingDeploymentsList);
   tool(tool$servingDeploymentsCreate);
   tool(tool$servingDeploymentsDelete);
@@ -141629,6 +141827,7 @@ var init_server2 = __esm(() => {
   init_servingDatasetsDelete2();
   init_servingDatasetsGet2();
   init_servingDatasetsList2();
+  init_servingDatasetsUploadContent2();
   init_servingDeploymentsCreate2();
   init_servingDeploymentsDelete2();
   init_servingDeploymentsDeregister2();
@@ -142857,7 +143056,7 @@ var routes = rn({
 var app = Ve(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.51.19"
+    currentVersion: "0.51.21"
   }
 });
 _t(app, process3.argv.slice(2), buildContext(process3));
@@ -142865,5 +143064,5 @@ export {
   app
 };
 
-//# debugId=68A0880E00FC9CCA64756E2164756E21
+//# debugId=C27E385DE65864AD64756E2164756E21
 //# sourceMappingURL=mcp-server.js.map