@meetkai/mka1 0.51.5 → 0.51.6

package/bin/mcp-server.js

@@ -52876,9 +52876,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.1.0",
-    sdkVersion: "0.51.5",
+    sdkVersion: "0.51.6",
     genVersion: "2.918.4",
-    userAgent: "speakeasy-sdk/typescript 0.51.5 2.918.4 1.1.0 @meetkai/mka1"
+    userAgent: "speakeasy-sdk/typescript 0.51.6 2.918.4 1.1.0 @meetkai/mka1"
   };
 });
 
@@ -63485,6 +63485,59 @@ var init_deployment = __esm(() => {
   });
 });
 
+// src/models/components/deploymentapiformat.ts
+var DeploymentAPIFormat, DeploymentAPIFormat$inboundSchema, DeploymentAPIFormat$outboundSchema;
+var init_deploymentapiformat = __esm(() => {
+  init_esm();
+  DeploymentAPIFormat = {
+    Responses: "responses",
+    Completions: "completions",
+    Embeddings: "embeddings",
+    Images: "images",
+    Transcriptions: "transcriptions",
+    Tts: "tts"
+  };
+  DeploymentAPIFormat$inboundSchema = nativeEnumType(DeploymentAPIFormat);
+  DeploymentAPIFormat$outboundSchema = DeploymentAPIFormat$inboundSchema;
+});
+
+// src/models/components/deploymentscalingcreate.ts
+var DeploymentScalingCreate$inboundSchema, DeploymentScalingCreate$outboundSchema;
+var init_deploymentscalingcreate = __esm(() => {
+  init_esm();
+  init_primitives();
+  DeploymentScalingCreate$inboundSchema = objectType({
+    buffer_containers: numberType().int().default(0),
+    max_concurrent_inputs: numberType().int().default(100),
+    max_containers: numberType().int().default(1),
+    min_containers: numberType().int().default(1),
+    scaledown_window_s: numberType().int().default(300)
+  }).transform((v2) => {
+    return remap(v2, {
+      buffer_containers: "bufferContainers",
+      max_concurrent_inputs: "maxConcurrentInputs",
+      max_containers: "maxContainers",
+      min_containers: "minContainers",
+      scaledown_window_s: "scaledownWindowS"
+    });
+  });
+  DeploymentScalingCreate$outboundSchema = objectType({
+    bufferContainers: numberType().int().default(0),
+    maxConcurrentInputs: numberType().int().default(100),
+    maxContainers: numberType().int().default(1),
+    minContainers: numberType().int().default(1),
+    scaledownWindowS: numberType().int().default(300)
+  }).transform((v2) => {
+    return remap(v2, {
+      bufferContainers: "buffer_containers",
+      maxConcurrentInputs: "max_concurrent_inputs",
+      maxContainers: "max_containers",
+      minContainers: "min_containers",
+      scaledownWindowS: "scaledown_window_s"
+    });
+  });
+});
+
 // src/models/components/deploystrategy.ts
 var DeployStrategy, DeployStrategy$inboundSchema, DeployStrategy$outboundSchema;
 var init_deploystrategy = __esm(() => {
@@ -63503,43 +63556,56 @@ var init_deploymentcreate = __esm(() => {
   init_esm();
   init_primitives();
   init_acceleratorspec();
+  init_deploymentapiformat();
+  init_deploymentscalingcreate();
   init_deploystrategy();
   init_engine();
-  init_scaling();
   DeploymentCreate$inboundSchema = objectType({
     accelerator: AcceleratorSpec$inboundSchema,
+    api_format: DeploymentAPIFormat$inboundSchema.optional(),
     endpoint_auth: booleanType().default(true),
     engine: Engine$inboundSchema.optional(),
     engine_args: arrayType(stringType()).optional(),
     image: nullableType(stringType()).optional(),
+    max_usd_hr: numberType(),
     model: stringType(),
     name: stringType(),
-    scaling: Scaling$inboundSchema.optional(),
+    port: numberType().int().optional(),
+    runtime: stringType().optional(),
+    scaling: DeploymentScalingCreate$inboundSchema.optional(),
     secrets: arrayType(stringType()).optional(),
     strategy: DeployStrategy$inboundSchema.optional(),
     volume: nullableType(stringType()).optional()
   }).transform((v2) => {
     return remap(v2, {
+      api_format: "apiFormat",
       endpoint_auth: "endpointAuth",
-      engine_args: "engineArgs"
+      engine_args: "engineArgs",
+      max_usd_hr: "maxUsdHr"
     });
   });
   DeploymentCreate$outboundSchema = objectType({
     accelerator: AcceleratorSpec$outboundSchema,
+    apiFormat: DeploymentAPIFormat$outboundSchema.optional(),
     endpointAuth: booleanType().default(true),
     engine: Engine$outboundSchema.optional(),
     engineArgs: arrayType(stringType()).optional(),
     image: nullableType(stringType()).optional(),
+    maxUsdHr: numberType(),
     model: stringType(),
     name: stringType(),
-    scaling: Scaling$outboundSchema.optional(),
+    port: numberType().int().optional(),
+    runtime: stringType().optional(),
+    scaling: DeploymentScalingCreate$outboundSchema.optional(),
     secrets: arrayType(stringType()).optional(),
     strategy: DeployStrategy$outboundSchema.optional(),
     volume: nullableType(stringType()).optional()
   }).transform((v2) => {
     return remap(v2, {
+      apiFormat: "api_format",
       endpointAuth: "endpoint_auth",
-      engineArgs: "engine_args"
+      engineArgs: "engine_args",
+      maxUsdHr: "max_usd_hr"
     });
   });
 });
@@ -63559,31 +63625,77 @@ var init_deploymentrollbackrequest = __esm(() => {
   });
 });
 
