@meetkai/mka1 0.49.17 → 0.49.18

package/src/models/components/deployment.ts

@@ -14,6 +14,12 @@ import {
   AcceleratorSpec$Outbound,
   AcceleratorSpec$outboundSchema,
 } from "./acceleratorspec.js";
+import {
+  DeploymentEndpoint,
+  DeploymentEndpoint$inboundSchema,
+  DeploymentEndpoint$Outbound,
+  DeploymentEndpoint$outboundSchema,
+} from "./deploymentendpoint.js";
 import {
   Engine,
   Engine$inboundSchema,
@@ -27,12 +33,15 @@ import {
 } from "./scaling.js";
 
 export const DeploymentStatus = {
+  Pending: "pending",
   Provisioning: "provisioning",
   Ready: "ready",
   Scaling: "scaling",
   Updating: "updating",
-  Error: "error",
+  Degraded: "degraded",
+  Failed: "failed",
   Stopped: "stopped",
+  Deleted: "deleted",
 } as const;
 export type DeploymentStatus = ClosedEnum<typeof DeploymentStatus>;
 
@@ -40,18 +49,6 @@ export type DeploymentStatus = ClosedEnum<typeof DeploymentStatus>;
  * A deployed inference server.
  */
 export type Deployment = {
-  id: string;
-  name: string;
-  status: DeploymentStatus;
-  /**
-   * Public endpoint once ready
-   */
-  url?: string | null | undefined;
-  model: string;
-  /**
-   * Inference engine that backs a deployment.
-   */
-  engine: Engine;
   /**
    * A hardware accelerator request — GPU, NPU, TPU, or similar.
    *
@@ -60,16 +57,32 @@ export type Deployment = {
    * Request an accelerator by type and count, with optional fallback types.
    */
   accelerator: AcceleratorSpec;
+  createdAt: Date;
   /**
-   * Autoscaling configuration for a deployment.
+   * Where and how to call the model; set while registered with the gateway
    */
-  scaling: Scaling;
+  endpoint?: DeploymentEndpoint | null | undefined;
+  /**
+   * Inference engine that backs a deployment.
+   */
+  engine: Engine;
+  id: string;
   image: string | null;
+  model: string;
+  name: string;
   /**
    * Current config revision
    */
   revision: number;
-  createdAt: Date;
+  /**
+   * Autoscaling configuration for a deployment.
+   */
+  scaling: Scaling;
+  /**
+   * Model ID consumers pass to the gateway's inference endpoints; set while the deployment is registered with the gateway (see Register), null when unregistered
+   */
+  servedModelId?: string | null | undefined;
+  status: DeploymentStatus;
   updatedAt: Date;
 };
 
@@ -88,37 +101,40 @@ export const Deployment$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.string(),
-  name: z.string(),
-  status: DeploymentStatus$inboundSchema,
-  url: z.nullable(z.string()).optional(),
-  model: z.string(),
-  engine: Engine$inboundSchema,
   accelerator: AcceleratorSpec$inboundSchema,
-  scaling: Scaling$inboundSchema,
+  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  endpoint: z.nullable(DeploymentEndpoint$inboundSchema).optional(),
+  engine: Engine$inboundSchema,
+  id: z.string(),
   image: z.nullable(z.string()),
+  model: z.string(),
+  name: z.string(),
   revision: z.number().int(),
-  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  scaling: Scaling$inboundSchema,
+  served_model_id: z.nullable(z.string()).optional(),
+  status: DeploymentStatus$inboundSchema,
   updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
 }).transform((v) => {
   return remap$(v, {
     "created_at": "createdAt",
+    "served_model_id": "servedModelId",
     "updated_at": "updatedAt",
   });
 });
 /** @internal */
 export type Deployment$Outbound = {
-  id: string;
-  name: string;
-  status: string;
-  url?: string | null | undefined;
-  model: string;
-  engine: string;
   accelerator: AcceleratorSpec$Outbound;
-  scaling: Scaling$Outbound;
+  created_at: string;
+  endpoint?: DeploymentEndpoint$Outbound | null | undefined;
+  engine: string;
+  id: string;
   image: string | null;
+  model: string;
+  name: string;
   revision: number;
-  created_at: string;
+  scaling: Scaling$Outbound;
+  served_model_id?: string | null | undefined;
+  status: string;
   updated_at: string;
 };
 
