@meetkai/mka1 0.51.23 → 0.51.25

package/src/models/components/pagerun.ts

@@ -0,0 +1,73 @@
+/*
+ * 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";
+import {
+  Run,
+  Run$inboundSchema,
+  Run$Outbound,
+  Run$outboundSchema,
+} from "./run.js";
+
+export type PageRun = {
+  data: Array<Run>;
+  /**
+   * Opaque cursor for the next page; null when there are no further items.
+   */
+  nextCursor: string | null;
+  /**
+   * Total number of items, or null when counting is expensive.
+   */
+  total: number | null;
+};
+
+/** @internal */
+export const PageRun$inboundSchema: z.ZodType<PageRun, z.ZodTypeDef, unknown> =
+  z.object({
+    data: z.array(Run$inboundSchema),
+    next_cursor: z.nullable(z.string()),
+    total: z.nullable(z.number().int()),
+  }).transform((v) => {
+    return remap$(v, {
+      "next_cursor": "nextCursor",
+    });
+  });
+/** @internal */
+export type PageRun$Outbound = {
+  data: Array<Run$Outbound>;
+  next_cursor: string | null;
+  total: number | null;
+};
+
+/** @internal */
+export const PageRun$outboundSchema: z.ZodType<
+  PageRun$Outbound,
+  z.ZodTypeDef,
+  PageRun
+> = z.object({
+  data: z.array(Run$outboundSchema),
+  nextCursor: z.nullable(z.string()),
+  total: z.nullable(z.number().int()),
+}).transform((v) => {
+  return remap$(v, {
+    nextCursor: "next_cursor",
+  });
+});
+
+export function pageRunToJSON(pageRun: PageRun): string {
+  return JSON.stringify(PageRun$outboundSchema.parse(pageRun));
+}
+export function pageRunFromJSON(
+  jsonString: string,
+): SafeParseResult<PageRun, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PageRun$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PageRun' from JSON`,
+  );
+}

package/src/models/components/run.ts