+// src/models/components/deploymentscalingupdate.ts
+var DeploymentScalingUpdate$inboundSchema, DeploymentScalingUpdate$outboundSchema;
+var init_deploymentscalingupdate = __esm(() => {
+  init_esm();
+  init_primitives();
+  DeploymentScalingUpdate$inboundSchema = objectType({
+    buffer_containers: numberType().int().optional(),
+    max_concurrent_inputs: numberType().int().optional(),
+    max_containers: numberType().int().optional(),
+    min_containers: numberType().int().optional(),
+    scaledown_window_s: numberType().int().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      buffer_containers: "bufferContainers",
+      max_concurrent_inputs: "maxConcurrentInputs",
+      max_containers: "maxContainers",
+      min_containers: "minContainers",
+      scaledown_window_s: "scaledownWindowS"
+    });
+  });
+  DeploymentScalingUpdate$outboundSchema = objectType({
+    bufferContainers: numberType().int().optional(),
+    maxConcurrentInputs: numberType().int().optional(),
+    maxContainers: numberType().int().optional(),
+    minContainers: numberType().int().optional(),
+    scaledownWindowS: numberType().int().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      bufferContainers: "buffer_containers",
+      maxConcurrentInputs: "max_concurrent_inputs",
+      maxContainers: "max_containers",
+      minContainers: "min_containers",
+      scaledownWindowS: "scaledown_window_s"
+    });
+  });
+});
+
 // src/models/components/deploymentupdate.ts
 var DeploymentUpdate$inboundSchema, DeploymentUpdate$outboundSchema;
 var init_deploymentupdate = __esm(() => {
   init_esm();
   init_primitives();
+  init_deploymentapiformat();
   init_deploystrategy();
   DeploymentUpdate$inboundSchema = objectType({
+    api_format: nullableType(DeploymentAPIFormat$inboundSchema).optional(),
     engine_args: nullableType(arrayType(stringType())).optional(),
     image: nullableType(stringType()).optional(),
     model: nullableType(stringType()).optional(),
+    port: nullableType(numberType().int()).optional(),
+    runtime: nullableType(stringType()).optional(),
     secrets: nullableType(arrayType(stringType())).optional(),
     strategy: DeployStrategy$inboundSchema.optional()
   }).transform((v2) => {
     return remap(v2, {
+      api_format: "apiFormat",
       engine_args: "engineArgs"
     });
   });
   DeploymentUpdate$outboundSchema = objectType({
+    apiFormat: nullableType(DeploymentAPIFormat$outboundSchema).optional(),
     engineArgs: nullableType(arrayType(stringType())).optional(),
     image: nullableType(stringType()).optional(),
     model: nullableType(stringType()).optional(),
+    port: nullableType(numberType().int()).optional(),
+    runtime: nullableType(stringType()).optional(),
     secrets: nullableType(arrayType(stringType())).optional(),
     strategy: DeployStrategy$outboundSchema.optional()
   }).transform((v2) => {
     return remap(v2, {
+      apiFormat: "api_format",
       engineArgs: "engine_args"
     });
   });
@@ -69773,10 +69885,14 @@ var init_replica = __esm(() => {
     accelerator: AcceleratorSpec$inboundSchema,
     id: stringType(),
     node: nullableType(stringType()).optional(),
+    price_usd_hr: numberType().optional(),
+    provider: stringType().optional(),
+    region: stringType().optional(),
     started_at: nullableType(stringType().datetime({ offset: true }).transform((v2) => new Date(v2))).optional(),
     status: stringType()
   }).transform((v2) => {
     return remap(v2, {
+      price_usd_hr: "priceUsdHr",
       started_at: "startedAt"
     });
   });
@@ -69784,10 +69900,14 @@ var init_replica = __esm(() => {
     accelerator: AcceleratorSpec$outboundSchema,
     id: stringType(),
     node: nullableType(stringType()).optional(),
+    priceUsdHr: numberType().optional(),
+    provider: stringType().optional(),
+    region: stringType().optional(),
     startedAt: nullableType(dateType().transform((v2) => v2.toISOString())).optional(),
     status: stringType()
   }).transform((v2) => {
     return remap(v2, {
+      priceUsdHr: "price_usd_hr",
       startedAt: "started_at"
     });
   });
@@ -69934,6 +70054,67 @@ var init_pagesecret = __esm(() => {
   });
 });
 