@@ -128,21 +144,23 @@ export const Deployment$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   Deployment
 > = z.object({
-  id: z.string(),
-  name: z.string(),
-  status: DeploymentStatus$outboundSchema,
-  url: z.nullable(z.string()).optional(),
-  model: z.string(),
-  engine: Engine$outboundSchema,
   accelerator: AcceleratorSpec$outboundSchema,
-  scaling: Scaling$outboundSchema,
+  createdAt: z.date().transform(v => v.toISOString()),
+  endpoint: z.nullable(DeploymentEndpoint$outboundSchema).optional(),
+  engine: Engine$outboundSchema,
+  id: z.string(),
   image: z.nullable(z.string()),
+  model: z.string(),
+  name: z.string(),
   revision: z.number().int(),
-  createdAt: z.date().transform(v => v.toISOString()),
+  scaling: Scaling$outboundSchema,
+  servedModelId: z.nullable(z.string()).optional(),
+  status: DeploymentStatus$outboundSchema,
   updatedAt: z.date().transform(v => v.toISOString()),
 }).transform((v) => {
   return remap$(v, {
     createdAt: "created_at",
+    servedModelId: "served_model_id",
     updatedAt: "updated_at",
   });
 });

package/src/models/components/deploymentcreate.ts

@@ -34,12 +34,6 @@ import {
  * Spin up an inference server.
  */
 export type DeploymentCreate = {
-  name: string;
-  model: string;
-  /**
-   * Inference engine that backs a deployment.
-   */
-  engine?: Engine | undefined;
   /**
    * A hardware accelerator request — GPU, NPU, TPU, or similar.
    *
@@ -49,30 +43,42 @@ export type DeploymentCreate = {
    */
   accelerator: AcceleratorSpec;
   /**
-   * Autoscaling configuration for a deployment.
+   * Require an endpoint key (separate from the model's own API key)
    */
-  scaling?: Scaling | undefined;
+  endpointAuth?: boolean | undefined;
+  /**
+   * Inference engine that backs a deployment.
+   */
+  engine?: Engine | undefined;
+  /**
+   * Extra flags passed to the engine launch command
+   */
+  engineArgs?: Array<string> | undefined;
   /**
    * Name/ID of a built image; defaults to the engine's stock image
    */
   image?: string | null | undefined;
   /**
-   * Volume mounted for cached weights
+   * ID of a registered model (see Serving Models)
    */
-  volume?: string | null | undefined;
-  secrets?: Array<string> | undefined;
+  model: string;
   /**
-   * Extra flags passed to the engine launch command
+   * Unique within your organization; becomes the served model ID consumers use at the gateway's inference endpoints
    */
-  engineArgs?: Array<string> | undefined;
+  name: string;
   /**
-   * Require an endpoint key (separate from the model's own API key)
+   * Autoscaling configuration for a deployment.
    */
-  endpointAuth?: boolean | undefined;
+  scaling?: Scaling | undefined;
+  secrets?: Array<string> | undefined;
   /**
    * How a config change or rollback is rolled out.
    */
   strategy?: DeployStrategy | undefined;
+  /**
+   * Volume mounted for cached weights
+   */
+  volume?: string | null | undefined;
 };
 
 /** @internal */
@@ -81,36 +87,36 @@ export const DeploymentCreate$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  name: z.string(),
-  model: z.string(),
-  engine: Engine$inboundSchema.optional(),
   accelerator: AcceleratorSpec$inboundSchema,
-  scaling: Scaling$inboundSchema.optional(),
+  endpoint_auth: z.boolean().default(true),
+  engine: Engine$inboundSchema.optional(),
+  engine_args: z.array(z.string()).optional(),
   image: z.nullable(z.string()).optional(),
-  volume: z.nullable(z.string()).optional(),
+  model: z.string(),
+  name: z.string(),
+  scaling: Scaling$inboundSchema.optional(),
   secrets: z.array(z.string()).optional(),
-  engine_args: z.array(z.string()).optional(),
-  endpoint_auth: z.boolean().default(true),
   strategy: DeployStrategy$inboundSchema.optional(),
+  volume: z.nullable(z.string()).optional(),
 }).transform((v) => {
   return remap$(v, {
-    "engine_args": "engineArgs",
     "endpoint_auth": "endpointAuth",
+    "engine_args": "engineArgs",
   });
 });
 /** @internal */
 export type DeploymentCreate$Outbound = {
-  name: string;
-  model: string;
-  engine?: string | undefined;
   accelerator: AcceleratorSpec$Outbound;
-  scaling?: Scaling$Outbound | undefined;
+  endpoint_auth: boolean;
+  engine?: string | undefined;
+  engine_args?: Array<string> | undefined;
   image?: string | null | undefined;
-  volume?: string | null | undefined;
+  model: string;
+  name: string;
+  scaling?: Scaling$Outbound | undefined;
   secrets?: Array<string> | undefined;
-  engine_args?: Array<string> | undefined;
-  endpoint_auth: boolean;
   strategy?: string | undefined;
+  volume?: string | null | undefined;
 };
 
 /** @internal */