@@ -0,0 +1,193 @@
+/*
+ * 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 { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  RunSSH,
+  RunSSH$inboundSchema,
+  RunSSH$Outbound,
+  RunSSH$outboundSchema,
+} from "./runssh.js";
+
+/**
+ * What the run is for. A fine-tune ends on its own and its exit code is the outcome; a deployment serves traffic and runs until it is deleted. They are one resource because they are one pod, one provider and one script — the kind selects terminal semantics, not a different machine.
+ */
+export const RunKind = {
+  Finetune: "finetune",
+  Deployment: "deployment",
+} as const;
+/**
+ * What the run is for. A fine-tune ends on its own and its exit code is the outcome; a deployment serves traffic and runs until it is deleted. They are one resource because they are one pod, one provider and one script — the kind selects terminal semantics, not a different machine.
+ */
+export type RunKind = ClosedEnum<typeof RunKind>;
+
+export const State = {
+  Requested: "requested",
+  Provisioning: "provisioning",
+  Running: "running",
+  Succeeded: "succeeded",
+  Failed: "failed",
+  Terminated: "terminated",
+} as const;
+export type State = ClosedEnum<typeof State>;
+
+export type Run = {
+  accelerator?: string | undefined;
+  createdAt: Date;
+  deadlineAt?: Date | undefined;
+  /**
+   * Where the workload serves, once it is running. Only a deployment declares ports, so only a deployment reports an endpoint.
+   */
+  endpoint?: string | undefined;
+  /**
+   * The workload's exit status. Provider status is not trusted for this: one provider reports the VM rather than the container.
+   */
+  exitCode?: number | undefined;
+  gpuCount?: number | undefined;
+  id: string;
+  image?: string | undefined;
+  /**
+   * What the run is for. A fine-tune ends on its own and its exit code is the outcome; a deployment serves traffic and runs until it is deleted. They are one resource because they are one pod, one provider and one script — the kind selects terminal semantics, not a different machine.
+   */
+  kind: RunKind;
+  name?: string | undefined;
+  priceUsdHr?: number | undefined;
+  provider?: string | undefined;
+  /**
+   * Why the run is in this state, e.g. ssh_setup_failed or budget_exhausted.
+   */
+  reason?: string | undefined;
+  /**
+   * Connection details. The login user is provider dependent and is read from the provider, never assumed.
+   */
+  ssh?: RunSSH | undefined;
+  startedAt?: Date | undefined;
+  state: State;
+  terminalAt?: Date | undefined;
+};
+
+/** @internal */
+export const RunKind$inboundSchema: z.ZodNativeEnum<typeof RunKind> = z
+  .nativeEnum(RunKind);
+/** @internal */
+export const RunKind$outboundSchema: z.ZodNativeEnum<typeof RunKind> =
+  RunKind$inboundSchema;
+
+/** @internal */
+export const State$inboundSchema: z.ZodNativeEnum<typeof State> = z.nativeEnum(
+  State,
+);
+/** @internal */
+export const State$outboundSchema: z.ZodNativeEnum<typeof State> =
+  State$inboundSchema;
+
+/** @internal */
+export const Run$inboundSchema: z.ZodType<Run, z.ZodTypeDef, unknown> = z
+  .object({
+    accelerator: z.string().optional(),
+    created_at: z.string().datetime({ offset: true }).transform(v =>
+      new Date(v)
+    ),
+    deadline_at: z.string().datetime({ offset: true }).transform(v =>
+      new Date(v)
+    ).optional(),
+    endpoint: z.string().optional(),
+    exit_code: z.number().int().optional(),
+    gpu_count: z.number().int().optional(),
+    id: z.string(),
+    image: z.string().optional(),
+    kind: RunKind$inboundSchema,
+    name: z.string().optional(),
+    price_usd_hr: z.number().optional(),
+    provider: z.string().optional(),
+    reason: z.string().optional(),
+    ssh: RunSSH$inboundSchema.optional(),
+    started_at: z.string().datetime({ offset: true }).transform(v =>
+      new Date(v)
+    ).optional(),
+    state: State$inboundSchema,
+    terminal_at: z.string().datetime({ offset: true }).transform(v =>
+      new Date(v)
+    ).optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      "created_at": "createdAt",
+      "deadline_at": "deadlineAt",
+      "exit_code": "exitCode",
+      "gpu_count": "gpuCount",
+      "price_usd_hr": "priceUsdHr",
+      "started_at": "startedAt",
+      "terminal_at": "terminalAt",
+    });
+  });
+/** @internal */
+export type Run$Outbound = {
+  accelerator?: string | undefined;
+  created_at: string;
+  deadline_at?: string | undefined;
+  endpoint?: string | undefined;
+  exit_code?: number | undefined;
+  gpu_count?: number | undefined;
+  id: string;
+  image?: string | undefined;
+  kind: string;
+  name?: string | undefined;
+  price_usd_hr?: number | undefined;
+  provider?: string | undefined;
+  reason?: string | undefined;
+  ssh?: RunSSH$Outbound | undefined;
+  started_at?: string | undefined;
+  state: string;
+  terminal_at?: string | undefined;
+};
+
+/** @internal */
+export const Run$outboundSchema: z.ZodType<Run$Outbound, z.ZodTypeDef, Run> = z
+  .object({
+    accelerator: z.string().optional(),
+    createdAt: z.date().transform(v => v.toISOString()),
+    deadlineAt: z.date().transform(v => v.toISOString()).optional(),
+    endpoint: z.string().optional(),
+    exitCode: z.number().int().optional(),
+    gpuCount: z.number().int().optional(),
+    id: z.string(),
+    image: z.string().optional(),
+    kind: RunKind$outboundSchema,
+    name: z.string().optional(),
+    priceUsdHr: z.number().optional(),
+    provider: z.string().optional(),
+    reason: z.string().optional(),
+    ssh: RunSSH$outboundSchema.optional(),
+    startedAt: z.date().transform(v => v.toISOString()).optional(),
+    state: State$outboundSchema,
+    terminalAt: z.date().transform(v => v.toISOString()).optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      createdAt: "created_at",
+      deadlineAt: "deadline_at",
+      exitCode: "exit_code",
+      gpuCount: "gpu_count",
+      priceUsdHr: "price_usd_hr",
+      startedAt: "started_at",
+      terminalAt: "terminal_at",
+    });
+  });
+
+export function runToJSON(run: Run): string {
+  return JSON.stringify(Run$outboundSchema.parse(run));
+}
+export function runFromJSON(
+  jsonString: string,
+): SafeParseResult<Run, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Run$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Run' from JSON`,
+  );
+}

package/src/models/components/{deploymentcreate.ts → runcreate.ts}

@@ -5,6 +5,7 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
@@ -14,7 +15,19 @@ import {
   RunDeadline$outboundSchema,
 } from "./rundeadline.js";
 
