@meetkai/mka1 0.49.17 → 0.49.18

package/bin/mcp-server.js

@@ -52876,9 +52876,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.1.0",
-    sdkVersion: "0.49.17",
+    sdkVersion: "0.49.18",
     genVersion: "2.918.4",
-    userAgent: "speakeasy-sdk/typescript 0.49.17 2.918.4 1.1.0 @meetkai/mka1"
+    userAgent: "speakeasy-sdk/typescript 0.49.18 2.918.4 1.1.0 @meetkai/mka1"
   };
 });
 
@@ -54489,14 +54489,14 @@ var AcceleratorSpec$inboundSchema, AcceleratorSpec$outboundSchema;
 var init_acceleratorspec = __esm(() => {
   init_esm();
   AcceleratorSpec$inboundSchema = objectType({
-    type: stringType(),
     count: numberType().int().default(1),
-    fallback: arrayType(stringType()).optional()
+    fallback: arrayType(stringType()).optional(),
+    type: stringType()
   });
   AcceleratorSpec$outboundSchema = objectType({
-    type: stringType(),
     count: numberType().int().default(1),
-    fallback: arrayType(stringType()).optional()
+    fallback: arrayType(stringType()).optional(),
+    type: stringType()
   });
 });
 
@@ -54514,27 +54514,27 @@ var init_acceleratortype = __esm(() => {
   Kind$inboundSchema = nativeEnumType(Kind);
   Kind$outboundSchema = Kind$inboundSchema;
   AcceleratorType$inboundSchema = objectType({
-    name: stringType(),
-    vendor: stringType(),
     kind: Kind$inboundSchema.default("gpu"),
+    max_count: numberType().int(),
     memory_gb: numberType().int(),
-    max_count: numberType().int()
+    name: stringType(),
+    vendor: stringType()
   }).transform((v2) => {
     return remap(v2, {
-      memory_gb: "memoryGb",
-      max_count: "maxCount"
+      max_count: "maxCount",
+      memory_gb: "memoryGb"
     });
   });
   AcceleratorType$outboundSchema = objectType({
-    name: stringType(),
-    vendor: stringType(),
     kind: Kind$outboundSchema.default("gpu"),
+    maxCount: numberType().int(),
     memoryGb: numberType().int(),
-    maxCount: numberType().int()
+    name: stringType(),
+    vendor: stringType()
   }).transform((v2) => {
     return remap(v2, {
-      memoryGb: "memory_gb",
-      maxCount: "max_count"
+      maxCount: "max_count",
+      memoryGb: "memory_gb"
     });
   });
 });
@@ -57316,25 +57316,27 @@ var init_checkpoint = __esm(() => {
   init_esm();
   init_primitives();
   Checkpoint$inboundSchema = objectType({
+    created_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
+    id: stringType(),
     path: stringType(),
-    step: nullableType(numberType().int()).optional(),
     size_bytes: nullableType(numberType().int()).optional(),
-    created_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2))
+    step: nullableType(numberType().int()).optional()
   }).transform((v2) => {
     return remap(v2, {
-      size_bytes: "sizeBytes",
-      created_at: "createdAt"
+      created_at: "createdAt",
+      size_bytes: "sizeBytes"
     });
   });
   Checkpoint$outboundSchema = objectType({
+    createdAt: dateType().transform((v2) => v2.toISOString()),
+    id: stringType(),
     path: stringType(),
-    step: nullableType(numberType().int()).optional(),
     sizeBytes: nullableType(numberType().int()).optional(),
-    createdAt: dateType().transform((v2) => v2.toISOString())
+    step: nullableType(numberType().int()).optional()
   }).transform((v2) => {
     return remap(v2, {
-      sizeBytes: "size_bytes",
-      createdAt: "created_at"
+      createdAt: "created_at",
+      sizeBytes: "size_bytes"
     });
   });
 });
@@ -63334,6 +63336,33 @@ var init_deleteresponseobject = __esm(() => {
   });
 });
 