+// src/models/components/servingtenant.ts
+var ServingTenant$inboundSchema, ServingTenant$outboundSchema;
+var init_servingtenant = __esm(() => {
+  init_esm();
+  init_primitives();
+  ServingTenant$inboundSchema = objectType({
+    disabled_at: nullableType(stringType().datetime({ offset: true }).transform((v2) => new Date(v2))),
+    enabled: booleanType(),
+    enabled_at: nullableType(stringType().datetime({ offset: true }).transform((v2) => new Date(v2))),
+    enabled_by: nullableType(stringType()),
+    org_id: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      disabled_at: "disabledAt",
+      enabled_at: "enabledAt",
+      enabled_by: "enabledBy",
+      org_id: "orgId"
+    });
+  });
+  ServingTenant$outboundSchema = objectType({
+    disabledAt: nullableType(dateType().transform((v2) => v2.toISOString())),
+    enabled: booleanType(),
+    enabledAt: nullableType(dateType().transform((v2) => v2.toISOString())),
+    enabledBy: nullableType(stringType()),
+    orgId: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      disabledAt: "disabled_at",
+      enabledAt: "enabled_at",
+      enabledBy: "enabled_by",
+      orgId: "org_id"
+    });
+  });
+});
+
+// src/models/components/pageservingtenant.ts
+var PageServingTenant$inboundSchema, PageServingTenant$outboundSchema;
+var init_pageservingtenant = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_servingtenant();
+  PageServingTenant$inboundSchema = objectType({
+    data: arrayType(ServingTenant$inboundSchema),
+    next_cursor: nullableType(stringType()).optional(),
+    total: numberType().int()
+  }).transform((v2) => {
+    return remap(v2, {
+      next_cursor: "nextCursor"
+    });
+  });
+  PageServingTenant$outboundSchema = objectType({
+    data: arrayType(ServingTenant$outboundSchema),
+    nextCursor: nullableType(stringType()).optional(),
+    total: numberType().int()
+  }).transform((v2) => {
+    return remap(v2, {
+      nextCursor: "next_cursor"
+    });
+  });
+});
+
 // src/models/components/volume.ts
 var Volume$inboundSchema, Volume$outboundSchema;
 var init_volume = __esm(() => {
@@ -74011,6 +74192,18 @@ var init_security2 = __esm(() => {
   });
 });
 