-export type DeploymentCreate = {
+/**
+ * What the run is for. A fine-tune ends on its own and its exit code is the outcome; a deployment serves traffic and runs until it is deleted. They are one resource because they are one pod, one provider and one script — the kind selects terminal semantics, not a different machine.
+ */
+export const RunCreateKind = {
+  Finetune: "finetune",
+  Deployment: "deployment",
+} as const;
+/**
+ * What the run is for. A fine-tune ends on its own and its exit code is the outcome; a deployment serves traffic and runs until it is deleted. They are one resource because they are one pod, one provider and one script — the kind selects terminal semantics, not a different machine.
+ */
+export type RunCreateKind = ClosedEnum<typeof RunCreateKind>;
+
+export type RunCreate = {
   /**
    * Curated accelerator name. GET /accelerators lists what is available.
    */
@@ -43,9 +56,13 @@ export type DeploymentCreate = {
    * Optional filter on intra-node topology, e.g. nvlink. Tensor-parallel work is materially slower over PCIe.
    */
   interconnect?: string | undefined;
+  /**
+   * What the run is for. A fine-tune ends on its own and its exit code is the outcome; a deployment serves traffic and runs until it is deleted. They are one resource because they are one pod, one provider and one script — the kind selects terminal semantics, not a different machine.
+   */
+  kind: RunCreateKind;
   name?: string | undefined;
   /**
-   * Provider-neutral port declarations such as "8000/http". They must be right at create time: RunPod cannot change them later without resetting and wiping the pod.
+   * Container ports to expose, e.g. "8000/http". Meaningful for a deployment, which serves traffic; a fine-tune has nothing to expose.
    */
   ports?: Array<string> | undefined;
   /**
@@ -67,8 +84,17 @@ export type DeploymentCreate = {
 };
 
 /** @internal */
-export const DeploymentCreate$inboundSchema: z.ZodType<
-  DeploymentCreate,
+export const RunCreateKind$inboundSchema: z.ZodNativeEnum<
+  typeof RunCreateKind
+> = z.nativeEnum(RunCreateKind);
+/** @internal */
+export const RunCreateKind$outboundSchema: z.ZodNativeEnum<
+  typeof RunCreateKind
+> = RunCreateKind$inboundSchema;
+
+/** @internal */
+export const RunCreate$inboundSchema: z.ZodType<
+  RunCreate,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -79,6 +105,7 @@ export const DeploymentCreate$inboundSchema: z.ZodType<
   gpu_count: z.number().int(),
   image: z.string(),
   interconnect: z.string().optional(),
+  kind: RunCreateKind$inboundSchema,
   name: z.string().optional(),
   ports: z.array(z.string()).optional(),
   providers: z.array(z.string()).optional(),
@@ -94,7 +121,7 @@ export const DeploymentCreate$inboundSchema: z.ZodType<
   });
 });
 /** @internal */