@@ -119,21 +125,21 @@ export const DeploymentCreate$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   DeploymentCreate
 > = z.object({
-  name: z.string(),
-  model: z.string(),
-  engine: Engine$outboundSchema.optional(),
   accelerator: AcceleratorSpec$outboundSchema,
-  scaling: Scaling$outboundSchema.optional(),
+  endpointAuth: z.boolean().default(true),
+  engine: Engine$outboundSchema.optional(),
+  engineArgs: z.array(z.string()).optional(),
   image: z.nullable(z.string()).optional(),
-  volume: z.nullable(z.string()).optional(),
+  model: z.string(),
+  name: z.string(),
+  scaling: Scaling$outboundSchema.optional(),
   secrets: z.array(z.string()).optional(),
-  engineArgs: z.array(z.string()).optional(),
-  endpointAuth: z.boolean().default(true),
   strategy: DeployStrategy$outboundSchema.optional(),
+  volume: z.nullable(z.string()).optional(),
 }).transform((v) => {
   return remap$(v, {
-    engineArgs: "engine_args",
     endpointAuth: "endpoint_auth",
+    engineArgs: "engine_args",
   });
 });
 

package/src/models/components/deploymentendpoint.ts

@@ -0,0 +1,82 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * How consumers reach the deployed model.
+ *
+ * @remarks
+ *
+ * Inference always flows through the MKA1 LLM gateway: the deployment registers
+ * its model there, and callers use their normal MKA1 API key. Provider URLs and
+ * credentials never leave the control plane.
+ */
+export type DeploymentEndpoint = {
+  /**
+   * Gateway base URL to send inference requests to
+   */
+  baseUrl: string;
+  openaiCompatible?: boolean | undefined;
+  via?: "gateway" | undefined;
+};
+
+/** @internal */
+export const DeploymentEndpoint$inboundSchema: z.ZodType<
+  DeploymentEndpoint,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  base_url: z.string(),
+  openai_compatible: z.boolean().default(true),
+  via: z.literal("gateway").default("gateway"),
+}).transform((v) => {
+  return remap$(v, {
+    "base_url": "baseUrl",
+    "openai_compatible": "openaiCompatible",
+  });
+});
+/** @internal */
+export type DeploymentEndpoint$Outbound = {
+  base_url: string;
+  openai_compatible: boolean;
+  via: "gateway";
+};
+
+/** @internal */
+export const DeploymentEndpoint$outboundSchema: z.ZodType<
+  DeploymentEndpoint$Outbound,
+  z.ZodTypeDef,
+  DeploymentEndpoint
+> = z.object({
+  baseUrl: z.string(),
+  openaiCompatible: z.boolean().default(true),
+  via: z.literal("gateway").default("gateway" as const),
+}).transform((v) => {
+  return remap$(v, {
+    baseUrl: "base_url",
+    openaiCompatible: "openai_compatible",
+  });
+});
+
+export function deploymentEndpointToJSON(
+  deploymentEndpoint: DeploymentEndpoint,
+): string {
+  return JSON.stringify(
+    DeploymentEndpoint$outboundSchema.parse(deploymentEndpoint),
+  );
+}
+export function deploymentEndpointFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentEndpoint, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentEndpoint$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentEndpoint' from JSON`,
+  );
+}