+// src/models/components/servingtenantset.ts
+var ServingTenantSet$inboundSchema, ServingTenantSet$outboundSchema;
+var init_servingtenantset = __esm(() => {
+  init_esm();
+  ServingTenantSet$inboundSchema = objectType({
+    enabled: booleanType()
+  });
+  ServingTenantSet$outboundSchema = objectType({
+    enabled: booleanType()
+  });
+});
+
 // src/models/components/servingvalidationerror.ts
 var Context$inboundSchema, Context$outboundSchema, ServingValidationErrorLoc$inboundSchema, ServingValidationErrorLoc$outboundSchema, ServingValidationError$inboundSchema, ServingValidationError$outboundSchema;
 var init_servingvalidationerror = __esm(() => {
@@ -76547,9 +76740,12 @@ var init_components = __esm(() => {
   init_deletepromptresponse();
   init_deleteresponseobject();
   init_deployment();
+  init_deploymentapiformat();
   init_deploymentcreate();
   init_deploymentendpoint();
   init_deploymentrollbackrequest();
+  init_deploymentscalingcreate();
+  init_deploymentscalingupdate();
   init_deploymentupdate();
   init_deploystrategy();
   init_doubleclickaction();
@@ -76754,6 +76950,7 @@ var init_components = __esm(() => {
   init_pagereplica();
   init_pagerevision();
   init_pagesecret();
+  init_pageservingtenant();
   init_pagevolume();
   init_pendingsafetycheck();
   init_preconfiguredskill();
@@ -76881,6 +77078,8 @@ var init_components = __esm(() => {
   init_secret();
   init_secretcreate();
   init_security2();
+  init_servingtenant();
+  init_servingtenantset();
   init_servingvalidationerror();
   init_sessionkind();
   init_sessionrecord();
@@ -90490,6 +90689,31 @@ var init_getservingmodel = __esm(() => {
   });
 });
 
+// src/models/operations/getservingtenant.ts
+var GetServingTenantRequest$inboundSchema, GetServingTenantRequest$outboundSchema;
+var init_getservingtenant = __esm(() => {
+  init_esm();
+  init_primitives();
+  GetServingTenantRequest$inboundSchema = objectType({
+    org_id: stringType(),
+    "X-On-Behalf-Of": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      org_id: "orgId",
+      "X-On-Behalf-Of": "xOnBehalfOf"
+    });
+  });
+  GetServingTenantRequest$outboundSchema = objectType({
+    orgId: stringType(),
+    xOnBehalfOf: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      orgId: "org_id",
+      xOnBehalfOf: "X-On-Behalf-Of"
+    });
+  });
+});
+
 // src/models/operations/getsession.ts
 var GetSessionRequest$inboundSchema, GetSessionRequest$outboundSchema;
 var init_getsession = __esm(() => {
@@ -93779,6 +94003,31 @@ var init_listservingmodels = __esm(() => {
   });
 });
 
+// src/models/operations/listservingtenants.ts
+var ListServingTenantsRequest$inboundSchema, ListServingTenantsRequest$outboundSchema;
+var init_listservingtenants = __esm(() => {
+  init_esm();
+  init_primitives();
+  ListServingTenantsRequest$inboundSchema = objectType({
+    cursor: nullableType(stringType()).optional(),
+    limit: numberType().int().default(50),
+    "X-On-Behalf-Of": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-On-Behalf-Of": "xOnBehalfOf"
+    });
+  });
+  ListServingTenantsRequest$outboundSchema = objectType({
+    cursor: nullableType(stringType()).optional(),
+    limit: numberType().int().default(50),
+    xOnBehalfOf: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      xOnBehalfOf: "X-On-Behalf-Of"
+    });
+  });
+});
+
 // src/models/operations/listsessions.ts
 var ListSessionsRequest$inboundSchema, ListSessionsRequest$outboundSchema;
 var init_listsessions = __esm(() => {
@@ -95854,6 +96103,36 @@ var init_setorgprice = __esm(() => {
   });
 });
 