-export type DeploymentCreate$Outbound = {
+export type RunCreate$Outbound = {
   accelerator: string;
   deadline: RunDeadline$Outbound;
   disk_gb: number;
@@ -102,6 +129,7 @@ export type DeploymentCreate$Outbound = {
   gpu_count: number;
   image: string;
   interconnect?: string | undefined;
+  kind: string;
   name?: string | undefined;
   ports?: Array<string> | undefined;
   providers?: Array<string> | undefined;
@@ -111,10 +139,10 @@ export type DeploymentCreate$Outbound = {
 };
 
 /** @internal */
-export const DeploymentCreate$outboundSchema: z.ZodType<
-  DeploymentCreate$Outbound,
+export const RunCreate$outboundSchema: z.ZodType<
+  RunCreate$Outbound,
   z.ZodTypeDef,
-  DeploymentCreate
+  RunCreate
 > = z.object({
   accelerator: z.string(),
   deadline: RunDeadline$outboundSchema,
@@ -123,6 +151,7 @@ export const DeploymentCreate$outboundSchema: z.ZodType<
   gpuCount: z.number().int(),
   image: z.string(),
   interconnect: z.string().optional(),
+  kind: RunCreateKind$outboundSchema,
   name: z.string().optional(),
   ports: z.array(z.string()).optional(),
   providers: z.array(z.string()).optional(),
@@ -138,19 +167,15 @@ export const DeploymentCreate$outboundSchema: z.ZodType<
   });
 });
 
-export function deploymentCreateToJSON(
-  deploymentCreate: DeploymentCreate,
-): string {
-  return JSON.stringify(
-    DeploymentCreate$outboundSchema.parse(deploymentCreate),
-  );
+export function runCreateToJSON(runCreate: RunCreate): string {
+  return JSON.stringify(RunCreate$outboundSchema.parse(runCreate));
 }
-export function deploymentCreateFromJSON(
+export function runCreateFromJSON(
   jsonString: string,
-): SafeParseResult<DeploymentCreate, SDKValidationError> {
+): SafeParseResult<RunCreate, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => DeploymentCreate$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'DeploymentCreate' from JSON`,
+    (x) => RunCreate$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RunCreate' from JSON`,
   );
 }

package/src/models/components/runssh.ts

@@ -11,6 +11,10 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
  * Connection details. The login user is provider dependent and is read from the provider, never assumed.
  */
 export type RunSSH = {
+  /**
+   * Ready-to-use SSH invocation. Assembled here because the login user is provider dependent — it is read from the provider, never assumed — and rebuilding it by hand is where callers get it wrong.
+   */
+  command: string;
   host: string;
   port: number;
   user: string;
@@ -19,12 +23,14 @@ export type RunSSH = {
 /** @internal */
 export const RunSSH$inboundSchema: z.ZodType<RunSSH, z.ZodTypeDef, unknown> = z
   .object({
+    command: z.string(),
     host: z.string(),
     port: z.number().int(),
     user: z.string(),
   });
 /** @internal */
 export type RunSSH$Outbound = {
+  command: string;
   host: string;
   port: number;
   user: string;
@@ -36,6 +42,7 @@ export const RunSSH$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   RunSSH
 > = z.object({
+  command: z.string(),
   host: z.string(),
   port: z.number().int(),
   user: z.string(),

package/src/models/components/servingtenant.ts

@@ -16,6 +16,14 @@ export type ServingTenant = {
   enabled: boolean;
   enabledAt: Date | null;
   enabledBy: string | null;
+  /**
+   * Maximum simultaneously live deployments for this organization. A deployment runs until it is deleted, so this is a standing limit. 0 blocks all serving.
+   */
+  maxDeployments: number;
+  /**
+   * Maximum simultaneously live fine-tune runs for this organization. A run counts until it reaches a terminal state. 0 blocks all fine-tuning.
+   */
+  maxFinetuneJobs: number;
   orgId: string;
 };
 
@@ -33,12 +41,16 @@ export const ServingTenant$inboundSchema: z.ZodType<
     z.string().datetime({ offset: true }).transform(v => new Date(v)),
   ),
   enabled_by: z.nullable(z.string()),
+  max_deployments: z.number().int(),
+  max_finetune_jobs: z.number().int(),
   org_id: z.string(),
 }).transform((v) => {
   return remap$(v, {
     "disabled_at": "disabledAt",
     "enabled_at": "enabledAt",
     "enabled_by": "enabledBy",
+    "max_deployments": "maxDeployments",
+    "max_finetune_jobs": "maxFinetuneJobs",
     "org_id": "orgId",
   });
 });
@@ -48,6 +60,8 @@ export type ServingTenant$Outbound = {
   enabled: boolean;
   enabled_at: string | null;
   enabled_by: string | null;
+  max_deployments: number;
+  max_finetune_jobs: number;
   org_id: string;
 };
 
@@ -61,12 +75,16 @@ export const ServingTenant$outboundSchema: z.ZodType<
   enabled: z.boolean(),
   enabledAt: z.nullable(z.date().transform(v => v.toISOString())),
   enabledBy: z.nullable(z.string()),
+  maxDeployments: z.number().int(),
+  maxFinetuneJobs: z.number().int(),
   orgId: z.string(),
 }).transform((v) => {
   return remap$(v, {
     disabledAt: "disabled_at",
     enabledAt: "enabled_at",
     enabledBy: "enabled_by",
+    maxDeployments: "max_deployments",
+    maxFinetuneJobs: "max_finetune_jobs",
     orgId: "org_id",
   });
 });

package/src/models/components/servingtenantset.ts

@@ -3,15 +3,24 @@
  */
 
 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";
 
 /**
- * Desired organization-wide serving state.
+ * Desired organization-wide serving state. Quotas are optional: omitting one leaves it unchanged, so toggling enablement never resets a raised limit.
  */
 export type ServingTenantSet = {
   enabled: boolean;
+  /**
+   * Maximum simultaneously live deployments for this organization. A deployment runs until it is deleted, so this is a standing limit. 0 blocks all serving.
+   */
+  maxDeployments?: number | null | undefined;
+  /**
+   * Maximum simultaneously live fine-tune runs for this organization. A run counts until it reaches a terminal state. 0 blocks all fine-tuning.
+   */
+  maxFinetuneJobs?: number | null | undefined;
 };
 
 /** @internal */
@@ -21,10 +30,19 @@ export const ServingTenantSet$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   enabled: z.boolean(),
+  max_deployments: z.nullable(z.number().int()).optional(),
+  max_finetune_jobs: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "max_deployments": "maxDeployments",
+    "max_finetune_jobs": "maxFinetuneJobs",
+  });
 });
 /** @internal */
 export type ServingTenantSet$Outbound = {
   enabled: boolean;
+  max_deployments?: number | null | undefined;
+  max_finetune_jobs?: number | null | undefined;
 };
 
 /** @internal */