package/src/models/components/deploymentupdate.ts

@@ -17,10 +17,10 @@ import {
  * Patch a deployment's config. Triggers a new revision (rolling by default).
  */
 export type DeploymentUpdate = {
-  model?: string | null | undefined;
+  engineArgs?: Array<string> | null | undefined;
   image?: string | null | undefined;
+  model?: string | null | undefined;
   secrets?: Array<string> | null | undefined;
-  engineArgs?: Array<string> | null | undefined;
   /**
    * How a config change or rollback is rolled out.
    */
@@ -33,10 +33,10 @@ export const DeploymentUpdate$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  model: z.nullable(z.string()).optional(),
+  engine_args: z.nullable(z.array(z.string())).optional(),
   image: z.nullable(z.string()).optional(),
+  model: z.nullable(z.string()).optional(),
   secrets: z.nullable(z.array(z.string())).optional(),
-  engine_args: z.nullable(z.array(z.string())).optional(),
   strategy: DeployStrategy$inboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
@@ -45,10 +45,10 @@ export const DeploymentUpdate$inboundSchema: z.ZodType<
 });
 /** @internal */
 export type DeploymentUpdate$Outbound = {
-  model?: string | null | undefined;
+  engine_args?: Array<string> | null | undefined;
   image?: string | null | undefined;
+  model?: string | null | undefined;
   secrets?: Array<string> | null | undefined;
-  engine_args?: Array<string> | null | undefined;
   strategy?: string | undefined;
 };
 