+// src/models/components/deploymentendpoint.ts
+var DeploymentEndpoint$inboundSchema, DeploymentEndpoint$outboundSchema;
+var init_deploymentendpoint = __esm(() => {
+  init_esm();
+  init_primitives();
+  DeploymentEndpoint$inboundSchema = objectType({
+    base_url: stringType(),
+    openai_compatible: booleanType().default(true),
+    via: literalType("gateway").default("gateway")
+  }).transform((v2) => {
+    return remap(v2, {
+      base_url: "baseUrl",
+      openai_compatible: "openaiCompatible"
+    });
+  });
+  DeploymentEndpoint$outboundSchema = objectType({
+    baseUrl: stringType(),
+    openaiCompatible: booleanType().default(true),
+    via: literalType("gateway").default("gateway")
+  }).transform((v2) => {
+    return remap(v2, {
+      baseUrl: "base_url",
+      openaiCompatible: "openai_compatible"
+    });
+  });
+});
+
 // src/models/components/engine.ts
 var Engine, Engine$inboundSchema, Engine$outboundSchema;
 var init_engine = __esm(() => {
@@ -63352,33 +63381,33 @@ var init_scaling = __esm(() => {
   init_esm();
   init_primitives();
   Scaling$inboundSchema = objectType({
-    min_containers: numberType().int().default(0),
-    max_containers: numberType().int().default(1),
     buffer_containers: numberType().int().default(0),
-    scaledown_window_s: numberType().int().default(300),
-    max_concurrent_inputs: numberType().int().default(100)
+    max_concurrent_inputs: numberType().int().default(100),
+    max_containers: numberType().int().default(1),
+    min_containers: numberType().int().default(0),
+    scaledown_window_s: numberType().int().default(300)
   }).transform((v2) => {
     return remap(v2, {
-      min_containers: "minContainers",
-      max_containers: "maxContainers",
       buffer_containers: "bufferContainers",
-      scaledown_window_s: "scaledownWindowS",
-      max_concurrent_inputs: "maxConcurrentInputs"
+      max_concurrent_inputs: "maxConcurrentInputs",
+      max_containers: "maxContainers",
+      min_containers: "minContainers",
+      scaledown_window_s: "scaledownWindowS"
     });
   });
   Scaling$outboundSchema = objectType({
-    minContainers: numberType().int().default(0),
-    maxContainers: numberType().int().default(1),
     bufferContainers: numberType().int().default(0),
-    scaledownWindowS: numberType().int().default(300),
-    maxConcurrentInputs: numberType().int().default(100)
+    maxConcurrentInputs: numberType().int().default(100),
+    maxContainers: numberType().int().default(1),
+    minContainers: numberType().int().default(0),
+    scaledownWindowS: numberType().int().default(300)
   }).transform((v2) => {
     return remap(v2, {
-      minContainers: "min_containers",
-      maxContainers: "max_containers",
       bufferContainers: "buffer_containers",
-      scaledownWindowS: "scaledown_window_s",
-      maxConcurrentInputs: "max_concurrent_inputs"
+      maxConcurrentInputs: "max_concurrent_inputs",
+      maxContainers: "max_containers",
+      minContainers: "min_containers",
+      scaledownWindowS: "scaledown_window_s"
     });
   });
 });
@@ -63389,53 +63418,61 @@ var init_deployment = __esm(() => {
   init_esm();
   init_primitives();
   init_acceleratorspec();
+  init_deploymentendpoint();
   init_engine();
   init_scaling();
   DeploymentStatus = {
+    Pending: "pending",
     Provisioning: "provisioning",
     Ready: "ready",
     Scaling: "scaling",
     Updating: "updating",
-    Error: "error",
-    Stopped: "stopped"
+    Degraded: "degraded",
+    Failed: "failed",
+    Stopped: "stopped",
+    Deleted: "deleted"
   };
   DeploymentStatus$inboundSchema = nativeEnumType(DeploymentStatus);
   DeploymentStatus$outboundSchema = DeploymentStatus$inboundSchema;
   Deployment$inboundSchema = objectType({
-    id: stringType(),
-    name: stringType(),
-    status: DeploymentStatus$inboundSchema,
-    url: nullableType(stringType()).optional(),
-    model: stringType(),
-    engine: Engine$inboundSchema,
     accelerator: AcceleratorSpec$inboundSchema,
-    scaling: Scaling$inboundSchema,
+    created_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
+    endpoint: nullableType(DeploymentEndpoint$inboundSchema).optional(),
+    engine: Engine$inboundSchema,
+    id: stringType(),
     image: nullableType(stringType()),
+    model: stringType(),
+    name: stringType(),
     revision: numberType().int(),
-    created_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
+    scaling: Scaling$inboundSchema,
+    served_model_id: nullableType(stringType()).optional(),
+    status: DeploymentStatus$inboundSchema,
     updated_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2))
   }).transform((v2) => {
     return remap(v2, {
       created_at: "createdAt",
+      served_model_id: "servedModelId",
       updated_at: "updatedAt"
     });
   });
   Deployment$outboundSchema = objectType({
-    id: stringType(),
-    name: stringType(),
-    status: DeploymentStatus$outboundSchema,
-    url: nullableType(stringType()).optional(),
-    model: stringType(),
-    engine: Engine$outboundSchema,
     accelerator: AcceleratorSpec$outboundSchema,
-    scaling: Scaling$outboundSchema,
+    createdAt: dateType().transform((v2) => v2.toISOString()),
+    endpoint: nullableType(DeploymentEndpoint$outboundSchema).optional(),
+    engine: Engine$outboundSchema,
+    id: stringType(),
     image: nullableType(stringType()),
+    model: stringType(),
+    name: stringType(),
     revision: numberType().int(),
-    createdAt: dateType().transform((v2) => v2.toISOString()),
+    scaling: Scaling$outboundSchema,
+    servedModelId: nullableType(stringType()).optional(),
+    status: DeploymentStatus$outboundSchema,
     updatedAt: dateType().transform((v2) => v2.toISOString())
   }).transform((v2) => {
     return remap(v2, {
       createdAt: "created_at",
+      servedModelId: "served_model_id",
       updatedAt: "updated_at"
     });
   });
@@ -63463,39 +63500,39 @@ var init_deploymentcreate = __esm(() => {
   init_engine();
   init_scaling();
   DeploymentCreate$inboundSchema = objectType({
-    name: stringType(),
-    model: stringType(),
-    engine: Engine$inboundSchema.optional(),
     accelerator: AcceleratorSpec$inboundSchema,
-    scaling: Scaling$inboundSchema.optional(),
+    endpoint_auth: booleanType().default(true),
+    engine: Engine$inboundSchema.optional(),
+    engine_args: arrayType(stringType()).optional(),
     image: nullableType(stringType()).optional(),
-    volume: nullableType(stringType()).optional(),
+    model: stringType(),
+    name: stringType(),
+    scaling: Scaling$inboundSchema.optional(),
     secrets: arrayType(stringType()).optional(),
-    engine_args: arrayType(stringType()).optional(),
-    endpoint_auth: booleanType().default(true),
-    strategy: DeployStrategy$inboundSchema.optional()
+    strategy: DeployStrategy$inboundSchema.optional(),
+    volume: nullableType(stringType()).optional()
   }).transform((v2) => {
     return remap(v2, {
-      engine_args: "engineArgs",
-      endpoint_auth: "endpointAuth"
+      endpoint_auth: "endpointAuth",
+      engine_args: "engineArgs"
     });
   });
   DeploymentCreate$outboundSchema = objectType({
-    name: stringType(),
-    model: stringType(),
-    engine: Engine$outboundSchema.optional(),
     accelerator: AcceleratorSpec$outboundSchema,
-    scaling: Scaling$outboundSchema.optional(),
+    endpointAuth: booleanType().default(true),
+    engine: Engine$outboundSchema.optional(),
+    engineArgs: arrayType(stringType()).optional(),
     image: nullableType(stringType()).optional(),
-    volume: nullableType(stringType()).optional(),
+    model: stringType(),
+    name: stringType(),
+    scaling: Scaling$outboundSchema.optional(),
     secrets: arrayType(stringType()).optional(),
-    engineArgs: arrayType(stringType()).optional(),
-    endpointAuth: booleanType().default(true),
-    strategy: DeployStrategy$outboundSchema.optional()
+    strategy: DeployStrategy$outboundSchema.optional(),
+    volume: nullableType(stringType()).optional()
   }).transform((v2) => {
     return remap(v2, {
-      engineArgs: "engine_args",
-      endpointAuth: "endpoint_auth"
+      endpointAuth: "endpoint_auth",
+      engineArgs: "engine_args"
     });
   });
 });
@@ -63522,10 +63559,10 @@ var init_deploymentupdate = __esm(() => {
   init_primitives();
   init_deploystrategy();
   DeploymentUpdate$inboundSchema = objectType({
-    model: nullableType(stringType()).optional(),
+    engine_args: nullableType(arrayType(stringType())).optional(),
     image: nullableType(stringType()).optional(),
+    model: nullableType(stringType()).optional(),
     secrets: nullableType(arrayType(stringType())).optional(),
-    engine_args: nullableType(arrayType(stringType())).optional(),
     strategy: DeployStrategy$inboundSchema.optional()
   }).transform((v2) => {
     return remap(v2, {
@@ -63533,10 +63570,10 @@ var init_deploymentupdate = __esm(() => {
     });
   });
   DeploymentUpdate$outboundSchema = objectType({
-    model: nullableType(stringType()).optional(),
+    engineArgs: nullableType(arrayType(stringType())).optional(),
     image: nullableType(stringType()).optional(),
+    model: nullableType(stringType()).optional(),
     secrets: nullableType(arrayType(stringType())).optional(),
-    engineArgs: nullableType(arrayType(stringType())).optional(),
     strategy: DeployStrategy$outboundSchema.optional()
   }).transform((v2) => {
     return remap(v2, {
@@ -64854,37 +64891,49 @@ var init_finetunejob = __esm(() => {
   FinetuneJobStatus$inboundSchema = nativeEnumType(FinetuneJobStatus);
   FinetuneJobStatus$outboundSchema = FinetuneJobStatus$inboundSchema;
   FinetuneJob$inboundSchema = objectType({
-    id: stringType(),
-    name: stringType(),
-    status: FinetuneJobStatus$inboundSchema,
     base_model: stringType(),
-    method: stringType(),
-    progress: nullableType(numberType()).optional(),
     checkpoints: arrayType(stringType()).optional(),
     created_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
-    finished_at: nullableType(stringType().datetime({ offset: true }).transform((v2) => new Date(v2))).optional()
+    finished_at: nullableType(stringType().datetime({ offset: true }).transform((v2) => new Date(v2))).optional(),
+    from_checkpoint: nullableType(stringType()).optional(),
+    id: stringType(),
+    method: stringType(),
+    name: stringType(),
+    output_model: nullableType(stringType()).optional(),
+    parent_job_id: nullableType(stringType()).optional(),
+    progress: nullableType(numberType()).optional(),
+    status: FinetuneJobStatus$inboundSchema
   }).transform((v2) => {
     return remap(v2, {
       base_model: "baseModel",
       created_at: "createdAt",
-      finished_at: "finishedAt"
+      finished_at: "finishedAt",
+      from_checkpoint: "fromCheckpoint",
+      output_model: "outputModel",
+      parent_job_id: "parentJobId"
     });
   });
   FinetuneJob$outboundSchema = objectType({
-    id: stringType(),
-    name: stringType(),
-    status: FinetuneJobStatus$outboundSchema,
     baseModel: stringType(),
-    method: stringType(),
-    progress: nullableType(numberType()).optional(),
     checkpoints: arrayType(stringType()).optional(),
     createdAt: dateType().transform((v2) => v2.toISOString()),
-    finishedAt: nullableType(dateType().transform((v2) => v2.toISOString())).optional()
+    finishedAt: nullableType(dateType().transform((v2) => v2.toISOString())).optional(),
+    fromCheckpoint: nullableType(stringType()).optional(),
+    id: stringType(),
+    method: stringType(),
+    name: stringType(),
+    outputModel: nullableType(stringType()).optional(),
+    parentJobId: nullableType(stringType()).optional(),
+    progress: nullableType(numberType()).optional(),
+    status: FinetuneJobStatus$outboundSchema
   }).transform((v2) => {
     return remap(v2, {
       baseModel: "base_model",
       createdAt: "created_at",
-      finishedAt: "finished_at"
+      finishedAt: "finished_at",
+      fromCheckpoint: "from_checkpoint",
+      outputModel: "output_model",
+      parentJobId: "parent_job_id"
     });
   });
 });
@@ -64903,34 +64952,38 @@ var init_finetunejobcreate = __esm(() => {
   FinetuneJobCreateMethod$inboundSchema = nativeEnumType(FinetuneJobCreateMethod);
   FinetuneJobCreateMethod$outboundSchema = FinetuneJobCreateMethod$inboundSchema;
   FinetuneJobCreate$inboundSchema = objectType({
-    name: stringType(),
-    base_model: stringType(),
-    method: FinetuneJobCreateMethod$inboundSchema.default("lora"),
-    dataset: stringType(),
     accelerator: AcceleratorSpec$inboundSchema,
-    output_volume: stringType(),
+    base_model: nullableType(stringType()).optional(),
+    dataset: stringType(),
+    from_checkpoint: nullableType(stringType()).optional(),
+    hyperparameters: recordType(anyType()).optional(),
     image: nullableType(stringType()).optional(),
-    secrets: arrayType(stringType()).optional(),
-    hyperparameters: recordType(anyType()).optional()
+    method: FinetuneJobCreateMethod$inboundSchema.default("lora"),
+    name: stringType(),
+    output_volume: stringType(),
+    secrets: arrayType(stringType()).optional()
   }).transform((v2) => {
     return remap(v2, {
       base_model: "baseModel",
+      from_checkpoint: "fromCheckpoint",
       output_volume: "outputVolume"
     });
   });
   FinetuneJobCreate$outboundSchema = objectType({
-    name: stringType(),
-    baseModel: stringType(),
-    method: FinetuneJobCreateMethod$outboundSchema.default("lora"),
-    dataset: stringType(),
     accelerator: AcceleratorSpec$outboundSchema,
-    outputVolume: stringType(),
+    baseModel: nullableType(stringType()).optional(),
+    dataset: stringType(),
+    fromCheckpoint: nullableType(stringType()).optional(),
+    hyperparameters: recordType(anyType()).optional(),
     image: nullableType(stringType()).optional(),
-    secrets: arrayType(stringType()).optional(),
-    hyperparameters: recordType(anyType()).optional()
+    method: FinetuneJobCreateMethod$outboundSchema.default("lora"),
+    name: stringType(),
+    outputVolume: stringType(),
+    secrets: arrayType(stringType()).optional()
   }).transform((v2) => {
     return remap(v2, {
       baseModel: "base_model",
+      fromCheckpoint: "from_checkpoint",
       outputVolume: "output_volume"
     });
   });
@@ -65723,33 +65776,33 @@ var init_imagespec = __esm(() => {
   init_esm();
   init_primitives();
   ImageSpec$inboundSchema = objectType({
-    base_image: stringType().default("nvidia/cuda:12.9.0-devel-ubuntu22.04"),
-    python_version: stringType().default("3.12"),
     apt_packages: arrayType(stringType()).optional(),
-    pip_packages: arrayType(stringType()).optional(),
+    base_image: stringType().default("nvidia/cuda:12.9.0-devel-ubuntu22.04"),
+    commands: arrayType(stringType()).optional(),
     env: recordType(stringType()).optional(),
-    commands: arrayType(stringType()).optional()
+    pip_packages: arrayType(stringType()).optional(),
+    python_version: stringType().default("3.12")
   }).transform((v2) => {
     return remap(v2, {
-      base_image: "baseImage",
-      python_version: "pythonVersion",
       apt_packages: "aptPackages",
-      pip_packages: "pipPackages"
+      base_image: "baseImage",
+      pip_packages: "pipPackages",
+      python_version: "pythonVersion"
     });
   });
   ImageSpec$outboundSchema = objectType({
-    baseImage: stringType().default("nvidia/cuda:12.9.0-devel-ubuntu22.04"),
-    pythonVersion: stringType().default("3.12"),
     aptPackages: arrayType(stringType()).optional(),
-    pipPackages: arrayType(stringType()).optional(),
+    baseImage: stringType().default("nvidia/cuda:12.9.0-devel-ubuntu22.04"),
+    commands: arrayType(stringType()).optional(),
     env: recordType(stringType()).optional(),
-    commands: arrayType(stringType()).optional()
+    pipPackages: arrayType(stringType()).optional(),
+    pythonVersion: stringType().default("3.12")
   }).transform((v2) => {
     return remap(v2, {
-      baseImage: "base_image",
-      pythonVersion: "python_version",
       aptPackages: "apt_packages",
-      pipPackages: "pip_packages"
+      baseImage: "base_image",
+      pipPackages: "pip_packages",
+      pythonVersion: "python_version"
     });
   });
 });
@@ -65768,22 +65821,22 @@ var init_image = __esm(() => {
   ImageStatus$inboundSchema = nativeEnumType(ImageStatus);
   ImageStatus$outboundSchema = ImageStatus$inboundSchema;
   Image$inboundSchema = objectType({
+    created_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
     id: stringType(),
     name: stringType(),
-    status: ImageStatus$inboundSchema,
     spec: ImageSpec$inboundSchema,
-    created_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2))
+    status: ImageStatus$inboundSchema
   }).transform((v2) => {
     return remap(v2, {
       created_at: "createdAt"
     });
   });
   Image$outboundSchema = objectType({
+    createdAt: dateType().transform((v2) => v2.toISOString()),
     id: stringType(),
     name: stringType(),
-    status: ImageStatus$outboundSchema,
     spec: ImageSpec$outboundSchema,
-    createdAt: dateType().transform((v2) => v2.toISOString())
+    status: ImageStatus$outboundSchema
   }).transform((v2) => {
     return remap(v2, {
       createdAt: "created_at"
@@ -66235,14 +66288,14 @@ var JobEvent$inboundSchema, JobEvent$outboundSchema;
 var init_jobevent = __esm(() => {
   init_esm();
   JobEvent$inboundSchema = objectType({
+    message: stringType(),
     timestamp: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
-    type: stringType(),
-    message: stringType()
+    type: stringType()
   });
   JobEvent$outboundSchema = objectType({
+    message: stringType(),
     timestamp: dateType().transform((v2) => v2.toISOString()),
-    type: stringType(),
-    message: stringType()
+    type: stringType()
   });
 });
 
@@ -67630,14 +67683,14 @@ var LogLine$inboundSchema, LogLine$outboundSchema;
 var init_logline = __esm(() => {
   init_esm();
   LogLine$inboundSchema = objectType({
-    timestamp: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
+    message: stringType(),
     source: nullableType(stringType()).optional(),
-    message: stringType()
+    timestamp: stringType().datetime({ offset: true }).transform((v2) => new Date(v2))
   });
   LogLine$outboundSchema = objectType({
-    timestamp: dateType().transform((v2) => v2.toISOString()),
+    message: stringType(),
     source: nullableType(stringType()).optional(),
-    message: stringType()
+    timestamp: dateType().transform((v2) => v2.toISOString())
   });
 });
 
@@ -68254,30 +68307,30 @@ var init_metrics = __esm(() => {
   init_esm();
   init_primitives();
   Metrics$inboundSchema = objectType({
-    replicas: numberType().int(),
-    queue_backlog: numberType().int(),
-    accelerator_utilization: numberType(),
     accelerator_memory_used_mb: numberType().int(),
+    accelerator_utilization: numberType(),
+    queue_backlog: numberType().int(),
+    replicas: numberType().int(),
     requests_per_second: numberType()
   }).transform((v2) => {
     return remap(v2, {
-      queue_backlog: "queueBacklog",
-      accelerator_utilization: "acceleratorUtilization",
       accelerator_memory_used_mb: "acceleratorMemoryUsedMb",
+      accelerator_utilization: "acceleratorUtilization",
+      queue_backlog: "queueBacklog",
       requests_per_second: "requestsPerSecond"
     });
   });
   Metrics$outboundSchema = objectType({
-    replicas: numberType().int(),
-    queueBacklog: numberType().int(),
-    acceleratorUtilization: numberType(),
     acceleratorMemoryUsedMb: numberType().int(),
+    acceleratorUtilization: numberType(),
+    queueBacklog: numberType().int(),
+    replicas: numberType().int(),
     requestsPerSecond: numberType()
   }).transform((v2) => {
     return remap(v2, {
-      queueBacklog: "queue_backlog",
-      acceleratorUtilization: "accelerator_utilization",
       acceleratorMemoryUsedMb: "accelerator_memory_used_mb",
+      acceleratorUtilization: "accelerator_utilization",
+      queueBacklog: "queue_backlog",
       requestsPerSecond: "requests_per_second"
     });
   });
@@ -68289,22 +68342,22 @@ var init_model = __esm(() => {
   init_esm();
   init_primitives();
   Model$inboundSchema = objectType({
+    created_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
     id: stringType(),
     name: stringType(),
-    source: stringType(),
     revision: nullableType(stringType()).optional(),
-    created_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2))
+    source: stringType()
   }).transform((v2) => {
     return remap(v2, {
       created_at: "createdAt"
     });
   });
   Model$outboundSchema = objectType({
+    createdAt: dateType().transform((v2) => v2.toISOString()),
     id: stringType(),
     name: stringType(),
-    source: stringType(),
     revision: nullableType(stringType()).optional(),
-    createdAt: dateType().transform((v2) => v2.toISOString())
+    source: stringType()
   }).transform((v2) => {
     return remap(v2, {
       createdAt: "created_at"
@@ -68318,13 +68371,13 @@ var init_modelregister = __esm(() => {
   init_esm();
   ModelRegister$inboundSchema = objectType({
     name: stringType(),
-    source: stringType(),
-    revision: nullableType(stringType()).optional()
+    revision: nullableType(stringType()).optional(),
+    source: stringType()
   });
   ModelRegister$outboundSchema = objectType({
     name: stringType(),
-    source: stringType(),
-    revision: nullableType(stringType()).optional()
+    revision: nullableType(stringType()).optional(),
+    source: stringType()
   });
 });
 
@@ -69581,8 +69634,8 @@ var init_pageacceleratortype = __esm(() => {
   init_acceleratortype();
   PageAcceleratorType$inboundSchema = objectType({
     data: arrayType(AcceleratorType$inboundSchema),
-    total: numberType().int(),
-    next_cursor: nullableType(stringType()).optional()
+    next_cursor: nullableType(stringType()).optional(),
+    total: numberType().int()
   }).transform((v2) => {
     return remap(v2, {
       next_cursor: "nextCursor"
@@ -69590,8 +69643,8 @@ var init_pageacceleratortype = __esm(() => {
   });
   PageAcceleratorType$outboundSchema = objectType({
     data: arrayType(AcceleratorType$outboundSchema),
-    total: numberType().int(),
-    nextCursor: nullableType(stringType()).optional()
+    nextCursor: nullableType(stringType()).optional(),
+    total: numberType().int()
   }).transform((v2) => {
     return remap(v2, {
       nextCursor: "next_cursor"
@@ -69607,8 +69660,8 @@ var init_pagedeployment = __esm(() => {
   init_deployment();
   PageDeployment$inboundSchema = objectType({
     data: arrayType(Deployment$inboundSchema),
-    total: numberType().int(),
-    next_cursor: nullableType(stringType()).optional()
+    next_cursor: nullableType(stringType()).optional(),
+    total: numberType().int()
   }).transform((v2) => {
     return remap(v2, {
       next_cursor: "nextCursor"
@@ -69616,8 +69669,8 @@ var init_pagedeployment = __esm(() => {
   });
   PageDeployment$outboundSchema = objectType({
     data: arrayType(Deployment$outboundSchema),
-    total: numberType().int(),
-    nextCursor: nullableType(stringType()).optional()
+    nextCursor: nullableType(stringType()).optional(),
+    total: numberType().int()
   }).transform((v2) => {
     return remap(v2, {
       nextCursor: "next_cursor"
@@ -69633,8 +69686,8 @@ var init_pagefinetunejob = __esm(() => {
   init_finetunejob();
   PageFinetuneJob$inboundSchema = objectType({
     data: arrayType(FinetuneJob$inboundSchema),
-    total: numberType().int(),
-    next_cursor: nullableType(stringType()).optional()
+    next_cursor: nullableType(stringType()).optional(),
+    total: numberType().int()
   }).transform((v2) => {
     return remap(v2, {
       next_cursor: "nextCursor"
@@ -69642,8 +69695,8 @@ var init_pagefinetunejob = __esm(() => {
   });
   PageFinetuneJob$outboundSchema = objectType({
     data: arrayType(FinetuneJob$outboundSchema),
-    total: numberType().int(),
-    nextCursor: nullableType(stringType()).optional()
+    nextCursor: nullableType(stringType()).optional(),
+    total: numberType().int()
   }).transform((v2) => {
     return remap(v2, {
       nextCursor: "next_cursor"
@@ -69659,8 +69712,8 @@ var init_pageimage = __esm(() => {
   init_image();
   PageImage$inboundSchema = objectType({
     data: arrayType(Image$inboundSchema),
-    total: numberType().int(),
-    next_cursor: nullableType(stringType()).optional()
+    next_cursor: nullableType(stringType()).optional(),
+    total: numberType().int()
   }).transform((v2) => {
     return remap(v2, {
       next_cursor: "nextCursor"
@@ -69668,8 +69721,8 @@ var init_pageimage = __esm(() => {
   });
   PageImage$outboundSchema = objectType({
     data: arrayType(Image$outboundSchema),
-    total: numberType().int(),
-    nextCursor: nullableType(stringType()).optional()
+    nextCursor: nullableType(stringType()).optional(),
+    total: numberType().int()
   }).transform((v2) => {
     return remap(v2, {
       nextCursor: "next_cursor"
@@ -69685,8 +69738,8 @@ var init_pagemodel = __esm(() => {
   init_model();
   PageModel$inboundSchema = objectType({
     data: arrayType(Model$inboundSchema),
-    total: numberType().int(),
-    next_cursor: nullableType(stringType()).optional()
+    next_cursor: nullableType(stringType()).optional(),
+    total: numberType().int()
   }).transform((v2) => {
     return remap(v2, {
       next_cursor: "nextCursor"
@@ -69694,8 +69747,8 @@ var init_pagemodel = __esm(() => {
   });
   PageModel$outboundSchema = objectType({
     data: arrayType(Model$outboundSchema),
-    total: numberType().int(),
-    nextCursor: nullableType(stringType()).optional()
+    nextCursor: nullableType(stringType()).optional(),
+    total: numberType().int()
   }).transform((v2) => {
     return remap(v2, {
       nextCursor: "next_cursor"
@@ -69710,22 +69763,22 @@ var init_replica = __esm(() => {
   init_primitives();
   init_acceleratorspec();
   Replica$inboundSchema = objectType({
-    id: stringType(),
-    status: stringType(),
     accelerator: AcceleratorSpec$inboundSchema,
+    id: stringType(),
     node: nullableType(stringType()).optional(),
-    started_at: nullableType(stringType().datetime({ offset: true }).transform((v2) => new Date(v2))).optional()
+    started_at: nullableType(stringType().datetime({ offset: true }).transform((v2) => new Date(v2))).optional(),
+    status: stringType()
   }).transform((v2) => {
     return remap(v2, {
       started_at: "startedAt"
     });
   });
   Replica$outboundSchema = objectType({
-    id: stringType(),
-    status: stringType(),
     accelerator: AcceleratorSpec$outboundSchema,
+    id: stringType(),
     node: nullableType(stringType()).optional(),
-    startedAt: nullableType(dateType().transform((v2) => v2.toISOString())).optional()
+    startedAt: nullableType(dateType().transform((v2) => v2.toISOString())).optional(),
+    status: stringType()
   }).transform((v2) => {
     return remap(v2, {
       startedAt: "started_at"
@@ -69741,8 +69794,8 @@ var init_pagereplica = __esm(() => {
   init_replica();
   PageReplica$inboundSchema = objectType({
     data: arrayType(Replica$inboundSchema),
-    total: numberType().int(),
-    next_cursor: nullableType(stringType()).optional()
+    next_cursor: nullableType(stringType()).optional(),
+    total: numberType().int()
   }).transform((v2) => {
     return remap(v2, {
       next_cursor: "nextCursor"
@@ -69750,8 +69803,8 @@ var init_pagereplica = __esm(() => {
   });
   PageReplica$outboundSchema = objectType({
     data: arrayType(Replica$outboundSchema),
-    total: numberType().int(),
-    nextCursor: nullableType(stringType()).optional()
+    nextCursor: nullableType(stringType()).optional(),
+    total: numberType().int()
   }).transform((v2) => {
     return remap(v2, {
       nextCursor: "next_cursor"
@@ -69772,22 +69825,22 @@ var init_revision = __esm(() => {
   RevisionStatus$inboundSchema = nativeEnumType(RevisionStatus);
   RevisionStatus$outboundSchema = RevisionStatus$inboundSchema;
   Revision$inboundSchema = objectType({
-    revision: numberType().int(),
-    status: RevisionStatus$inboundSchema,
-    model: stringType(),
+    created_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
     image: nullableType(stringType()),
-    created_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2))
+    model: stringType(),
+    revision: numberType().int(),
+    status: RevisionStatus$inboundSchema
   }).transform((v2) => {
     return remap(v2, {
       created_at: "createdAt"
     });
   });
   Revision$outboundSchema = objectType({
-    revision: numberType().int(),
-    status: RevisionStatus$outboundSchema,
-    model: stringType(),
+    createdAt: dateType().transform((v2) => v2.toISOString()),
     image: nullableType(stringType()),
-    createdAt: dateType().transform((v2) => v2.toISOString())
+    model: stringType(),
+    revision: numberType().int(),
+    status: RevisionStatus$outboundSchema
   }).transform((v2) => {
     return remap(v2, {
       createdAt: "created_at"
@@ -69803,8 +69856,8 @@ var init_pagerevision = __esm(() => {
   init_revision();
   PageRevision$inboundSchema = objectType({
     data: arrayType(Revision$inboundSchema),
-    total: numberType().int(),
-    next_cursor: nullableType(stringType()).optional()
+    next_cursor: nullableType(stringType()).optional(),
+    total: numberType().int()
   }).transform((v2) => {
     return remap(v2, {
       next_cursor: "nextCursor"
@@ -69812,8 +69865,8 @@ var init_pagerevision = __esm(() => {
   });
   PageRevision$outboundSchema = objectType({
     data: arrayType(Revision$outboundSchema),
-    total: numberType().int(),
-    nextCursor: nullableType(stringType()).optional()
+    nextCursor: nullableType(stringType()).optional(),
+    total: numberType().int()
   }).transform((v2) => {
     return remap(v2, {
       nextCursor: "next_cursor"
@@ -69827,20 +69880,20 @@ var init_secret = __esm(() => {
   init_esm();
   init_primitives();
   Secret$inboundSchema = objectType({
+    created_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
     id: stringType(),
-    name: stringType(),
     keys: arrayType(stringType()),
-    created_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2))
+    name: stringType()
   }).transform((v2) => {
     return remap(v2, {
       created_at: "createdAt"
     });
   });
   Secret$outboundSchema = objectType({
+    createdAt: dateType().transform((v2) => v2.toISOString()),
     id: stringType(),
-    name: stringType(),
     keys: arrayType(stringType()),
-    createdAt: dateType().transform((v2) => v2.toISOString())
+    name: stringType()
   }).transform((v2) => {
     return remap(v2, {
       createdAt: "created_at"
@@ -69856,8 +69909,8 @@ var init_pagesecret = __esm(() => {
   init_secret();
   PageSecret$inboundSchema = objectType({
     data: arrayType(Secret$inboundSchema),
-    total: numberType().int(),
-    next_cursor: nullableType(stringType()).optional()
+    next_cursor: nullableType(stringType()).optional(),
+    total: numberType().int()
   }).transform((v2) => {
     return remap(v2, {
       next_cursor: "nextCursor"
@@ -69865,8 +69918,8 @@ var init_pagesecret = __esm(() => {
   });
   PageSecret$outboundSchema = objectType({
     data: arrayType(Secret$outboundSchema),
-    total: numberType().int(),
-    nextCursor: nullableType(stringType()).optional()
+    nextCursor: nullableType(stringType()).optional(),
+    total: numberType().int()
   }).transform((v2) => {
     return remap(v2, {
       nextCursor: "next_cursor"
@@ -69880,25 +69933,25 @@ var init_volume = __esm(() => {
   init_esm();
   init_primitives();
   Volume$inboundSchema = objectType({
+    created_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
     id: stringType(),
     name: stringType(),
-    size_gb: nullableType(numberType().int()).optional(),
-    created_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2))
+    size_gb: nullableType(numberType().int()).optional()
   }).transform((v2) => {
     return remap(v2, {
-      size_gb: "sizeGb",
-      created_at: "createdAt"
+      created_at: "createdAt",
+      size_gb: "sizeGb"
     });
   });
   Volume$outboundSchema = objectType({
+    createdAt: dateType().transform((v2) => v2.toISOString()),
     id: stringType(),
     name: stringType(),
-    sizeGb: nullableType(numberType().int()).optional(),
-    createdAt: dateType().transform((v2) => v2.toISOString())
+    sizeGb: nullableType(numberType().int()).optional()
   }).transform((v2) => {
     return remap(v2, {
-      sizeGb: "size_gb",
-      createdAt: "created_at"
+      createdAt: "created_at",
+      sizeGb: "size_gb"
     });
   });
 });
@@ -69911,8 +69964,8 @@ var init_pagevolume = __esm(() => {
   init_volume();
   PageVolume$inboundSchema = objectType({
     data: arrayType(Volume$inboundSchema),
-    total: numberType().int(),
-    next_cursor: nullableType(stringType()).optional()
+    next_cursor: nullableType(stringType()).optional(),
+    total: numberType().int()
   }).transform((v2) => {
     return remap(v2, {
       next_cursor: "nextCursor"
@@ -69920,8 +69973,8 @@ var init_pagevolume = __esm(() => {
   });
   PageVolume$outboundSchema = objectType({
     data: arrayType(Volume$outboundSchema),
-    total: numberType().int(),
-    nextCursor: nullableType(stringType()).optional()
+    nextCursor: nullableType(stringType()).optional(),
+    total: numberType().int()
   }).transform((v2) => {
     return remap(v2, {
       nextCursor: "next_cursor"
@@ -73930,12 +73983,12 @@ var SecretCreate$inboundSchema, SecretCreate$outboundSchema;
 var init_secretcreate = __esm(() => {
   init_esm();
   SecretCreate$inboundSchema = objectType({
-    name: stringType(),
-    data: recordType(stringType())
+    data: recordType(stringType()),
+    name: stringType()
   });
   SecretCreate$outboundSchema = objectType({
-    name: stringType(),
-    data: recordType(stringType())
+    data: recordType(stringType()),
+    name: stringType()
   });
 });
 
@@ -73952,26 +74005,26 @@ var init_security2 = __esm(() => {
 });
 
 // src/models/components/servingvalidationerror.ts
-var ServingValidationErrorLoc$inboundSchema, ServingValidationErrorLoc$outboundSchema, Context$inboundSchema, Context$outboundSchema, ServingValidationError$inboundSchema, ServingValidationError$outboundSchema;
+var Context$inboundSchema, Context$outboundSchema, ServingValidationErrorLoc$inboundSchema, ServingValidationErrorLoc$outboundSchema, ServingValidationError$inboundSchema, ServingValidationError$outboundSchema;
 var init_servingvalidationerror = __esm(() => {
   init_esm();
-  ServingValidationErrorLoc$inboundSchema = unionType([stringType(), numberType().int()]);
-  ServingValidationErrorLoc$outboundSchema = unionType([stringType(), numberType().int()]);
   Context$inboundSchema = objectType({});
   Context$outboundSchema = objectType({});
+  ServingValidationErrorLoc$inboundSchema = unionType([stringType(), numberType().int()]);
+  ServingValidationErrorLoc$outboundSchema = unionType([stringType(), numberType().int()]);
   ServingValidationError$inboundSchema = objectType({
+    ctx: lazyType(() => Context$inboundSchema).optional(),
+    input: anyType().optional(),
     loc: arrayType(unionType([stringType(), numberType().int()])),
     msg: stringType(),
-    type: stringType(),
-    input: anyType().optional(),
-    ctx: lazyType(() => Context$inboundSchema).optional()
+    type: stringType()
   });
   ServingValidationError$outboundSchema = objectType({
+    ctx: lazyType(() => Context$outboundSchema).optional(),
+    input: anyType().optional(),
     loc: arrayType(unionType([stringType(), numberType().int()])),
     msg: stringType(),
-    type: stringType(),
-    input: anyType().optional(),
-    ctx: lazyType(() => Context$outboundSchema).optional()
+    type: stringType()
   });
 });
 
@@ -76488,6 +76541,7 @@ var init_components = __esm(() => {
   init_deleteresponseobject();
   init_deployment();
   init_deploymentcreate();
+  init_deploymentendpoint();
   init_deploymentrollbackrequest();
   init_deploymentupdate();
   init_deploystrategy();
@@ -87149,6 +87203,31 @@ var init_deletevolume = __esm(() => {
   });
 });
 
+// src/models/operations/deregisterdeployment.ts
+var DeregisterDeploymentRequest$inboundSchema, DeregisterDeploymentRequest$outboundSchema;
+var init_deregisterdeployment = __esm(() => {
+  init_esm();
+  init_primitives();
+  DeregisterDeploymentRequest$inboundSchema = objectType({
+    deployment_id: stringType(),
+    "X-On-Behalf-Of": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      deployment_id: "deploymentId",
+      "X-On-Behalf-Of": "xOnBehalfOf"
+    });
+  });
+  DeregisterDeploymentRequest$outboundSchema = objectType({
+    deploymentId: stringType(),
+    xOnBehalfOf: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      deploymentId: "deployment_id",
+      xOnBehalfOf: "X-On-Behalf-Of"
+    });
+  });
+});
+
 // src/models/operations/downloadworkspacearchive.ts
 var DownloadWorkspaceArchiveRequest$inboundSchema, DownloadWorkspaceArchiveRequest$outboundSchema;
 var init_downloadworkspacearchive = __esm(() => {
@@ -89514,19 +89593,23 @@ var init_getfinetuneevents = __esm(() => {
   init_primitives();
   GetFinetuneEventsRequest$inboundSchema = objectType({
     job_id: stringType(),
+    include_lineage: booleanType().default(false),
     "X-On-Behalf-Of": stringType().optional()
   }).transform((v2) => {
     return remap(v2, {
       job_id: "jobId",
+      include_lineage: "includeLineage",
       "X-On-Behalf-Of": "xOnBehalfOf"
     });
   });
   GetFinetuneEventsRequest$outboundSchema = objectType({
     jobId: stringType(),
+    includeLineage: booleanType().default(false),
     xOnBehalfOf: stringType().optional()
   }).transform((v2) => {
     return remap(v2, {
       jobId: "job_id",
+      includeLineage: "include_lineage",
       xOnBehalfOf: "X-On-Behalf-Of"
     });
   });
@@ -94419,6 +94502,31 @@ var init_regenerateserviceaccountapikey2 = __esm(() => {
   });
 });
 
+// src/models/operations/registerdeployment.ts
+var RegisterDeploymentRequest$inboundSchema, RegisterDeploymentRequest$outboundSchema;
+var init_registerdeployment = __esm(() => {
+  init_esm();
+  init_primitives();
+  RegisterDeploymentRequest$inboundSchema = objectType({
+    deployment_id: stringType(),
+    "X-On-Behalf-Of": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      deployment_id: "deploymentId",
+      "X-On-Behalf-Of": "xOnBehalfOf"
+    });
+  });
+  RegisterDeploymentRequest$outboundSchema = objectType({
+    deploymentId: stringType(),
+    xOnBehalfOf: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      deploymentId: "deployment_id",
+      xOnBehalfOf: "X-On-Behalf-Of"
+    });
+  });
+});
+
 // src/models/operations/registermodel.ts
 var RegisterModelRequest$inboundSchema, RegisterModelRequest$outboundSchema;
 var init_registermodel = __esm(() => {
@@ -97833,6 +97941,7 @@ var init_operations = __esm(() => {
   init_deletevectorstore();
   init_deletevectorstorefile();
   init_deletevolume();
+  init_deregisterdeployment();
   init_downloadworkspacearchive();
   init_downloadworkspacefile();
   init_embed();
@@ -97985,6 +98094,7 @@ var init_operations = __esm(() => {
   init_putorgautomodel();
   init_regeneratescopedapikey2();
   init_regenerateserviceaccountapikey2();
+  init_registerdeployment();
   init_registermodel();
   init_reissueownerkey2();
   init_removeteammember2();
@@ -131830,13 +131940,134 @@ 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(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_servingDeploymentsCreate = __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/servingDeploymentsCreate.ts
+var args280, tool$servingDeploymentsCreate;
+var init_servingDeploymentsCreate2 = __esm(() => {
+  init_servingDeploymentsCreate();
+  init_operations();
+  init_tools();
+  args280 = {
+    request: CreateDeploymentRequest$inboundSchema
+  };
+  tool$servingDeploymentsCreate = {
+    name: "serving-deployments-create",
+    description: `Create an inference deployment
+
+Create and start an inference deployment for a model, and return its endpoint.`,
+    args: args280,
+    tool: async (client, args281, ctx) => {
+      const [result, apiCall] = await servingDeploymentsCreate(client, args281.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/servingDeploymentsDelete.ts
+function servingDeploymentsDelete(client, request, options) {
+  return new APIPromise($do288(client, request, options));
+}
+async function $do288(client, request, options) {
+  const parsed = safeParse4(request, (value) => DeleteDeploymentRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    deployment_id: encodeSimple("deployment_id", payload.deployment_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/api/v1/serving/deployments/{deployment_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: "deleteDeployment",
+    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: "DELETE",
+    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(nil(204, voidType()), 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_servingDeploymentsCreate = __esm(() => {
+var init_servingDeploymentsDelete = __esm(() => {
+  init_esm();
   init_encodings();
   init_http();
   init_matchers();
@@ -131844,47 +132075,45 @@ var init_servingDeploymentsCreate = __esm(() => {
   init_schemas4();
   init_security();
   init_url();
-  init_components();
   init_errors4();
   init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/servingDeploymentsCreate.ts
-var args280, tool$servingDeploymentsCreate;
-var init_servingDeploymentsCreate2 = __esm(() => {
-  init_servingDeploymentsCreate();
+// src/mcp-server/tools/servingDeploymentsDelete.ts
+var args281, tool$servingDeploymentsDelete;
+var init_servingDeploymentsDelete2 = __esm(() => {
+  init_servingDeploymentsDelete();
   init_operations();
   init_tools();
-  args280 = {
-    request: CreateDeploymentRequest$inboundSchema
+  args281 = {
+    request: DeleteDeploymentRequest$inboundSchema
   };
-  tool$servingDeploymentsCreate = {
-    name: "serving-deployments-create",
-    description: `Create an inference deployment
+  tool$servingDeploymentsDelete = {
+    name: "serving-deployments-delete",
+    description: `Tear down a deployment
 
-Create and start an inference deployment for a model, and return its endpoint.`,
-    args: args280,
-    tool: async (client, args281, ctx) => {
-      const [result, apiCall] = await servingDeploymentsCreate(client, args281.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+Tear down a deployment and release its resources.`,
+    args: args281,
+    tool: async (client, args282, ctx) => {
+      const [result, apiCall] = await servingDeploymentsDelete(client, args282.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);
+      return formatResult(undefined, apiCall);
     }
   };
 });
 
-// src/funcs/servingDeploymentsDelete.ts
-function servingDeploymentsDelete(client, request, options) {
-  return new APIPromise($do288(client, request, options));
+// src/funcs/servingDeploymentsDeregister.ts
+function servingDeploymentsDeregister(client, request, options) {
+  return new APIPromise($do289(client, request, options));
 }
-async function $do288(client, request, options) {
-  const parsed = safeParse4(request, (value) => DeleteDeploymentRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do289(client, request, options) {
+  const parsed = safeParse4(request, (value) => DeregisterDeploymentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
@@ -131896,7 +132125,7 @@ async function $do288(client, request, options) {
       charEncoding: "percent"
     })
   };
-  const path = pathToFunc("/api/v1/serving/deployments/{deployment_id}")(pathParams);
+  const path = pathToFunc("/api/v1/serving/deployments/{deployment_id}/registration")(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" })
@@ -131907,7 +132136,7 @@ async function $do288(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "deleteDeployment",
+    operationID: "deregisterDeployment",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -131956,7 +132185,7 @@ async function $do288(client, request, options) {
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_servingDeploymentsDelete = __esm(() => {
+var init_servingDeploymentsDeregister = __esm(() => {
   init_esm();
   init_encodings();
   init_http();
@@ -131970,23 +132199,23 @@ var init_servingDeploymentsDelete = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/servingDeploymentsDelete.ts
-var args281, tool$servingDeploymentsDelete;
-var init_servingDeploymentsDelete2 = __esm(() => {
-  init_servingDeploymentsDelete();
+// src/mcp-server/tools/servingDeploymentsDeregister.ts
+var args282, tool$servingDeploymentsDeregister;
+var init_servingDeploymentsDeregister2 = __esm(() => {
+  init_servingDeploymentsDeregister();
   init_operations();
   init_tools();
-  args281 = {
-    request: DeleteDeploymentRequest$inboundSchema
+  args282 = {
+    request: DeregisterDeploymentRequest$inboundSchema
   };
-  tool$servingDeploymentsDelete = {
-    name: "serving-deployments-delete",
-    description: `Tear down a deployment
+  tool$servingDeploymentsDeregister = {
+    name: "serving-deployments-deregister",
+    description: `Deregister the model from the LLM gateway
 
-Tear down a deployment and release its resources.`,
-    args: args281,
-    tool: async (client, args282, ctx) => {
-      const [result, apiCall] = await servingDeploymentsDelete(client, args282.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+Withdraw the deployment's model from the LLM gateway registry: inference stops resolving, compute keeps running (re-register any time).`,
+    args: args282,
+    tool: async (client, args283, ctx) => {
+      const [result, apiCall] = await servingDeploymentsDeregister(client, args283.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -132000,9 +132229,9 @@ Tear down a deployment and release its resources.`,
 
 // src/funcs/servingDeploymentsGet.ts
 function servingDeploymentsGet(client, request, options) {
-  return new APIPromise($do289(client, request, options));
+  return new APIPromise($do290(client, request, options));
 }
-async function $do289(client, request, options) {
+async function $do290(client, request, options) {
   const parsed = safeParse4(request, (value) => GetDeploymentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -132090,12 +132319,12 @@ var init_servingDeploymentsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/servingDeploymentsGet.ts
-var args282, tool$servingDeploymentsGet;
+var args283, tool$servingDeploymentsGet;
 var init_servingDeploymentsGet2 = __esm(() => {
   init_servingDeploymentsGet();
   init_operations();
   init_tools();
-  args282 = {
+  args283 = {
     request: GetDeploymentRequest$inboundSchema
   };
   tool$servingDeploymentsGet = {
@@ -132103,9 +132332,9 @@ var init_servingDeploymentsGet2 = __esm(() => {
     description: `Get a deployment
 
 Retrieve a single deployment, including its status and endpoint URL.`,
-    args: args282,
-    tool: async (client, args283, ctx) => {
-      const [result, apiCall] = await servingDeploymentsGet(client, args283.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args283,
+    tool: async (client, args284, ctx) => {
+      const [result, apiCall] = await servingDeploymentsGet(client, args284.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -132120,9 +132349,9 @@ Retrieve a single deployment, including its status and endpoint URL.`,
 
 // src/funcs/servingDeploymentsGetLogs.ts
 function servingDeploymentsGetLogs(client, request, options) {
-  return new APIPromise($do290(client, request, options));
+  return new APIPromise($do291(client, request, options));
 }
-async function $do290(client, request, options) {
+async function $do291(client, request, options) {
   const parsed = safeParse4(request, (value) => GetDeploymentLogsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -132215,12 +132444,12 @@ var init_servingDeploymentsGetLogs = __esm(() => {
 });
 
 // src/mcp-server/tools/servingDeploymentsGetLogs.ts
-var args283, tool$servingDeploymentsGetLogs;
+var args284, tool$servingDeploymentsGetLogs;
 var init_servingDeploymentsGetLogs2 = __esm(() => {
   init_servingDeploymentsGetLogs();
   init_operations();
   init_tools();
-  args283 = {
+  args284 = {
     request: GetDeploymentLogsRequest$inboundSchema
   };
   tool$servingDeploymentsGetLogs = {
@@ -132228,9 +132457,9 @@ var init_servingDeploymentsGetLogs2 = __esm(() => {
     description: `Fetch deployment logs
 
 Fetch recent log lines from a deployment's replicas.`,
-    args: args283,
-    tool: async (client, args284, ctx) => {
-      const [result, apiCall] = await servingDeploymentsGetLogs(client, args284.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args284,
+    tool: async (client, args285, ctx) => {
+      const [result, apiCall] = await servingDeploymentsGetLogs(client, args285.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -132245,9 +132474,9 @@ Fetch recent log lines from a deployment's replicas.`,
 
 // src/funcs/servingDeploymentsGetMetrics.ts
 function servingDeploymentsGetMetrics(client, request, options) {
-  return new APIPromise($do291(client, request, options));
+  return new APIPromise($do292(client, request, options));
 }
-async function $do291(client, request, options) {
+async function $do292(client, request, options) {
   const parsed = safeParse4(request, (value) => GetDeploymentMetricsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -132335,12 +132564,12 @@ var init_servingDeploymentsGetMetrics = __esm(() => {
 });
 
 // src/mcp-server/tools/servingDeploymentsGetMetrics.ts
-var args284, tool$servingDeploymentsGetMetrics;
+var args285, tool$servingDeploymentsGetMetrics;
 var init_servingDeploymentsGetMetrics2 = __esm(() => {
   init_servingDeploymentsGetMetrics();
   init_operations();
   init_tools();
-  args284 = {
+  args285 = {
     request: GetDeploymentMetricsRequest$inboundSchema
   };
   tool$servingDeploymentsGetMetrics = {
@@ -132348,9 +132577,9 @@ var init_servingDeploymentsGetMetrics2 = __esm(() => {
     description: `Live serving metrics
 
 Return live serving metrics (throughput, queue depth, accelerator usage).`,
-    args: args284,
-    tool: async (client, args285, ctx) => {
-      const [result, apiCall] = await servingDeploymentsGetMetrics(client, args285.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args285,
+    tool: async (client, args286, ctx) => {
+      const [result, apiCall] = await servingDeploymentsGetMetrics(client, args286.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -132365,9 +132594,9 @@ Return live serving metrics (throughput, queue depth, accelerator usage).`,
 
 // src/funcs/servingDeploymentsList.ts
 function servingDeploymentsList(client, request, options) {
-  return new APIPromise($do292(client, request, options));
+  return new APIPromise($do293(client, request, options));
 }
-async function $do292(client, request, options) {
+async function $do293(client, request, options) {
   const parsed = safeParse4(request, (value) => ListDeploymentsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -132454,12 +132683,12 @@ var init_servingDeploymentsList = __esm(() => {
 });
 
 // src/mcp-server/tools/servingDeploymentsList.ts
-var args285, tool$servingDeploymentsList;
+var args286, tool$servingDeploymentsList;
 var init_servingDeploymentsList2 = __esm(() => {
   init_servingDeploymentsList();
   init_operations();
   init_tools();
-  args285 = {
+  args286 = {
     request: ListDeploymentsRequest$inboundSchema
   };
   tool$servingDeploymentsList = {
@@ -132467,9 +132696,9 @@ var init_servingDeploymentsList2 = __esm(() => {
     description: `List deployments
 
 List your inference deployments.`,
-    args: args285,
-    tool: async (client, args286, ctx) => {
-      const [result, apiCall] = await servingDeploymentsList(client, args286.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args286,
+    tool: async (client, args287, ctx) => {
+      const [result, apiCall] = await servingDeploymentsList(client, args287.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -132484,9 +132713,9 @@ List your inference deployments.`,
 
 // src/funcs/servingDeploymentsListReplicas.ts
 function servingDeploymentsListReplicas(client, request, options) {
-  return new APIPromise($do293(client, request, options));
+  return new APIPromise($do294(client, request, options));
 }
-async function $do293(client, request, options) {
+async function $do294(client, request, options) {
   const parsed = safeParse4(request, (value) => ListReplicasRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -132574,12 +132803,12 @@ var init_servingDeploymentsListReplicas = __esm(() => {
 });
 
 // src/mcp-server/tools/servingDeploymentsListReplicas.ts
-var args286, tool$servingDeploymentsListReplicas;
+var args287, tool$servingDeploymentsListReplicas;
 var init_servingDeploymentsListReplicas2 = __esm(() => {
   init_servingDeploymentsListReplicas();
   init_operations();
   init_tools();
-  args286 = {
+  args287 = {
     request: ListReplicasRequest$inboundSchema
   };
   tool$servingDeploymentsListReplicas = {
@@ -132587,9 +132816,9 @@ var init_servingDeploymentsListReplicas2 = __esm(() => {
     description: `List running replicas
 
 List the replicas currently backing a deployment.`,
-    args: args286,
-    tool: async (client, args287, ctx) => {
-      const [result, apiCall] = await servingDeploymentsListReplicas(client, args287.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args287,
+    tool: async (client, args288, ctx) => {
+      const [result, apiCall] = await servingDeploymentsListReplicas(client, args288.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -132604,9 +132833,9 @@ List the replicas currently backing a deployment.`,
 
 // src/funcs/servingDeploymentsListRevisions.ts
 function servingDeploymentsListRevisions(client, request, options) {
-  return new APIPromise($do294(client, request, options));
+  return new APIPromise($do295(client, request, options));
 }
-async function $do294(client, request, options) {
+async function $do295(client, request, options) {
   const parsed = safeParse4(request, (value) => ListRevisionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -132694,12 +132923,12 @@ var init_servingDeploymentsListRevisions = __esm(() => {
 });
 
 // src/mcp-server/tools/servingDeploymentsListRevisions.ts
-var args287, tool$servingDeploymentsListRevisions;
+var args288, tool$servingDeploymentsListRevisions;
 var init_servingDeploymentsListRevisions2 = __esm(() => {
   init_servingDeploymentsListRevisions();
   init_operations();
   init_tools();
-  args287 = {
+  args288 = {
     request: ListRevisionsRequest$inboundSchema
   };
   tool$servingDeploymentsListRevisions = {
@@ -132707,9 +132936,129 @@ var init_servingDeploymentsListRevisions2 = __esm(() => {
     description: `List config revisions
 
 List a deployment's configuration revisions, most recent first.`,
-    args: args287,
-    tool: async (client, args288, ctx) => {
-      const [result, apiCall] = await servingDeploymentsListRevisions(client, args288.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args288,
+    tool: async (client, args289, ctx) => {
+      const [result, apiCall] = await servingDeploymentsListRevisions(client, args289.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/servingDeploymentsRegister.ts
+function servingDeploymentsRegister(client, request, options) {
+  return new APIPromise($do296(client, request, options));
+}
+async function $do296(client, request, options) {
+  const parsed = safeParse4(request, (value) => RegisterDeploymentRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    deployment_id: encodeSimple("deployment_id", payload.deployment_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/api/v1/serving/deployments/{deployment_id}/registration")(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: "registerDeployment",
+    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: "POST",
+    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, Deployment$inboundSchema), 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 }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_servingDeploymentsRegister = __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/servingDeploymentsRegister.ts
+var args289, tool$servingDeploymentsRegister;
+var init_servingDeploymentsRegister2 = __esm(() => {
+  init_servingDeploymentsRegister();
+  init_operations();
+  init_tools();
+  args289 = {
+    request: RegisterDeploymentRequest$inboundSchema
+  };
+  tool$servingDeploymentsRegister = {
+    name: "serving-deployments-register",
+    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: args289,
+    tool: async (client, args290, ctx) => {
+      const [result, apiCall] = await servingDeploymentsRegister(client, args290.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -132724,9 +133073,9 @@ List a deployment's configuration revisions, most recent first.`,
 
 // src/funcs/servingDeploymentsRollback.ts
 function servingDeploymentsRollback(client, request, options) {
-  return new APIPromise($do295(client, request, options));
+  return new APIPromise($do297(client, request, options));
 }
-async function $do295(client, request, options) {
+async function $do297(client, request, options) {
   const parsed = safeParse4(request, (value) => RollbackDeploymentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -132817,12 +133166,12 @@ var init_servingDeploymentsRollback = __esm(() => {
 });
 
 // src/mcp-server/tools/servingDeploymentsRollback.ts
-var args288, tool$servingDeploymentsRollback;
+var args290, tool$servingDeploymentsRollback;
 var init_servingDeploymentsRollback2 = __esm(() => {
   init_servingDeploymentsRollback();
   init_operations();
   init_tools();
-  args288 = {
+  args290 = {
     request: RollbackDeploymentRequest$inboundSchema
   };
   tool$servingDeploymentsRollback = {
@@ -132830,9 +133179,9 @@ var init_servingDeploymentsRollback2 = __esm(() => {
     description: `Roll back to a previous revision
 
 Roll a deployment back to a previous configuration revision.`,
-    args: args288,
-    tool: async (client, args289, ctx) => {
-      const [result, apiCall] = await servingDeploymentsRollback(client, args289.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args290,
+    tool: async (client, args291, ctx) => {
+      const [result, apiCall] = await servingDeploymentsRollback(client, args291.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -132847,9 +133196,9 @@ Roll a deployment back to a previous configuration revision.`,
 
 // src/funcs/servingDeploymentsUpdate.ts
 function servingDeploymentsUpdate(client, request, options) {
-  return new APIPromise($do296(client, request, options));
+  return new APIPromise($do298(client, request, options));
 }
-async function $do296(client, request, options) {
+async function $do298(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateDeploymentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -132938,12 +133287,12 @@ var init_servingDeploymentsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/servingDeploymentsUpdate.ts
-var args289, tool$servingDeploymentsUpdate;
+var args291, tool$servingDeploymentsUpdate;
 var init_servingDeploymentsUpdate2 = __esm(() => {
   init_servingDeploymentsUpdate();
   init_operations();
   init_tools();
-  args289 = {
+  args291 = {
     request: UpdateDeploymentRequest$inboundSchema
   };
   tool$servingDeploymentsUpdate = {
@@ -132951,9 +133300,9 @@ var init_servingDeploymentsUpdate2 = __esm(() => {
     description: `Update a deployment (new revision)
 
 Update a deployment's configuration, rolling out a new revision.`,
-    args: args289,
-    tool: async (client, args290, ctx) => {
-      const [result, apiCall] = await servingDeploymentsUpdate(client, args290.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args291,
+    tool: async (client, args292, ctx) => {
+      const [result, apiCall] = await servingDeploymentsUpdate(client, args292.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -132968,9 +133317,9 @@ Update a deployment's configuration, rolling out a new revision.`,
 
 // src/funcs/servingDeploymentsUpdateScaling.ts
 function servingDeploymentsUpdateScaling(client, request, options) {
-  return new APIPromise($do297(client, request, options));
+  return new APIPromise($do299(client, request, options));
 }
-async function $do297(client, request, options) {
+async function $do299(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateScalingRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -133059,12 +133408,12 @@ var init_servingDeploymentsUpdateScaling = __esm(() => {
 });
 
 // src/mcp-server/tools/servingDeploymentsUpdateScaling.ts
-var args290, tool$servingDeploymentsUpdateScaling;
+var args292, tool$servingDeploymentsUpdateScaling;
 var init_servingDeploymentsUpdateScaling2 = __esm(() => {
   init_servingDeploymentsUpdateScaling();
   init_operations();
   init_tools();
-  args290 = {
+  args292 = {
     request: UpdateScalingRequest$inboundSchema
   };
   tool$servingDeploymentsUpdateScaling = {
@@ -133072,9 +133421,9 @@ var init_servingDeploymentsUpdateScaling2 = __esm(() => {
     description: `Update autoscaling live (no redeploy)
 
 Change a deployment's autoscaling limits in place, without redeploying.`,
-    args: args290,
-    tool: async (client, args291, ctx) => {
-      const [result, apiCall] = await servingDeploymentsUpdateScaling(client, args291.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args292,
+    tool: async (client, args293, ctx) => {
+      const [result, apiCall] = await servingDeploymentsUpdateScaling(client, args293.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -133089,9 +133438,9 @@ Change a deployment's autoscaling limits in place, without redeploying.`,
 
 // src/funcs/servingFinetuneJobsCancel.ts
 function servingFinetuneJobsCancel(client, request, options) {
-  return new APIPromise($do298(client, request, options));
+  return new APIPromise($do300(client, request, options));
 }
-async function $do298(client, request, options) {
+async function $do300(client, request, options) {
   const parsed = safeParse4(request, (value) => CancelFinetuneJobRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -133179,12 +133528,12 @@ var init_servingFinetuneJobsCancel = __esm(() => {
 });
 
 // src/mcp-server/tools/servingFinetuneJobsCancel.ts
-var args291, tool$servingFinetuneJobsCancel;
+var args293, tool$servingFinetuneJobsCancel;
 var init_servingFinetuneJobsCancel2 = __esm(() => {
   init_servingFinetuneJobsCancel();
   init_operations();
   init_tools();
-  args291 = {
+  args293 = {
     request: CancelFinetuneJobRequest$inboundSchema
   };
   tool$servingFinetuneJobsCancel = {
@@ -133192,9 +133541,9 @@ var init_servingFinetuneJobsCancel2 = __esm(() => {
     description: `Cancel a fine-tune job
 
 Cancel a running fine-tune job.`,
-    args: args291,
-    tool: async (client, args292, ctx) => {
-      const [result, apiCall] = await servingFinetuneJobsCancel(client, args292.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args293,
+    tool: async (client, args294, ctx) => {
+      const [result, apiCall] = await servingFinetuneJobsCancel(client, args294.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -133208,9 +133557,9 @@ Cancel a running fine-tune job.`,
 
 // src/funcs/servingFinetuneJobsCreate.ts
 function servingFinetuneJobsCreate(client, request, options) {
-  return new APIPromise($do299(client, request, options));
+  return new APIPromise($do301(client, request, options));
 }
-async function $do299(client, request, options) {
+async function $do301(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateFinetuneJobRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -133293,12 +133642,12 @@ var init_servingFinetuneJobsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/servingFinetuneJobsCreate.ts
-var args292, tool$servingFinetuneJobsCreate;
+var args294, tool$servingFinetuneJobsCreate;
 var init_servingFinetuneJobsCreate2 = __esm(() => {
   init_servingFinetuneJobsCreate();
   init_operations();
   init_tools();
-  args292 = {
+  args294 = {
     request: CreateFinetuneJobRequest$inboundSchema
   };
   tool$servingFinetuneJobsCreate = {
@@ -133306,9 +133655,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: args292,
-    tool: async (client, args293, ctx) => {
-      const [result, apiCall] = await servingFinetuneJobsCreate(client, args293.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args294,
+    tool: async (client, args295, ctx) => {
+      const [result, apiCall] = await servingFinetuneJobsCreate(client, args295.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -133323,9 +133672,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($do300(client, request, options));
+  return new APIPromise($do302(client, request, options));
 }
-async function $do300(client, request, options) {
+async function $do302(client, request, options) {
   const parsed = safeParse4(request, (value) => GetFinetuneJobRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -133413,12 +133762,12 @@ var init_servingFinetuneJobsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/servingFinetuneJobsGet.ts
-var args293, tool$servingFinetuneJobsGet;
+var args295, tool$servingFinetuneJobsGet;
 var init_servingFinetuneJobsGet2 = __esm(() => {
   init_servingFinetuneJobsGet();
   init_operations();
   init_tools();
-  args293 = {
+  args295 = {
     request: GetFinetuneJobRequest$inboundSchema
   };
   tool$servingFinetuneJobsGet = {
@@ -133426,9 +133775,9 @@ var init_servingFinetuneJobsGet2 = __esm(() => {
     description: `Get a fine-tune job
 
 Retrieve a fine-tune job, including its status and progress.`,
-    args: args293,
-    tool: async (client, args294, ctx) => {
-      const [result, apiCall] = await servingFinetuneJobsGet(client, args294.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args295,
+    tool: async (client, args296, ctx) => {
+      const [result, apiCall] = await servingFinetuneJobsGet(client, args296.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -133443,9 +133792,9 @@ Retrieve a fine-tune job, including its status and progress.`,
 
 // src/funcs/servingFinetuneJobsGetEvents.ts
 function servingFinetuneJobsGetEvents(client, request, options) {
-  return new APIPromise($do301(client, request, options));
+  return new APIPromise($do303(client, request, options));
 }
-async function $do301(client, request, options) {
+async function $do303(client, request, options) {
   const parsed = safeParse4(request, (value) => GetFinetuneEventsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -133459,6 +133808,9 @@ async function $do301(client, request, options) {
     })
   };
   const path = pathToFunc("/api/v1/serving/finetune-jobs/{job_id}/events")(pathParams);
+  const query = encodeFormQuery({
+    include_lineage: payload.include_lineage
+  });
   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" })
@@ -133491,6 +133843,7 @@ async function $do301(client, request, options) {
     baseURL: options?.serverURL,
     path,
     headers,
+    query,
     body,
     userAgent: client._options.userAgent,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
@@ -133534,12 +133887,12 @@ var init_servingFinetuneJobsGetEvents = __esm(() => {
 });
 
 // src/mcp-server/tools/servingFinetuneJobsGetEvents.ts
-var args294, tool$servingFinetuneJobsGetEvents;
+var args296, tool$servingFinetuneJobsGetEvents;
 var init_servingFinetuneJobsGetEvents2 = __esm(() => {
   init_servingFinetuneJobsGetEvents();
   init_operations();
   init_tools();
-  args294 = {
+  args296 = {
     request: GetFinetuneEventsRequest$inboundSchema
   };
   tool$servingFinetuneJobsGetEvents = {
@@ -133547,9 +133900,9 @@ var init_servingFinetuneJobsGetEvents2 = __esm(() => {
     description: `Status timeline
 
 Return the job's status timeline (queued, running, checkpoints, completion).`,
-    args: args294,
-    tool: async (client, args295, ctx) => {
-      const [result, apiCall] = await servingFinetuneJobsGetEvents(client, args295.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args296,
+    tool: async (client, args297, ctx) => {
+      const [result, apiCall] = await servingFinetuneJobsGetEvents(client, args297.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -133564,9 +133917,9 @@ Return the job's status timeline (queued, running, checkpoints, completion).`,
 
 // src/funcs/servingFinetuneJobsGetLogs.ts
 function servingFinetuneJobsGetLogs(client, request, options) {
-  return new APIPromise($do302(client, request, options));
+  return new APIPromise($do304(client, request, options));
 }
-async function $do302(client, request, options) {
+async function $do304(client, request, options) {
   const parsed = safeParse4(request, (value) => GetFinetuneLogsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -133659,12 +134012,12 @@ var init_servingFinetuneJobsGetLogs = __esm(() => {
 });
 
 // src/mcp-server/tools/servingFinetuneJobsGetLogs.ts
-var args295, tool$servingFinetuneJobsGetLogs;
+var args297, tool$servingFinetuneJobsGetLogs;
 var init_servingFinetuneJobsGetLogs2 = __esm(() => {
   init_servingFinetuneJobsGetLogs();
   init_operations();
   init_tools();
-  args295 = {
+  args297 = {
     request: GetFinetuneLogsRequest$inboundSchema
   };
   tool$servingFinetuneJobsGetLogs = {
@@ -133672,9 +134025,9 @@ var init_servingFinetuneJobsGetLogs2 = __esm(() => {
     description: `Fetch training logs
 
 Fetch recent training log lines for a job.`,
-    args: args295,
-    tool: async (client, args296, ctx) => {
-      const [result, apiCall] = await servingFinetuneJobsGetLogs(client, args296.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args297,
+    tool: async (client, args298, ctx) => {
+      const [result, apiCall] = await servingFinetuneJobsGetLogs(client, args298.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -133689,9 +134042,9 @@ Fetch recent training log lines for a job.`,
 
 // src/funcs/servingFinetuneJobsList.ts
 function servingFinetuneJobsList(client, request, options) {
-  return new APIPromise($do303(client, request, options));
+  return new APIPromise($do305(client, request, options));
 }
-async function $do303(client, request, options) {
+async function $do305(client, request, options) {
   const parsed = safeParse4(request, (value) => ListFinetuneJobsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -133778,12 +134131,12 @@ var init_servingFinetuneJobsList = __esm(() => {
 });
 
 // src/mcp-server/tools/servingFinetuneJobsList.ts
-var args296, tool$servingFinetuneJobsList;
+var args298, tool$servingFinetuneJobsList;
 var init_servingFinetuneJobsList2 = __esm(() => {
   init_servingFinetuneJobsList();
   init_operations();
   init_tools();
-  args296 = {
+  args298 = {
     request: ListFinetuneJobsRequest$inboundSchema
   };
   tool$servingFinetuneJobsList = {
@@ -133791,9 +134144,9 @@ var init_servingFinetuneJobsList2 = __esm(() => {
     description: `List fine-tune jobs
 
 List your fine-tune jobs.`,
-    args: args296,
-    tool: async (client, args297, ctx) => {
-      const [result, apiCall] = await servingFinetuneJobsList(client, args297.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args298,
+    tool: async (client, args299, ctx) => {
+      const [result, apiCall] = await servingFinetuneJobsList(client, args299.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -133808,9 +134161,9 @@ List your fine-tune jobs.`,
 
 // src/funcs/servingFinetuneJobsListCheckpoints.ts
 function servingFinetuneJobsListCheckpoints(client, request, options) {
-  return new APIPromise($do304(client, request, options));
+  return new APIPromise($do306(client, request, options));
 }
-async function $do304(client, request, options) {
+async function $do306(client, request, options) {
   const parsed = safeParse4(request, (value) => ListFinetuneCheckpointsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -133899,12 +134252,12 @@ var init_servingFinetuneJobsListCheckpoints = __esm(() => {
 });
 
 // src/mcp-server/tools/servingFinetuneJobsListCheckpoints.ts
-var args297, tool$servingFinetuneJobsListCheckpoints;
+var args299, tool$servingFinetuneJobsListCheckpoints;
 var init_servingFinetuneJobsListCheckpoints2 = __esm(() => {
   init_servingFinetuneJobsListCheckpoints();
   init_operations();
   init_tools();
-  args297 = {
+  args299 = {
     request: ListFinetuneCheckpointsRequest$inboundSchema
   };
   tool$servingFinetuneJobsListCheckpoints = {
@@ -133912,9 +134265,9 @@ var init_servingFinetuneJobsListCheckpoints2 = __esm(() => {
     description: `List output checkpoints
 
 List the checkpoints a fine-tune job has produced.`,
-    args: args297,
-    tool: async (client, args298, ctx) => {
-      const [result, apiCall] = await servingFinetuneJobsListCheckpoints(client, args298.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args299,
+    tool: async (client, args300, ctx) => {
+      const [result, apiCall] = await servingFinetuneJobsListCheckpoints(client, args300.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -133929,9 +134282,9 @@ List the checkpoints a fine-tune job has produced.`,
 
 // src/funcs/servingImagesBuild.ts
 function servingImagesBuild(client, request, options) {
-  return new APIPromise($do305(client, request, options));
+  return new APIPromise($do307(client, request, options));
 }
-async function $do305(client, request, options) {
+async function $do307(client, request, options) {
   const parsed = safeParse4(request, (value) => BuildImageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -134014,12 +134367,12 @@ var init_servingImagesBuild = __esm(() => {
 });
 
 // src/mcp-server/tools/servingImagesBuild.ts
-var args298, tool$servingImagesBuild;
+var args300, tool$servingImagesBuild;
 var init_servingImagesBuild2 = __esm(() => {
   init_servingImagesBuild();
   init_operations();
   init_tools();
-  args298 = {
+  args300 = {
     request: BuildImageRequest$inboundSchema
   };
   tool$servingImagesBuild = {
@@ -134027,9 +134380,9 @@ var init_servingImagesBuild2 = __esm(() => {
     description: `Build a container image
 
 Build a custom container image from a recipe for use by deployments and jobs.`,
-    args: args298,
-    tool: async (client, args299, ctx) => {
-      const [result, apiCall] = await servingImagesBuild(client, args299.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args300,
+    tool: async (client, args301, ctx) => {
+      const [result, apiCall] = await servingImagesBuild(client, args301.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -134044,9 +134397,9 @@ Build a custom container image from a recipe for use by deployments and jobs.`,
 
 // src/funcs/servingImagesDelete.ts
 function servingImagesDelete(client, request, options) {
-  return new APIPromise($do306(client, request, options));
+  return new APIPromise($do308(client, request, options));
 }
-async function $do306(client, request, options) {
+async function $do308(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteImageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -134134,12 +134487,12 @@ var init_servingImagesDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/servingImagesDelete.ts
-var args299, tool$servingImagesDelete;
+var args301, tool$servingImagesDelete;
 var init_servingImagesDelete2 = __esm(() => {
   init_servingImagesDelete();
   init_operations();
   init_tools();
-  args299 = {
+  args301 = {
     request: DeleteImageRequest$inboundSchema
   };
   tool$servingImagesDelete = {
@@ -134147,9 +134500,9 @@ var init_servingImagesDelete2 = __esm(() => {
     description: `Delete an image
 
 Delete a container image.`,
-    args: args299,
-    tool: async (client, args300, ctx) => {
-      const [result, apiCall] = await servingImagesDelete(client, args300.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args301,
+    tool: async (client, args302, ctx) => {
+      const [result, apiCall] = await servingImagesDelete(client, args302.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -134163,9 +134516,9 @@ Delete a container image.`,
 
 // src/funcs/servingImagesGet.ts
 function servingImagesGet(client, request, options) {
-  return new APIPromise($do307(client, request, options));
+  return new APIPromise($do309(client, request, options));
 }
-async function $do307(client, request, options) {
+async function $do309(client, request, options) {
   const parsed = safeParse4(request, (value) => GetImageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -134253,12 +134606,12 @@ var init_servingImagesGet = __esm(() => {
 });
 
 // src/mcp-server/tools/servingImagesGet.ts
-var args300, tool$servingImagesGet;
+var args302, tool$servingImagesGet;
 var init_servingImagesGet2 = __esm(() => {
   init_servingImagesGet();
   init_operations();
   init_tools();
-  args300 = {
+  args302 = {
     request: GetImageRequest$inboundSchema
   };
   tool$servingImagesGet = {
@@ -134266,9 +134619,9 @@ var init_servingImagesGet2 = __esm(() => {
     description: `Get an image
 
 Retrieve an image, including its build status.`,
-    args: args300,
-    tool: async (client, args301, ctx) => {
-      const [result, apiCall] = await servingImagesGet(client, args301.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args302,
+    tool: async (client, args303, ctx) => {
+      const [result, apiCall] = await servingImagesGet(client, args303.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -134283,9 +134636,9 @@ Retrieve an image, including its build status.`,
 
 // src/funcs/servingImagesList.ts
 function servingImagesList(client, request, options) {
-  return new APIPromise($do308(client, request, options));
+  return new APIPromise($do310(client, request, options));
 }
-async function $do308(client, request, options) {
+async function $do310(client, request, options) {
   const parsed = safeParse4(request, (value) => ListImagesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -134372,12 +134725,12 @@ var init_servingImagesList = __esm(() => {
 });
 
 // src/mcp-server/tools/servingImagesList.ts
-var args301, tool$servingImagesList;
+var args303, tool$servingImagesList;
 var init_servingImagesList2 = __esm(() => {
   init_servingImagesList();
   init_operations();
   init_tools();
-  args301 = {
+  args303 = {
     request: ListImagesRequest$inboundSchema
   };
   tool$servingImagesList = {
@@ -134385,9 +134738,9 @@ var init_servingImagesList2 = __esm(() => {
     description: `List images
 
 List your container images.`,
-    args: args301,
-    tool: async (client, args302, ctx) => {
-      const [result, apiCall] = await servingImagesList(client, args302.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args303,
+    tool: async (client, args304, ctx) => {
+      const [result, apiCall] = await servingImagesList(client, args304.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -134402,9 +134755,9 @@ List your container images.`,
 
 // src/funcs/servingModelsDelete.ts
 function servingModelsDelete(client, request, options) {
-  return new APIPromise($do309(client, request, options));
+  return new APIPromise($do311(client, request, options));
 }
-async function $do309(client, request, options) {
+async function $do311(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteModelRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -134492,12 +134845,12 @@ var init_servingModelsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/servingModelsDelete.ts
-var args302, tool$servingModelsDelete;
+var args304, tool$servingModelsDelete;
 var init_servingModelsDelete2 = __esm(() => {
   init_servingModelsDelete();
   init_operations();
   init_tools();
-  args302 = {
+  args304 = {
     request: DeleteModelRequest$inboundSchema
   };
   tool$servingModelsDelete = {
@@ -134505,9 +134858,9 @@ var init_servingModelsDelete2 = __esm(() => {
     description: `Deregister a model
 
 Deregister a model from the catalog.`,
-    args: args302,
-    tool: async (client, args303, ctx) => {
-      const [result, apiCall] = await servingModelsDelete(client, args303.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args304,
+    tool: async (client, args305, ctx) => {
+      const [result, apiCall] = await servingModelsDelete(client, args305.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -134521,9 +134874,9 @@ Deregister a model from the catalog.`,
 
 // src/funcs/servingModelsGet.ts
 function servingModelsGet(client, request, options) {
-  return new APIPromise($do310(client, request, options));
+  return new APIPromise($do312(client, request, options));
 }
-async function $do310(client, request, options) {
+async function $do312(client, request, options) {
   const parsed = safeParse4(request, (value) => GetServingModelRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -134611,12 +134964,12 @@ var init_servingModelsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/servingModelsGet.ts
-var args303, tool$servingModelsGet;
+var args305, tool$servingModelsGet;
 var init_servingModelsGet2 = __esm(() => {
   init_servingModelsGet();
   init_operations();
   init_tools();
-  args303 = {
+  args305 = {
     request: GetServingModelRequest$inboundSchema
   };
   tool$servingModelsGet = {
@@ -134624,9 +134977,9 @@ var init_servingModelsGet2 = __esm(() => {
     description: `Get a model
 
 Retrieve a registered model.`,
-    args: args303,
-    tool: async (client, args304, ctx) => {
-      const [result, apiCall] = await servingModelsGet(client, args304.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args305,
+    tool: async (client, args306, ctx) => {
+      const [result, apiCall] = await servingModelsGet(client, args306.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -134641,9 +134994,9 @@ Retrieve a registered model.`,
 
 // src/funcs/servingModelsList.ts
 function servingModelsList(client, request, options) {
-  return new APIPromise($do311(client, request, options));
+  return new APIPromise($do313(client, request, options));
 }
-async function $do311(client, request, options) {
+async function $do313(client, request, options) {
   const parsed = safeParse4(request, (value) => ListServingModelsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -134730,12 +135083,12 @@ var init_servingModelsList = __esm(() => {
 });
 
 // src/mcp-server/tools/servingModelsList.ts
-var args304, tool$servingModelsList;
+var args306, tool$servingModelsList;
 var init_servingModelsList2 = __esm(() => {
   init_servingModelsList();
   init_operations();
   init_tools();
-  args304 = {
+  args306 = {
     request: ListServingModelsRequest$inboundSchema
   };
   tool$servingModelsList = {
@@ -134743,9 +135096,9 @@ var init_servingModelsList2 = __esm(() => {
     description: `List models
 
 List your registered models.`,
-    args: args304,
-    tool: async (client, args305, ctx) => {
-      const [result, apiCall] = await servingModelsList(client, args305.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args306,
+    tool: async (client, args307, ctx) => {
+      const [result, apiCall] = await servingModelsList(client, args307.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -134760,9 +135113,9 @@ List your registered models.`,
 
 // src/funcs/servingModelsRegister.ts
 function servingModelsRegister(client, request, options) {
-  return new APIPromise($do312(client, request, options));
+  return new APIPromise($do314(client, request, options));
 }
-async function $do312(client, request, options) {
+async function $do314(client, request, options) {
   const parsed = safeParse4(request, (value) => RegisterModelRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -134845,12 +135198,12 @@ var init_servingModelsRegister = __esm(() => {
 });
 
 // src/mcp-server/tools/servingModelsRegister.ts
-var args305, tool$servingModelsRegister;
+var args307, tool$servingModelsRegister;
 var init_servingModelsRegister2 = __esm(() => {
   init_servingModelsRegister();
   init_operations();
   init_tools();
-  args305 = {
+  args307 = {
     request: RegisterModelRequest$inboundSchema
   };
   tool$servingModelsRegister = {
@@ -134858,9 +135211,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: args305,
-    tool: async (client, args306, ctx) => {
-      const [result, apiCall] = await servingModelsRegister(client, args306.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args307,
+    tool: async (client, args308, ctx) => {
+      const [result, apiCall] = await servingModelsRegister(client, args308.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -134875,9 +135228,9 @@ Register a model (from a source or volume) so it can be deployed or fine-tuned.`
 
 // src/funcs/servingSecretsCreate.ts
 function servingSecretsCreate(client, request, options) {
-  return new APIPromise($do313(client, request, options));
+  return new APIPromise($do315(client, request, options));
 }
-async function $do313(client, request, options) {
+async function $do315(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateSecretRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -134960,12 +135313,12 @@ var init_servingSecretsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/servingSecretsCreate.ts
-var args306, tool$servingSecretsCreate;
+var args308, tool$servingSecretsCreate;
 var init_servingSecretsCreate2 = __esm(() => {
   init_servingSecretsCreate();
   init_operations();
   init_tools();
-  args306 = {
+  args308 = {
     request: CreateSecretRequest$inboundSchema
   };
   tool$servingSecretsCreate = {
@@ -134973,9 +135326,9 @@ var init_servingSecretsCreate2 = __esm(() => {
     description: `Create a secret
 
 Create a secret whose values are injected into your workloads as env vars.`,
-    args: args306,
-    tool: async (client, args307, ctx) => {
-      const [result, apiCall] = await servingSecretsCreate(client, args307.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args308,
+    tool: async (client, args309, ctx) => {
+      const [result, apiCall] = await servingSecretsCreate(client, args309.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -134990,9 +135343,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($do314(client, request, options));
+  return new APIPromise($do316(client, request, options));
 }
-async function $do314(client, request, options) {
+async function $do316(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteSecretRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135080,12 +135433,12 @@ var init_servingSecretsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/servingSecretsDelete.ts
-var args307, tool$servingSecretsDelete;
+var args309, tool$servingSecretsDelete;
 var init_servingSecretsDelete2 = __esm(() => {
   init_servingSecretsDelete();
   init_operations();
   init_tools();
-  args307 = {
+  args309 = {
     request: DeleteSecretRequest$inboundSchema
   };
   tool$servingSecretsDelete = {
@@ -135093,9 +135446,9 @@ var init_servingSecretsDelete2 = __esm(() => {
     description: `Delete a secret
 
 Delete a secret.`,
-    args: args307,
-    tool: async (client, args308, ctx) => {
-      const [result, apiCall] = await servingSecretsDelete(client, args308.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args309,
+    tool: async (client, args310, ctx) => {
+      const [result, apiCall] = await servingSecretsDelete(client, args310.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -135109,9 +135462,9 @@ Delete a secret.`,
 
 // src/funcs/servingSecretsList.ts
 function servingSecretsList(client, request, options) {
-  return new APIPromise($do315(client, request, options));
+  return new APIPromise($do317(client, request, options));
 }
-async function $do315(client, request, options) {
+async function $do317(client, request, options) {
   const parsed = safeParse4(request, (value) => ListSecretsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135198,12 +135551,12 @@ var init_servingSecretsList = __esm(() => {
 });
 
 // src/mcp-server/tools/servingSecretsList.ts
-var args308, tool$servingSecretsList;
+var args310, tool$servingSecretsList;
 var init_servingSecretsList2 = __esm(() => {
   init_servingSecretsList();
   init_operations();
   init_tools();
-  args308 = {
+  args310 = {
     request: ListSecretsRequest$inboundSchema
   };
   tool$servingSecretsList = {
@@ -135211,9 +135564,9 @@ var init_servingSecretsList2 = __esm(() => {
     description: `List secrets (names only)
 
 List your secrets by name (values are never returned).`,
-    args: args308,
-    tool: async (client, args309, ctx) => {
-      const [result, apiCall] = await servingSecretsList(client, args309.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args310,
+    tool: async (client, args311, ctx) => {
+      const [result, apiCall] = await servingSecretsList(client, args311.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -135228,9 +135581,9 @@ List your secrets by name (values are never returned).`,
 
 // src/funcs/servingVolumesCreate.ts
 function servingVolumesCreate(client, request, options) {
-  return new APIPromise($do316(client, request, options));
+  return new APIPromise($do318(client, request, options));
 }
-async function $do316(client, request, options) {
+async function $do318(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateVolumeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135313,12 +135666,12 @@ var init_servingVolumesCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/servingVolumesCreate.ts
-var args309, tool$servingVolumesCreate;
+var args311, tool$servingVolumesCreate;
 var init_servingVolumesCreate2 = __esm(() => {
   init_servingVolumesCreate();
   init_operations();
   init_tools();
-  args309 = {
+  args311 = {
     request: CreateVolumeRequest$inboundSchema
   };
   tool$servingVolumesCreate = {
@@ -135326,9 +135679,9 @@ var init_servingVolumesCreate2 = __esm(() => {
     description: `Create a volume
 
 Create a persistent volume for weights, datasets, or checkpoints.`,
-    args: args309,
-    tool: async (client, args310, ctx) => {
-      const [result, apiCall] = await servingVolumesCreate(client, args310.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args311,
+    tool: async (client, args312, ctx) => {
+      const [result, apiCall] = await servingVolumesCreate(client, args312.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -135343,9 +135696,9 @@ Create a persistent volume for weights, datasets, or checkpoints.`,
 
 // src/funcs/servingVolumesDelete.ts
 function servingVolumesDelete(client, request, options) {
-  return new APIPromise($do317(client, request, options));
+  return new APIPromise($do319(client, request, options));
 }
-async function $do317(client, request, options) {
+async function $do319(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteVolumeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135433,12 +135786,12 @@ var init_servingVolumesDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/servingVolumesDelete.ts
-var args310, tool$servingVolumesDelete;
+var args312, tool$servingVolumesDelete;
 var init_servingVolumesDelete2 = __esm(() => {
   init_servingVolumesDelete();
   init_operations();
   init_tools();
-  args310 = {
+  args312 = {
     request: DeleteVolumeRequest$inboundSchema
   };
   tool$servingVolumesDelete = {
@@ -135446,9 +135799,9 @@ var init_servingVolumesDelete2 = __esm(() => {
     description: `Delete a volume
 
 Delete a volume and its contents.`,
-    args: args310,
-    tool: async (client, args311, ctx) => {
-      const [result, apiCall] = await servingVolumesDelete(client, args311.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args312,
+    tool: async (client, args313, ctx) => {
+      const [result, apiCall] = await servingVolumesDelete(client, args313.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -135462,9 +135815,9 @@ Delete a volume and its contents.`,
 
 // src/funcs/servingVolumesGet.ts
 function servingVolumesGet(client, request, options) {
-  return new APIPromise($do318(client, request, options));
+  return new APIPromise($do320(client, request, options));
 }
-async function $do318(client, request, options) {
+async function $do320(client, request, options) {
   const parsed = safeParse4(request, (value) => GetVolumeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135552,12 +135905,12 @@ var init_servingVolumesGet = __esm(() => {
 });
 
 // src/mcp-server/tools/servingVolumesGet.ts
-var args311, tool$servingVolumesGet;
+var args313, tool$servingVolumesGet;
 var init_servingVolumesGet2 = __esm(() => {
   init_servingVolumesGet();
   init_operations();
   init_tools();
-  args311 = {
+  args313 = {
     request: GetVolumeRequest$inboundSchema
   };
   tool$servingVolumesGet = {
@@ -135565,9 +135918,9 @@ var init_servingVolumesGet2 = __esm(() => {
     description: `Get a volume
 
 Retrieve a volume.`,
-    args: args311,
-    tool: async (client, args312, ctx) => {
-      const [result, apiCall] = await servingVolumesGet(client, args312.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args313,
+    tool: async (client, args314, ctx) => {
+      const [result, apiCall] = await servingVolumesGet(client, args314.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -135582,9 +135935,9 @@ Retrieve a volume.`,
 
 // src/funcs/servingVolumesList.ts
 function servingVolumesList(client, request, options) {
-  return new APIPromise($do319(client, request, options));
+  return new APIPromise($do321(client, request, options));
 }
-async function $do319(client, request, options) {
+async function $do321(client, request, options) {
   const parsed = safeParse4(request, (value) => ListVolumesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135671,12 +136024,12 @@ var init_servingVolumesList = __esm(() => {
 });
 
 // src/mcp-server/tools/servingVolumesList.ts
-var args312, tool$servingVolumesList;
+var args314, tool$servingVolumesList;
 var init_servingVolumesList2 = __esm(() => {
   init_servingVolumesList();
   init_operations();
   init_tools();
-  args312 = {
+  args314 = {
     request: ListVolumesRequest$inboundSchema
   };
   tool$servingVolumesList = {
@@ -135684,9 +136037,9 @@ var init_servingVolumesList2 = __esm(() => {
     description: `List volumes
 
 List your volumes.`,
-    args: args312,
-    tool: async (client, args313, ctx) => {
-      const [result, apiCall] = await servingVolumesList(client, args313.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args314,
+    tool: async (client, args315, ctx) => {
+      const [result, apiCall] = await servingVolumesList(client, args315.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -135701,9 +136054,9 @@ List your volumes.`,
 
 // src/funcs/usageCosts.ts
 function usageCosts(client, request, options) {
-  return new APIPromise($do320(client, request, options));
+  return new APIPromise($do322(client, request, options));
 }
-async function $do320(client, request, options) {
+async function $do322(client, request, options) {
   const parsed = safeParse4(request, (value) => GetCostsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135786,12 +136139,12 @@ var init_usageCosts = __esm(() => {
 });
 
 // src/mcp-server/tools/usageCosts.ts
-var args313, tool$usageCosts;
+var args315, tool$usageCosts;
 var init_usageCosts2 = __esm(() => {
   init_usageCosts();
   init_operations();
   init_tools();
-  args313 = {
+  args315 = {
     request: GetCostsRequest$inboundSchema
   };
   tool$usageCosts = {
@@ -135799,9 +136152,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: args313,
-    tool: async (client, args314, ctx) => {
-      const [result, apiCall] = await usageCosts(client, args314.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args315,
+    tool: async (client, args316, ctx) => {
+      const [result, apiCall] = await usageCosts(client, args316.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -135816,9 +136169,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($do321(client, request, options));
+  return new APIPromise($do323(client, request, options));
 }
-async function $do321(client, request, options) {
+async function $do323(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSandboxUsageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -135909,12 +136262,12 @@ var init_usageSandbox = __esm(() => {
 });
 
 // src/mcp-server/tools/usageSandbox.ts
-var args314, tool$usageSandbox;
+var args316, tool$usageSandbox;
 var init_usageSandbox2 = __esm(() => {
   init_usageSandbox();
   init_operations();
   init_tools();
-  args314 = {
+  args316 = {
     request: GetSandboxUsageRequest$inboundSchema
   };
   tool$usageSandbox = {
@@ -135922,9 +136275,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: args314,
-    tool: async (client, args315, ctx) => {
-      const [result, apiCall] = await usageSandbox(client, args315.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args316,
+    tool: async (client, args317, ctx) => {
+      const [result, apiCall] = await usageSandbox(client, args317.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -135941,7 +136294,7 @@ Aggregate sandbox usage (session lifecycle, execution, and workspace operations)
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "SDK",
-    version: "0.49.17"
+    version: "0.49.18"
   });
   const client = new SDKCore({
     bearerAuth: deps.bearerAuth,
@@ -136242,40 +136595,42 @@ function createMCPServer(deps) {
   tool(tool$authClusterInviteInfo);
   tool(tool$authClusterAcceptInvite);
   tool(tool$authApiKeyGetJwtFromKey);
-  tool(tool$servingDeploymentsCreate);
+  tool(tool$servingAcceleratorsList);
   tool(tool$servingDeploymentsList);
+  tool(tool$servingDeploymentsCreate);
+  tool(tool$servingDeploymentsDelete);
   tool(tool$servingDeploymentsGet);
   tool(tool$servingDeploymentsUpdate);
-  tool(tool$servingDeploymentsDelete);
-  tool(tool$servingDeploymentsUpdateScaling);
-  tool(tool$servingDeploymentsListRevisions);
-  tool(tool$servingDeploymentsRollback);
   tool(tool$servingDeploymentsGetLogs);
   tool(tool$servingDeploymentsGetMetrics);
+  tool(tool$servingDeploymentsDeregister);
+  tool(tool$servingDeploymentsRegister);
   tool(tool$servingDeploymentsListReplicas);
-  tool(tool$servingFinetuneJobsCreate);
+  tool(tool$servingDeploymentsListRevisions);
+  tool(tool$servingDeploymentsRollback);
+  tool(tool$servingDeploymentsUpdateScaling);
   tool(tool$servingFinetuneJobsList);
-  tool(tool$servingFinetuneJobsGet);
+  tool(tool$servingFinetuneJobsCreate);
   tool(tool$servingFinetuneJobsCancel);
-  tool(tool$servingFinetuneJobsGetLogs);
-  tool(tool$servingFinetuneJobsGetEvents);
+  tool(tool$servingFinetuneJobsGet);
   tool(tool$servingFinetuneJobsListCheckpoints);
-  tool(tool$servingImagesBuild);
+  tool(tool$servingFinetuneJobsGetEvents);
+  tool(tool$servingFinetuneJobsGetLogs);
   tool(tool$servingImagesList);
-  tool(tool$servingImagesGet);
+  tool(tool$servingImagesBuild);
   tool(tool$servingImagesDelete);
-  tool(tool$servingModelsRegister);
+  tool(tool$servingImagesGet);
   tool(tool$servingModelsList);
-  tool(tool$servingModelsGet);
+  tool(tool$servingModelsRegister);
   tool(tool$servingModelsDelete);
-  tool(tool$servingVolumesCreate);
-  tool(tool$servingVolumesList);
-  tool(tool$servingVolumesGet);
-  tool(tool$servingVolumesDelete);
-  tool(tool$servingSecretsCreate);
+  tool(tool$servingModelsGet);
   tool(tool$servingSecretsList);
+  tool(tool$servingSecretsCreate);
   tool(tool$servingSecretsDelete);
-  tool(tool$servingAcceleratorsList);
+  tool(tool$servingVolumesList);
+  tool(tool$servingVolumesCreate);
+  tool(tool$servingVolumesDelete);
+  tool(tool$servingVolumesGet);
   return server;
 }
 var init_server2 = __esm(() => {
@@ -136571,12 +136926,14 @@ var init_server2 = __esm(() => {
   init_servingAcceleratorsList2();
   init_servingDeploymentsCreate2();
   init_servingDeploymentsDelete2();
+  init_servingDeploymentsDeregister2();
   init_servingDeploymentsGet2();
   init_servingDeploymentsGetLogs2();
   init_servingDeploymentsGetMetrics2();
   init_servingDeploymentsList2();
   init_servingDeploymentsListReplicas2();
   init_servingDeploymentsListRevisions2();
+  init_servingDeploymentsRegister2();
   init_servingDeploymentsRollback2();
   init_servingDeploymentsUpdate2();
   init_servingDeploymentsUpdateScaling2();
@@ -137781,7 +138138,7 @@ var routes = rn({
 var app = Ve(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.49.17"
+    currentVersion: "0.49.18"
   }
 });
 _t(app, process3.argv.slice(2), buildContext(process3));
@@ -137789,5 +138146,5 @@ export {
   app
 };
 
-//# debugId=4021B2ACCE40ACF964756E2164756E21
+//# debugId=433469A4B3F2A83B64756E2164756E21
 //# sourceMappingURL=mcp-server.js.map