@@ -34,6 +52,13 @@ export const ServingTenantSet$outboundSchema: z.ZodType<
   ServingTenantSet
 > = z.object({
   enabled: z.boolean(),
+  maxDeployments: z.nullable(z.number().int()).optional(),
+  maxFinetuneJobs: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    maxDeployments: "max_deployments",
+    maxFinetuneJobs: "max_finetune_jobs",
+  });
 });
 
 export function servingTenantSetToJSON(

package/src/models/operations/{createdeployment.ts → createservingrun.ts}

@@ -9,62 +9,62 @@ import { Result as SafeParseResult } from "../../types/fp.js";
 import * as components from "../components/index.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
-export type CreateDeploymentRequest = {
+export type CreateServingRunRequest = {
   /**
    * Optional external end-user identifier forwarded by the API gateway.
    */
   xOnBehalfOf?: string | undefined;
-  deploymentCreate: components.DeploymentCreate;
+  runCreate: components.RunCreate;
 };
 
 /** @internal */
-export const CreateDeploymentRequest$inboundSchema: z.ZodType<
-  CreateDeploymentRequest,
+export const CreateServingRunRequest$inboundSchema: z.ZodType<
+  CreateServingRunRequest,
   z.ZodTypeDef,
   unknown
 > = z.object({
   "X-On-Behalf-Of": z.string().optional(),
-  DeploymentCreate: components.DeploymentCreate$inboundSchema,
+  RunCreate: components.RunCreate$inboundSchema,
 }).transform((v) => {
   return remap$(v, {
     "X-On-Behalf-Of": "xOnBehalfOf",
-    "DeploymentCreate": "deploymentCreate",
+    "RunCreate": "runCreate",
   });
 });
 /** @internal */
-export type CreateDeploymentRequest$Outbound = {
+export type CreateServingRunRequest$Outbound = {
   "X-On-Behalf-Of"?: string | undefined;
-  DeploymentCreate: components.DeploymentCreate$Outbound;
+  RunCreate: components.RunCreate$Outbound;
 };
 
 /** @internal */
-export const CreateDeploymentRequest$outboundSchema: z.ZodType<
-  CreateDeploymentRequest$Outbound,
+export const CreateServingRunRequest$outboundSchema: z.ZodType<
+  CreateServingRunRequest$Outbound,
   z.ZodTypeDef,
-  CreateDeploymentRequest
+  CreateServingRunRequest
 > = z.object({
   xOnBehalfOf: z.string().optional(),
-  deploymentCreate: components.DeploymentCreate$outboundSchema,
+  runCreate: components.RunCreate$outboundSchema,
 }).transform((v) => {
   return remap$(v, {
     xOnBehalfOf: "X-On-Behalf-Of",
-    deploymentCreate: "DeploymentCreate",
+    runCreate: "RunCreate",
   });
 });
 
-export function createDeploymentRequestToJSON(
-  createDeploymentRequest: CreateDeploymentRequest,
+export function createServingRunRequestToJSON(
+  createServingRunRequest: CreateServingRunRequest,
 ): string {
   return JSON.stringify(
-    CreateDeploymentRequest$outboundSchema.parse(createDeploymentRequest),
+    CreateServingRunRequest$outboundSchema.parse(createServingRunRequest),
   );
 }
-export function createDeploymentRequestFromJSON(
+export function createServingRunRequestFromJSON(
   jsonString: string,
-): SafeParseResult<CreateDeploymentRequest, SDKValidationError> {
+): SafeParseResult<CreateServingRunRequest, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => CreateDeploymentRequest$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateDeploymentRequest' from JSON`,
+    (x) => CreateServingRunRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateServingRunRequest' from JSON`,
   );
 }