@@ -58,10 +58,10 @@ export const DeploymentUpdate$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   DeploymentUpdate
 > = z.object({
-  model: z.nullable(z.string()).optional(),
+  engineArgs: z.nullable(z.array(z.string())).optional(),
   image: z.nullable(z.string()).optional(),
+  model: z.nullable(z.string()).optional(),
   secrets: z.nullable(z.array(z.string())).optional(),
-  engineArgs: z.nullable(z.array(z.string())).optional(),
   strategy: DeployStrategy$outboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {

package/src/models/components/finetunejob.ts

@@ -22,18 +22,30 @@ export type FinetuneJobStatus = ClosedEnum<typeof FinetuneJobStatus>;
  * A fine-tune job.
  */
 export type FinetuneJob = {
-  id: string;
-  name: string;
-  status: FinetuneJobStatus;
   baseModel: string;
+  checkpoints?: Array<string> | undefined;
+  createdAt: Date;
+  finishedAt?: Date | null | undefined;
+  /**
+   * Checkpoint this job warm-started from, if any
+   */
+  fromCheckpoint?: string | null | undefined;
+  id: string;
   method: string;
+  name: string;
+  /**
+   * ID of the model registered from this job's output weights on success (see Serving Models); pass it to Create Deployment to serve
+   */
+  outputModel?: string | null | undefined;
+  /**
+   * Job whose checkpoint this job warm-started from (derived from from_checkpoint); jobs may share a parent, so lineage forms a tree
+   */
+  parentJobId?: string | null | undefined;
   /**
    * 0.0–1.0 if known
    */
   progress?: number | null | undefined;
-  checkpoints?: Array<string> | undefined;
-  createdAt: Date;
-  finishedAt?: Date | null | undefined;
+  status: FinetuneJobStatus;
 };
 
 /** @internal */
@@ -51,35 +63,44 @@ export const FinetuneJob$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.string(),
-  name: z.string(),
-  status: FinetuneJobStatus$inboundSchema,
   base_model: z.string(),
-  method: z.string(),
-  progress: z.nullable(z.number()).optional(),
   checkpoints: z.array(z.string()).optional(),
   created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
   finished_at: z.nullable(
     z.string().datetime({ offset: true }).transform(v => new Date(v)),
   ).optional(),
+  from_checkpoint: z.nullable(z.string()).optional(),
+  id: z.string(),
+  method: z.string(),
+  name: z.string(),
+  output_model: z.nullable(z.string()).optional(),
+  parent_job_id: z.nullable(z.string()).optional(),
+  progress: z.nullable(z.number()).optional(),
+  status: FinetuneJobStatus$inboundSchema,
 }).transform((v) => {
   return remap$(v, {
     "base_model": "baseModel",
     "created_at": "createdAt",
     "finished_at": "finishedAt",
+    "from_checkpoint": "fromCheckpoint",
+    "output_model": "outputModel",
+    "parent_job_id": "parentJobId",
   });
 });
 /** @internal */
 export type FinetuneJob$Outbound = {
-  id: string;
-  name: string;
-  status: string;
   base_model: string;
-  method: string;
-  progress?: number | null | undefined;
   checkpoints?: Array<string> | undefined;
   created_at: string;
   finished_at?: string | null | undefined;
+  from_checkpoint?: string | null | undefined;
+  id: string;
+  method: string;
+  name: string;
+  output_model?: string | null | undefined;
+  parent_job_id?: string | null | undefined;
+  progress?: number | null | undefined;
+  status: string;
 };
 
 /** @internal */
@@ -88,20 +109,26 @@ export const FinetuneJob$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   FinetuneJob
 > = z.object({
-  id: z.string(),
-  name: z.string(),
-  status: FinetuneJobStatus$outboundSchema,
   baseModel: z.string(),
-  method: z.string(),
-  progress: z.nullable(z.number()).optional(),
   checkpoints: z.array(z.string()).optional(),
   createdAt: z.date().transform(v => v.toISOString()),
   finishedAt: z.nullable(z.date().transform(v => v.toISOString())).optional(),
+  fromCheckpoint: z.nullable(z.string()).optional(),
+  id: z.string(),
+  method: z.string(),
+  name: z.string(),
+  outputModel: z.nullable(z.string()).optional(),
+  parentJobId: z.nullable(z.string()).optional(),
+  progress: z.nullable(z.number()).optional(),
+  status: FinetuneJobStatus$outboundSchema,
 }).transform((v) => {
   return remap$(v, {
     baseModel: "base_model",
     createdAt: "created_at",
     finishedAt: "finished_at",
+    fromCheckpoint: "from_checkpoint",
+    outputModel: "output_model",
+    parentJobId: "parent_job_id",
   });
 });
 

package/src/models/components/finetunejobcreate.ts

@@ -28,13 +28,6 @@ export type FinetuneJobCreateMethod = ClosedEnum<
  * Submit a fine-tune.
  */
 export type FinetuneJobCreate = {
-  name: string;
-  baseModel: string;
-  method?: FinetuneJobCreateMethod | undefined;
-  /**
-   * Volume path or Hugging Face dataset id
-   */
-  dataset: string;
   /**
    * A hardware accelerator request — GPU, NPU, TPU, or similar.
    *
@@ -44,15 +37,29 @@ export type FinetuneJobCreate = {
    */
   accelerator: AcceleratorSpec;
   /**
-   * Volume where checkpoints are written
+   * Required unless from_checkpoint is set (then inherited from the checkpoint's parent job; supplying a contradicting value is rejected)
    */
-  outputVolume: string;
+  baseModel?: string | null | undefined;
+  /**
+   * Volume path or Hugging Face dataset id
+   */
+  dataset: string;
+  /**
+   * Checkpoint to warm-start from: a checkpoint ID (see List output checkpoints) or a volume path. base_model and method are inherited from the checkpoint's parent job — supplying contradicting values is rejected. Hyperparameters may be overridden freely. The new job writes checkpoints under its own prefix and records parent_job_id for lineage.
+   */
+  fromCheckpoint?: string | null | undefined;
+  hyperparameters?: { [k: string]: any } | undefined;
   /**
    * Name/ID of a built image; defaults to a stock trainer
    */
   image?: string | null | undefined;
+  method?: FinetuneJobCreateMethod | undefined;
+  name: string;
+  /**
+   * Volume where checkpoints are written
+   */
+  outputVolume: string;
   secrets?: Array<string> | undefined;
-  hyperparameters?: { [k: string]: any } | undefined;
 };
 
 /** @internal */
@@ -70,32 +77,35 @@ export const FinetuneJobCreate$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  name: z.string(),
-  base_model: z.string(),
-  method: FinetuneJobCreateMethod$inboundSchema.default("lora"),
-  dataset: z.string(),
   accelerator: AcceleratorSpec$inboundSchema,
-  output_volume: z.string(),
+  base_model: z.nullable(z.string()).optional(),
+  dataset: z.string(),
+  from_checkpoint: z.nullable(z.string()).optional(),
+  hyperparameters: z.record(z.any()).optional(),
   image: z.nullable(z.string()).optional(),
+  method: FinetuneJobCreateMethod$inboundSchema.default("lora"),
+  name: z.string(),
+  output_volume: z.string(),
   secrets: z.array(z.string()).optional(),
-  hyperparameters: z.record(z.any()).optional(),
 }).transform((v) => {
   return remap$(v, {
     "base_model": "baseModel",
+    "from_checkpoint": "fromCheckpoint",
     "output_volume": "outputVolume",
   });
 });
 /** @internal */
 export type FinetuneJobCreate$Outbound = {
-  name: string;
-  base_model: string;
-  method: string;
-  dataset: string;
   accelerator: AcceleratorSpec$Outbound;
-  output_volume: string;
+  base_model?: string | null | undefined;
+  dataset: string;
+  from_checkpoint?: string | null | undefined;
+  hyperparameters?: { [k: string]: any } | undefined;
   image?: string | null | undefined;
+  method: string;
+  name: string;
+  output_volume: string;
   secrets?: Array<string> | undefined;
-  hyperparameters?: { [k: string]: any } | undefined;
 };
 
 /** @internal */
@@ -104,18 +114,20 @@ export const FinetuneJobCreate$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   FinetuneJobCreate
 > = z.object({
-  name: z.string(),
-  baseModel: z.string(),
-  method: FinetuneJobCreateMethod$outboundSchema.default("lora"),
-  dataset: z.string(),
   accelerator: AcceleratorSpec$outboundSchema,
-  outputVolume: z.string(),
+  baseModel: z.nullable(z.string()).optional(),
+  dataset: z.string(),
+  fromCheckpoint: z.nullable(z.string()).optional(),
+  hyperparameters: z.record(z.any()).optional(),
   image: z.nullable(z.string()).optional(),
+  method: FinetuneJobCreateMethod$outboundSchema.default("lora"),
+  name: z.string(),
+  outputVolume: z.string(),
   secrets: z.array(z.string()).optional(),
-  hyperparameters: z.record(z.any()).optional(),
 }).transform((v) => {
   return remap$(v, {
     baseModel: "base_model",
+    fromCheckpoint: "from_checkpoint",
     outputVolume: "output_volume",
   });
 });