+// src/models/operations/setservingtenant.ts
+var SetServingTenantRequest$inboundSchema, SetServingTenantRequest$outboundSchema;
+var init_setservingtenant = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  SetServingTenantRequest$inboundSchema = objectType({
+    org_id: stringType(),
+    "X-On-Behalf-Of": stringType().optional(),
+    ServingTenantSet: ServingTenantSet$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      org_id: "orgId",
+      "X-On-Behalf-Of": "xOnBehalfOf",
+      ServingTenantSet: "servingTenantSet"
+    });
+  });
+  SetServingTenantRequest$outboundSchema = objectType({
+    orgId: stringType(),
+    xOnBehalfOf: stringType().optional(),
+    servingTenantSet: ServingTenantSet$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      orgId: "org_id",
+      xOnBehalfOf: "X-On-Behalf-Of",
+      servingTenantSet: "ServingTenantSet"
+    });
+  });
+});
+
 // src/models/operations/setupwhatsappappwebhook.ts
 var SetupWhatsAppAppWebhookRequest$inboundSchema, SetupWhatsAppAppWebhookRequest$outboundSchema, SetupWhatsAppAppWebhookResponse$inboundSchema, SetupWhatsAppAppWebhookResponse$outboundSchema;
 var init_setupwhatsappappwebhook = __esm(() => {
@@ -97334,23 +97613,23 @@ var init_updatescaling = __esm(() => {
   UpdateScalingRequest$inboundSchema = objectType({
     deployment_id: stringType(),
     "X-On-Behalf-Of": stringType().optional(),
-    Scaling: Scaling$inboundSchema
+    DeploymentScalingUpdate: DeploymentScalingUpdate$inboundSchema
   }).transform((v2) => {
     return remap(v2, {
       deployment_id: "deploymentId",
       "X-On-Behalf-Of": "xOnBehalfOf",
-      Scaling: "scaling"
+      DeploymentScalingUpdate: "deploymentScalingUpdate"
     });
   });
   UpdateScalingRequest$outboundSchema = objectType({
     deploymentId: stringType(),
     xOnBehalfOf: stringType().optional(),
-    scaling: Scaling$outboundSchema
+    deploymentScalingUpdate: DeploymentScalingUpdate$outboundSchema
   }).transform((v2) => {
     return remap(v2, {
       deploymentId: "deployment_id",
       xOnBehalfOf: "X-On-Behalf-Of",
-      scaling: "Scaling"
+      deploymentScalingUpdate: "DeploymentScalingUpdate"
     });
   });
 });
@@ -98008,6 +98287,7 @@ var init_operations = __esm(() => {
   init_getsandboxusage();
   init_getserviceaccount2();
   init_getservingmodel();
+  init_getservingtenant();
   init_getsession();
   init_getsessionurl();
   init_getskill();
@@ -98079,6 +98359,7 @@ var init_operations = __esm(() => {
   init_listserviceaccountapikeys2();
   init_listserviceaccounts2();
   init_listservingmodels();
+  init_listservingtenants();
   init_listsessions();
   init_listskills();
   init_listskillversions();
@@ -98122,6 +98403,7 @@ var init_operations = __esm(() => {
   init_setcurrency();
   init_setorgbudget();
   init_setorgprice();
+  init_setservingtenant();
   init_setupwhatsappappwebhook();
   init_startexportfeedback();
   init_streamagentrunevents();
@@ -131947,7 +132229,7 @@ async function $do287(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(201, Deployment$inboundSchema), jsonErr(403, ServingError$inboundSchema), jsonErr(422, ServingHTTPValidationError$inboundSchema), fail([401, "4XX"]), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(201, Deployment$inboundSchema), jsonErr([401, 403, 404, 409], ServingError$inboundSchema), jsonErr(422, ServingHTTPValidationError$inboundSchema), jsonErr([500, 503], ServingError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -132067,7 +132349,7 @@ async function $do288(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(nil(204, voidType()), jsonErr([403, 404], ServingError$inboundSchema), jsonErr(422, ServingHTTPValidationError$inboundSchema), fail([401, "4XX"]), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(nil(204, voidType()), jsonErr([401, 403, 404], ServingError$inboundSchema), jsonErr(422, ServingHTTPValidationError$inboundSchema), jsonErr([500, 503], ServingError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -132186,7 +132468,7 @@ async function $do289(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(nil(204, voidType()), jsonErr([403, 404], ServingError$inboundSchema), jsonErr(422, ServingHTTPValidationError$inboundSchema), fail([401, "4XX"]), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(nil(204, voidType()), jsonErr([403, 404, 409], ServingError$inboundSchema), jsonErr(422, ServingHTTPValidationError$inboundSchema), jsonErr([500, 503], ServingError$inboundSchema), fail([401, "4XX"]), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -132305,7 +132587,7 @@ async function $do290(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, Deployment$inboundSchema), jsonErr([403, 404], ServingError$inboundSchema), jsonErr(422, ServingHTTPValidationError$inboundSchema), fail([401, "4XX"]), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(200, Deployment$inboundSchema), jsonErr([401, 403, 404], ServingError$inboundSchema), jsonErr(422, ServingHTTPValidationError$inboundSchema), jsonErr([500, 503], ServingError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -132669,7 +132951,7 @@ async function $do293(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, PageDeployment$inboundSchema), jsonErr(403, ServingError$inboundSchema), jsonErr(422, ServingHTTPValidationError$inboundSchema), fail([401, "4XX"]), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(200, PageDeployment$inboundSchema), jsonErr([401, 403], ServingError$inboundSchema), jsonErr(422, ServingHTTPValidationError$inboundSchema), jsonErr([500, 503], ServingError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -132789,7 +133071,7 @@ async function $do294(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, PageReplica$inboundSchema), jsonErr([403, 404], ServingError$inboundSchema), jsonErr(422, ServingHTTPValidationError$inboundSchema), fail([401, "4XX"]), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(200, PageReplica$inboundSchema), jsonErr([403, 404], ServingError$inboundSchema), jsonErr(422, ServingHTTPValidationError$inboundSchema), jsonErr([500, 503], ServingError$inboundSchema), fail([401, "4XX"]), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -132909,7 +133191,7 @@ async function $do295(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, PageRevision$inboundSchema), jsonErr([403, 404], ServingError$inboundSchema), jsonErr(422, ServingHTTPValidationError$inboundSchema), fail([401, "4XX"]), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(200, PageRevision$inboundSchema), jsonErr([401, 403, 404], ServingError$inboundSchema), jsonErr(422, ServingHTTPValidationError$inboundSchema), jsonErr([500, 503], ServingError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -133029,7 +133311,7 @@ async function $do296(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, Deployment$inboundSchema), jsonErr([403, 404, 409], ServingError$inboundSchema), jsonErr(422, ServingHTTPValidationError$inboundSchema), fail([401, "4XX"]), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(200, Deployment$inboundSchema), jsonErr([403, 404, 409], ServingError$inboundSchema), jsonErr(422, ServingHTTPValidationError$inboundSchema), jsonErr([500, 503], ServingError$inboundSchema), fail([401, "4XX"]), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -133273,7 +133555,7 @@ async function $do298(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, Deployment$inboundSchema), jsonErr([403, 404], ServingError$inboundSchema), jsonErr(422, ServingHTTPValidationError$inboundSchema), fail([401, "4XX"]), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(200, Deployment$inboundSchema), jsonErr([401, 403, 404], ServingError$inboundSchema), jsonErr(422, ServingHTTPValidationError$inboundSchema), jsonErr([500, 503], ServingError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -133332,7 +133614,9 @@ async function $do299(client, request, options) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = encodeJSON("body", payload.Scaling, { explode: true });
+  const body = encodeJSON("body", payload.DeploymentScalingUpdate, {
+    explode: true
+  });
   const pathParams = {
     deployment_id: encodeSimple("deployment_id", payload.deployment_id, {
       explode: false,
@@ -133394,7 +133678,7 @@ async function $do299(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, Deployment$inboundSchema), jsonErr([403, 404], ServingError$inboundSchema), jsonErr(422, ServingHTTPValidationError$inboundSchema), fail([401, "4XX"]), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(200, Deployment$inboundSchema), jsonErr([403, 404], ServingError$inboundSchema), jsonErr(422, ServingHTTPValidationError$inboundSchema), jsonErr([500, 503], ServingError$inboundSchema), fail([401, "4XX"]), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -134831,7 +135115,7 @@ async function $do311(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(nil(204, voidType()), jsonErr([403, 404], ServingError$inboundSchema), jsonErr(422, ServingHTTPValidationError$inboundSchema), fail([401, "4XX"]), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(nil(204, voidType()), jsonErr([403, 404, 409], 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 }];
   }
@@ -135419,7 +135703,7 @@ async function $do316(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(nil(204, voidType()), jsonErr([403, 404], ServingError$inboundSchema), jsonErr(422, ServingHTTPValidationError$inboundSchema), fail([401, "4XX"]), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(nil(204, voidType()), jsonErr([403, 404, 409], 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 }];
   }
@@ -135586,11 +135870,371 @@ List your secrets by name (values are never returned).`,
   };
 });
 
-// src/funcs/servingVolumesCreate.ts
-function servingVolumesCreate(client, request, options) {
+// src/funcs/servingTenantsGet.ts
+function servingTenantsGet(client, request, options) {
   return new APIPromise($do318(client, request, options));
 }
 async function $do318(client, request, options) {
+  const parsed = safeParse4(request, (value) => GetServingTenantRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    org_id: encodeSimple("org_id", payload.org_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/api/v1/serving/tenants/{org_id}")(pathParams);
+  const headers = new Headers(compactMap({
+    Accept: "application/json",
+    "X-On-Behalf-Of": encodeSimple("X-On-Behalf-Of", payload["X-On-Behalf-Of"], { explode: false, charEncoding: "none" })
+  }));
+  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: "getServingTenant",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearerAuth,
+    retryConfig: options?.retries || client._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 500,
+        maxInterval: 5000,
+        exponent: 1.5,
+        maxElapsedTime: 15000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    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, ServingTenant$inboundSchema), jsonErr([403, 404], 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_servingTenantsGet = __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/servingTenantsGet.ts
+var args311, tool$servingTenantsGet;
+var init_servingTenantsGet2 = __esm(() => {
+  init_servingTenantsGet();
+  init_operations();
+  init_tools();
+  args311 = {
+    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: args311,
+    tool: async (client, args312, ctx) => {
+      const [result, apiCall] = await servingTenantsGet(client, args312.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/servingTenantsList.ts
+function servingTenantsList(client, request, options) {
+  return new APIPromise($do319(client, request, options));
+}
+async function $do319(client, request, options) {
+  const parsed = safeParse4(request, (value) => ListServingTenantsRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const path = pathToFunc("/api/v1/serving/tenants")();
+  const query = encodeFormQuery({
+    cursor: payload.cursor,
+    limit: payload.limit
+  });
+  const headers = new Headers(compactMap({
+    Accept: "application/json",
+    "X-On-Behalf-Of": encodeSimple("X-On-Behalf-Of", payload["X-On-Behalf-Of"], { explode: false, charEncoding: "none" })
+  }));
+  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: "listServingTenants",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearerAuth,
+    retryConfig: options?.retries || client._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 500,
+        maxInterval: 5000,
+        exponent: 1.5,
+        maxElapsedTime: 15000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    isErrorStatusCode: (statusCode) => matchStatusCode({ status: statusCode }, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, PageServingTenant$inboundSchema), jsonErr(403, 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_servingTenantsList = __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/servingTenantsList.ts
+var args312, tool$servingTenantsList;
+var init_servingTenantsList2 = __esm(() => {
+  init_servingTenantsList();
+  init_operations();
+  init_tools();
+  args312 = {
+    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: args312,
+    tool: async (client, args313, ctx) => {
+      const [result, apiCall] = await servingTenantsList(client, args313.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/servingTenantsSet.ts
+function servingTenantsSet(client, request, options) {
+  return new APIPromise($do320(client, request, options));
+}
+async function $do320(client, request, options) {
+  const parsed = safeParse4(request, (value) => SetServingTenantRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.ServingTenantSet, { explode: true });
+  const pathParams = {
+    org_id: encodeSimple("org_id", payload.org_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/api/v1/serving/tenants/{org_id}")(pathParams);
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    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: "setServingTenant",
+    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, ServingTenant$inboundSchema), jsonErr(403, 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_servingTenantsSet = __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/servingTenantsSet.ts
+var args313, tool$servingTenantsSet;
+var init_servingTenantsSet2 = __esm(() => {
+  init_servingTenantsSet();
+  init_operations();
+  init_tools();
+  args313 = {
+    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: args313,
+    tool: async (client, args314, ctx) => {
+      const [result, apiCall] = await servingTenantsSet(client, args314.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/servingVolumesCreate.ts
+function servingVolumesCreate(client, request, options) {
+  return new APIPromise($do321(client, request, options));
+}
+async function $do321(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateVolumeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135673,12 +136317,12 @@ var init_servingVolumesCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/servingVolumesCreate.ts
-var args311, tool$servingVolumesCreate;
+var args314, tool$servingVolumesCreate;
 var init_servingVolumesCreate2 = __esm(() => {
   init_servingVolumesCreate();
   init_operations();
   init_tools();
-  args311 = {
+  args314 = {
     request: CreateVolumeRequest$inboundSchema
   };
   tool$servingVolumesCreate = {
@@ -135686,9 +136330,9 @@ var init_servingVolumesCreate2 = __esm(() => {
     description: `Create a volume
 
 Create a persistent volume for weights, datasets, or checkpoints.`,
-    args: args311,
-    tool: async (client, args312, ctx) => {
-      const [result, apiCall] = await servingVolumesCreate(client, args312.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args314,
+    tool: async (client, args315, ctx) => {
+      const [result, apiCall] = await servingVolumesCreate(client, args315.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -135703,9 +136347,9 @@ Create a persistent volume for weights, datasets, or checkpoints.`,
 
 // src/funcs/servingVolumesDelete.ts
 function servingVolumesDelete(client, request, options) {
-  return new APIPromise($do319(client, request, options));
+  return new APIPromise($do322(client, request, options));
 }
-async function $do319(client, request, options) {
+async function $do322(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteVolumeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135793,12 +136437,12 @@ var init_servingVolumesDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/servingVolumesDelete.ts
-var args312, tool$servingVolumesDelete;
+var args315, tool$servingVolumesDelete;
 var init_servingVolumesDelete2 = __esm(() => {
   init_servingVolumesDelete();
   init_operations();
   init_tools();
-  args312 = {
+  args315 = {
     request: DeleteVolumeRequest$inboundSchema
   };
   tool$servingVolumesDelete = {
@@ -135806,9 +136450,9 @@ var init_servingVolumesDelete2 = __esm(() => {
     description: `Delete a volume
 
 Delete a volume and its contents.`,
-    args: args312,
-    tool: async (client, args313, ctx) => {
-      const [result, apiCall] = await servingVolumesDelete(client, args313.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args315,
+    tool: async (client, args316, ctx) => {
+      const [result, apiCall] = await servingVolumesDelete(client, args316.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -135822,9 +136466,9 @@ Delete a volume and its contents.`,
 
 // src/funcs/servingVolumesGet.ts
 function servingVolumesGet(client, request, options) {
-  return new APIPromise($do320(client, request, options));
+  return new APIPromise($do323(client, request, options));
 }
-async function $do320(client, request, options) {
+async function $do323(client, request, options) {
   const parsed = safeParse4(request, (value) => GetVolumeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135912,12 +136556,12 @@ var init_servingVolumesGet = __esm(() => {
 });
 
 // src/mcp-server/tools/servingVolumesGet.ts
-var args313, tool$servingVolumesGet;
+var args316, tool$servingVolumesGet;
 var init_servingVolumesGet2 = __esm(() => {
   init_servingVolumesGet();
   init_operations();
   init_tools();
-  args313 = {
+  args316 = {
     request: GetVolumeRequest$inboundSchema
   };
   tool$servingVolumesGet = {
@@ -135925,9 +136569,9 @@ var init_servingVolumesGet2 = __esm(() => {
     description: `Get a volume
 
 Retrieve a volume.`,
-    args: args313,
-    tool: async (client, args314, ctx) => {
-      const [result, apiCall] = await servingVolumesGet(client, args314.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args316,
+    tool: async (client, args317, ctx) => {
+      const [result, apiCall] = await servingVolumesGet(client, args317.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -135942,9 +136586,9 @@ Retrieve a volume.`,
 
 // src/funcs/servingVolumesList.ts
 function servingVolumesList(client, request, options) {
-  return new APIPromise($do321(client, request, options));
+  return new APIPromise($do324(client, request, options));
 }
-async function $do321(client, request, options) {
+async function $do324(client, request, options) {
   const parsed = safeParse4(request, (value) => ListVolumesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -136031,12 +136675,12 @@ var init_servingVolumesList = __esm(() => {
 });
 
 // src/mcp-server/tools/servingVolumesList.ts
-var args314, tool$servingVolumesList;
+var args317, tool$servingVolumesList;
 var init_servingVolumesList2 = __esm(() => {
   init_servingVolumesList();
   init_operations();
   init_tools();
-  args314 = {
+  args317 = {
     request: ListVolumesRequest$inboundSchema
   };
   tool$servingVolumesList = {
@@ -136044,9 +136688,9 @@ var init_servingVolumesList2 = __esm(() => {
     description: `List volumes
 
 List your volumes.`,
-    args: args314,
-    tool: async (client, args315, ctx) => {
-      const [result, apiCall] = await servingVolumesList(client, args315.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args317,
+    tool: async (client, args318, ctx) => {
+      const [result, apiCall] = await servingVolumesList(client, args318.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -136061,9 +136705,9 @@ List your volumes.`,
 
 // src/funcs/usageCosts.ts
 function usageCosts(client, request, options) {
-  return new APIPromise($do322(client, request, options));
+  return new APIPromise($do325(client, request, options));
 }
-async function $do322(client, request, options) {
+async function $do325(client, request, options) {
   const parsed = safeParse4(request, (value) => GetCostsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -136146,12 +136790,12 @@ var init_usageCosts = __esm(() => {
 });
 
 // src/mcp-server/tools/usageCosts.ts
-var args315, tool$usageCosts;
+var args318, tool$usageCosts;
 var init_usageCosts2 = __esm(() => {
   init_usageCosts();
   init_operations();
   init_tools();
-  args315 = {
+  args318 = {
     request: GetCostsRequest$inboundSchema
   };
   tool$usageCosts = {
@@ -136159,9 +136803,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: args315,
-    tool: async (client, args316, ctx) => {
-      const [result, apiCall] = await usageCosts(client, args316.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args318,
+    tool: async (client, args319, ctx) => {
+      const [result, apiCall] = await usageCosts(client, args319.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -136176,9 +136820,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($do323(client, request, options));
+  return new APIPromise($do326(client, request, options));
 }
-async function $do323(client, request, options) {
+async function $do326(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSandboxUsageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -136269,12 +136913,12 @@ var init_usageSandbox = __esm(() => {
 });
 
 // src/mcp-server/tools/usageSandbox.ts
-var args316, tool$usageSandbox;
+var args319, tool$usageSandbox;
 var init_usageSandbox2 = __esm(() => {
   init_usageSandbox();
   init_operations();
   init_tools();
-  args316 = {
+  args319 = {
     request: GetSandboxUsageRequest$inboundSchema
   };
   tool$usageSandbox = {
@@ -136282,9 +136926,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: args316,
-    tool: async (client, args317, ctx) => {
-      const [result, apiCall] = await usageSandbox(client, args317.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args319,
+    tool: async (client, args320, ctx) => {
+      const [result, apiCall] = await usageSandbox(client, args320.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -136301,7 +136945,7 @@ Aggregate sandbox usage (session lifecycle, execution, and workspace operations)
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "SDK",
-    version: "0.51.5"
+    version: "0.51.6"
   });
   const client = new SDKCore({
     bearerAuth: deps.bearerAuth,
@@ -136634,6 +137278,9 @@ function createMCPServer(deps) {
   tool(tool$servingSecretsList);
   tool(tool$servingSecretsCreate);
   tool(tool$servingSecretsDelete);
+  tool(tool$servingTenantsList);
+  tool(tool$servingTenantsGet);
+  tool(tool$servingTenantsSet);
   tool(tool$servingVolumesList);
   tool(tool$servingVolumesCreate);
   tool(tool$servingVolumesDelete);
@@ -136962,6 +137609,9 @@ var init_server2 = __esm(() => {
   init_servingSecretsCreate2();
   init_servingSecretsDelete2();
   init_servingSecretsList2();
+  init_servingTenantsGet2();
+  init_servingTenantsList2();
+  init_servingTenantsSet2();
   init_servingVolumesCreate2();
   init_servingVolumesDelete2();
   init_servingVolumesGet2();
@@ -138145,7 +138795,7 @@ var routes = rn({
 var app = Ve(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.51.5"
+    currentVersion: "0.51.6"
   }
 });
 _t(app, process3.argv.slice(2), buildContext(process3));
@@ -138153,5 +138803,5 @@ export {
   app
 };
 
-//# debugId=0D7CEABD4CBCA55164756E2164756E21
+//# debugId=AE2B5460970AAD1A64756E2164756E21
 //# sourceMappingURL=mcp-server.js.map