@meetkai/mka1 0.49.16 → 0.49.18

package/src/models/components/acceleratortype.ts

@@ -21,14 +21,14 @@ export type Kind = ClosedEnum<typeof Kind>;
  * An offered accelerator type in the catalog.
  */
 export type AcceleratorType = {
-  name: string;
-  vendor: string;
   kind?: Kind | undefined;
-  memoryGb: number;
   /**
    * Max accelerators of this type per replica
    */
   maxCount: number;
+  memoryGb: number;
+  name: string;
+  vendor: string;
 };
 
 /** @internal */
@@ -45,24 +45,24 @@ export const AcceleratorType$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  name: z.string(),
-  vendor: z.string(),
   kind: Kind$inboundSchema.default("gpu"),
-  memory_gb: z.number().int(),
   max_count: z.number().int(),
+  memory_gb: z.number().int(),
+  name: z.string(),
+  vendor: z.string(),
 }).transform((v) => {
   return remap$(v, {
-    "memory_gb": "memoryGb",
     "max_count": "maxCount",
+    "memory_gb": "memoryGb",
   });
 });
 /** @internal */
 export type AcceleratorType$Outbound = {
-  name: string;
-  vendor: string;
   kind: string;
-  memory_gb: number;
   max_count: number;
+  memory_gb: number;
+  name: string;
+  vendor: string;
 };
 
 /** @internal */
@@ -71,15 +71,15 @@ export const AcceleratorType$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   AcceleratorType
 > = z.object({
-  name: z.string(),
-  vendor: z.string(),
   kind: Kind$outboundSchema.default("gpu"),
-  memoryGb: z.number().int(),
   maxCount: z.number().int(),
+  memoryGb: z.number().int(),
+  name: z.string(),
+  vendor: z.string(),
 }).transform((v) => {
   return remap$(v, {
-    memoryGb: "memory_gb",
     maxCount: "max_count",
+    memoryGb: "memory_gb",
   });
 });
 

package/src/models/components/checkpoint.ts

@@ -12,10 +12,11 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
  * A saved checkpoint/artifact produced by a job.
  */
 export type Checkpoint = {
+  createdAt: Date;
+  id: string;
   path: string;
-  step?: number | null | undefined;
   sizeBytes?: number | null | undefined;
-  createdAt: Date;
+  step?: number | null | undefined;
 };
 
 /** @internal */
@@ -24,22 +25,24 @@ export const Checkpoint$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
+  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  id: z.string(),
   path: z.string(),
-  step: z.nullable(z.number().int()).optional(),
   size_bytes: z.nullable(z.number().int()).optional(),
-  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  step: z.nullable(z.number().int()).optional(),
 }).transform((v) => {
   return remap$(v, {
-    "size_bytes": "sizeBytes",
     "created_at": "createdAt",
+    "size_bytes": "sizeBytes",
   });
 });
 /** @internal */
 export type Checkpoint$Outbound = {
+  created_at: string;
+  id: string;
   path: string;
-  step?: number | null | undefined;
   size_bytes?: number | null | undefined;
-  created_at: string;
+  step?: number | null | undefined;
 };
 
 /** @internal */
@@ -48,14 +51,15 @@ export const Checkpoint$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   Checkpoint
 > = z.object({
+  createdAt: z.date().transform(v => v.toISOString()),
+  id: z.string(),
   path: z.string(),
-  step: z.nullable(z.number().int()).optional(),
   sizeBytes: z.nullable(z.number().int()).optional(),
-  createdAt: z.date().transform(v => v.toISOString()),
+  step: z.nullable(z.number().int()).optional(),
 }).transform((v) => {
   return remap$(v, {
-    sizeBytes: "size_bytes",
     createdAt: "created_at",
+    sizeBytes: "size_bytes",
   });
 });
 

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, {