@meetkai/mka1 0.51.15 → 0.51.17

package/src/models/components/acceleratorhourofdayslot.ts

@@ -0,0 +1,80 @@
+/*
+ * 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";
+
+/**
+ * One slot of the 24-slot hour-of-day availability profile.
+ */
+export type AcceleratorHourOfDaySlot = {
+  /**
+   * Unweighted mean of the window's hourly availability ratios that fall on this hour of day. Meaningless when samples is 0.
+   */
+  availabilityRatio: number;
+  /**
+   * UTC hour of day.
+   */
+  hour: number;
+  /**
+   * Number of window buckets contributing to this slot. 0 means no evidence for this hour of day.
+   */
+  samples: number;
+};
+
+/** @internal */
+export const AcceleratorHourOfDaySlot$inboundSchema: z.ZodType<
+  AcceleratorHourOfDaySlot,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  availability_ratio: z.number(),
+  hour: z.number().int(),
+  samples: z.number().int(),
+}).transform((v) => {
+  return remap$(v, {
+    "availability_ratio": "availabilityRatio",
+  });
+});
+/** @internal */
+export type AcceleratorHourOfDaySlot$Outbound = {
+  availability_ratio: number;
+  hour: number;
+  samples: number;
+};
+
+/** @internal */
+export const AcceleratorHourOfDaySlot$outboundSchema: z.ZodType<
+  AcceleratorHourOfDaySlot$Outbound,
+  z.ZodTypeDef,
+  AcceleratorHourOfDaySlot
+> = z.object({
+  availabilityRatio: z.number(),
+  hour: z.number().int(),
+  samples: z.number().int(),
+}).transform((v) => {
+  return remap$(v, {
+    availabilityRatio: "availability_ratio",
+  });
+});
+
+export function acceleratorHourOfDaySlotToJSON(
+  acceleratorHourOfDaySlot: AcceleratorHourOfDaySlot,
+): string {
+  return JSON.stringify(
+    AcceleratorHourOfDaySlot$outboundSchema.parse(acceleratorHourOfDaySlot),
+  );
+}
+export function acceleratorHourOfDaySlotFromJSON(
+  jsonString: string,
+): SafeParseResult<AcceleratorHourOfDaySlot, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AcceleratorHourOfDaySlot$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AcceleratorHourOfDaySlot' from JSON`,
+  );
+}

package/src/models/components/acceleratorprovideravailability.ts

@@ -0,0 +1,66 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  AcceleratorAvailabilityBucket,
+  AcceleratorAvailabilityBucket$inboundSchema,
+  AcceleratorAvailabilityBucket$Outbound,
+  AcceleratorAvailabilityBucket$outboundSchema,
+} from "./acceleratoravailabilitybucket.js";
+
+/**
+ * Per-provider breakdown of the same buckets. Served only when the cluster does not anonymize providers.
+ */
+export type AcceleratorProviderAvailability = {
+  buckets: Array<AcceleratorAvailabilityBucket>;
+  provider: string;
+};
+
+/** @internal */
+export const AcceleratorProviderAvailability$inboundSchema: z.ZodType<
+  AcceleratorProviderAvailability,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  buckets: z.array(AcceleratorAvailabilityBucket$inboundSchema),
+  provider: z.string(),
+});
+/** @internal */
+export type AcceleratorProviderAvailability$Outbound = {
+  buckets: Array<AcceleratorAvailabilityBucket$Outbound>;
+  provider: string;
+};
+
+/** @internal */
+export const AcceleratorProviderAvailability$outboundSchema: z.ZodType<
+  AcceleratorProviderAvailability$Outbound,
+  z.ZodTypeDef,
+  AcceleratorProviderAvailability
+> = z.object({
+  buckets: z.array(AcceleratorAvailabilityBucket$outboundSchema),
+  provider: z.string(),
+});
+
+export function acceleratorProviderAvailabilityToJSON(
+  acceleratorProviderAvailability: AcceleratorProviderAvailability,
+): string {
+  return JSON.stringify(
+    AcceleratorProviderAvailability$outboundSchema.parse(
+      acceleratorProviderAvailability,
+    ),
+  );
+}
+export function acceleratorProviderAvailabilityFromJSON(
+  jsonString: string,
+): SafeParseResult<AcceleratorProviderAvailability, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AcceleratorProviderAvailability$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AcceleratorProviderAvailability' from JSON`,
+  );
+}

package/src/models/components/acceleratortype.ts

@@ -14,20 +14,54 @@ import {
   AcceleratorPriceBand$Outbound,
   AcceleratorPriceBand$outboundSchema,
 } from "./acceleratorpriceband.js";
+import {
+  AcceleratorWorkloadAffinity,
+  AcceleratorWorkloadAffinity$inboundSchema,
+  AcceleratorWorkloadAffinity$Outbound,
+  AcceleratorWorkloadAffinity$outboundSchema,
+} from "./acceleratorworkloadaffinity.js";
 import {
   Acquirability,
   Acquirability$inboundSchema,
   Acquirability$outboundSchema,
 } from "./acquirability.js";
 
+/**
+ * Coarse accelerator class. npu/tpu are reserved for future catalog entries.
+ */
+export const Class = {
+  Gpu: "gpu",
+  Cpu: "cpu",
+} as const;
+/**
+ * Coarse accelerator class. npu/tpu are reserved for future catalog entries.
+ */
+export type Class = ClosedEnum<typeof Class>;
+
+/**
+ * Deprecated: use class. Retained for SDK compatibility until the next breaking conventions pass.
+ *
+ * @deprecated enum: This will be removed in a future release, please migrate away from it as soon as possible.
+ */
 export const Kind = {
   Gpu: "gpu",
   Npu: "npu",
   Tpu: "tpu",
   Other: "other",
 } as const;
+/**
+ * Deprecated: use class. Retained for SDK compatibility until the next breaking conventions pass.
+ *
+ * @deprecated enum: This will be removed in a future release, please migrate away from it as soon as possible.
+ */
 export type Kind = ClosedEnum<typeof Kind>;
 
+export const Placements = {
+  Internal: "internal",
+  External: "external",
+} as const;
+export type Placements = ClosedEnum<typeof Placements>;
+
 /**
  * An offered accelerator type in the catalog.
  */
@@ -40,24 +74,52 @@ export type AcceleratorType = {
    * Configurations acquirable now (0 when offered is false). Absent when live market data is unavailable.
    */
   acquirableCount?: number | undefined;
+  /**
+   * Coarse accelerator class. npu/tpu are reserved for future catalog entries.
+   */
+  class: Class;
+  /**
+   * Deprecated: use class. Retained for SDK compatibility until the next breaking conventions pass.
+   *
+   * @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
+   */
   kind?: Kind | undefined;
   /**
-   * Max accelerators of this type per replica
+   * Max accelerators of this type per replica. For class cpu the unit is vCPUs: the maximum rentable vCPU count per replica.
    */
   maxCount: number;
-  memoryGb: number;
+  /**
+   * Per-accelerator memory in GB. Absent for class cpu: CPU capacity is sized per request (min_vcpus/min_mem_gb), not by a fixed module.
+   */
+  memoryGb?: number | undefined;
   name: string;
   /**
    * Whether any capacity acquirable right now matches this type. Absent when live market data is unavailable.
    */
   offered?: boolean | undefined;
+  /**
+   * Placements where this accelerator exists. All catalog entries are external (marketplace-acquired) today; internal arrives with private-cluster inventory.
+   */
+  placements: Array<Placements>;
   /**
    * USD-per-hour price band across configurations acquirable now for an accelerator type.
    */
   priceUsdHr?: AcceleratorPriceBand | undefined;
   vendor: string;
+  /**
+   * Per-workload suitability ratings for an accelerator type, seeded from the training hardware matrix.
+   */
+  workloadAffinity: AcceleratorWorkloadAffinity;
 };
 
+/** @internal */
+export const Class$inboundSchema: z.ZodNativeEnum<typeof Class> = z.nativeEnum(
+  Class,
+);
+/** @internal */
+export const Class$outboundSchema: z.ZodNativeEnum<typeof Class> =
+  Class$inboundSchema;
+
 /** @internal */
 export const Kind$inboundSchema: z.ZodNativeEnum<typeof Kind> = z.nativeEnum(
   Kind,
@@ -66,6 +128,13 @@ export const Kind$inboundSchema: z.ZodNativeEnum<typeof Kind> = z.nativeEnum(
 export const Kind$outboundSchema: z.ZodNativeEnum<typeof Kind> =
   Kind$inboundSchema;
 
+/** @internal */
+export const Placements$inboundSchema: z.ZodNativeEnum<typeof Placements> = z
+  .nativeEnum(Placements);
+/** @internal */
+export const Placements$outboundSchema: z.ZodNativeEnum<typeof Placements> =
+  Placements$inboundSchema;
+
 /** @internal */
 export const AcceleratorType$inboundSchema: z.ZodType<
   AcceleratorType,
@@ -74,32 +143,39 @@ export const AcceleratorType$inboundSchema: z.ZodType<
 > = z.object({
   acquirability: Acquirability$inboundSchema.optional(),
   acquirable_count: z.number().int().optional(),
+  class: Class$inboundSchema,
   kind: Kind$inboundSchema.default("gpu"),
   max_count: z.number().int(),
-  memory_gb: z.number().int(),
+  memory_gb: z.number().int().optional(),
   name: z.string(),
   offered: z.boolean().optional(),
+  placements: z.array(Placements$inboundSchema),
   price_usd_hr: AcceleratorPriceBand$inboundSchema.optional(),
   vendor: z.string(),
+  workload_affinity: AcceleratorWorkloadAffinity$inboundSchema,
 }).transform((v) => {
   return remap$(v, {
     "acquirable_count": "acquirableCount",
     "max_count": "maxCount",
     "memory_gb": "memoryGb",
     "price_usd_hr": "priceUsdHr",
+    "workload_affinity": "workloadAffinity",
   });
 });
 /** @internal */
 export type AcceleratorType$Outbound = {
   acquirability?: string | undefined;
   acquirable_count?: number | undefined;
+  class: string;
   kind: string;
   max_count: number;
-  memory_gb: number;
+  memory_gb?: number | undefined;
   name: string;
   offered?: boolean | undefined;
+  placements: Array<string>;
   price_usd_hr?: AcceleratorPriceBand$Outbound | undefined;
   vendor: string;
+  workload_affinity: AcceleratorWorkloadAffinity$Outbound;
 };
 
 /** @internal */
@@ -110,19 +186,23 @@ export const AcceleratorType$outboundSchema: z.ZodType<
 > = z.object({
   acquirability: Acquirability$outboundSchema.optional(),
   acquirableCount: z.number().int().optional(),
+  class: Class$outboundSchema,
   kind: Kind$outboundSchema.default("gpu"),
   maxCount: z.number().int(),
-  memoryGb: z.number().int(),
+  memoryGb: z.number().int().optional(),
   name: z.string(),
   offered: z.boolean().optional(),
+  placements: z.array(Placements$outboundSchema),
   priceUsdHr: AcceleratorPriceBand$outboundSchema.optional(),
   vendor: z.string(),
+  workloadAffinity: AcceleratorWorkloadAffinity$outboundSchema,
 }).transform((v) => {
   return remap$(v, {
     acquirableCount: "acquirable_count",
     maxCount: "max_count",
     memoryGb: "memory_gb",
     priceUsdHr: "price_usd_hr",
+    workloadAffinity: "workload_affinity",
   });
 });
 

package/src/models/components/acceleratorworkloadaffinity.ts

@@ -0,0 +1,71 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  AffinityRating,
+  AffinityRating$inboundSchema,
+  AffinityRating$outboundSchema,
+} from "./affinityrating.js";
+
+/**
+ * Per-workload suitability ratings for an accelerator type, seeded from the training hardware matrix.
+ */
+export type AcceleratorWorkloadAffinity = {
+  /**
+   * How well an accelerator suits a workload class. Catalog data, not a scheduling guarantee.
+   */
+  serving: AffinityRating;
+  /**
+   * How well an accelerator suits a workload class. Catalog data, not a scheduling guarantee.
+   */
+  training: AffinityRating;
+};
+
+/** @internal */
+export const AcceleratorWorkloadAffinity$inboundSchema: z.ZodType<
+  AcceleratorWorkloadAffinity,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  serving: AffinityRating$inboundSchema,
+  training: AffinityRating$inboundSchema,
+});
+/** @internal */
+export type AcceleratorWorkloadAffinity$Outbound = {
+  serving: string;
+  training: string;
+};
+
+/** @internal */
+export const AcceleratorWorkloadAffinity$outboundSchema: z.ZodType<
+  AcceleratorWorkloadAffinity$Outbound,
+  z.ZodTypeDef,
+  AcceleratorWorkloadAffinity
+> = z.object({
+  serving: AffinityRating$outboundSchema,
+  training: AffinityRating$outboundSchema,
+});
+
+export function acceleratorWorkloadAffinityToJSON(
+  acceleratorWorkloadAffinity: AcceleratorWorkloadAffinity,
+): string {
+  return JSON.stringify(
+    AcceleratorWorkloadAffinity$outboundSchema.parse(
+      acceleratorWorkloadAffinity,
+    ),
+  );
+}
+export function acceleratorWorkloadAffinityFromJSON(
+  jsonString: string,
+): SafeParseResult<AcceleratorWorkloadAffinity, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AcceleratorWorkloadAffinity$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AcceleratorWorkloadAffinity' from JSON`,
+  );
+}

package/src/models/components/affinityrating.ts

@@ -0,0 +1,28 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+/**
+ * How well an accelerator suits a workload class. Catalog data, not a scheduling guarantee.
+ */
+export const AffinityRating = {
+  Optimal: "optimal",
+  Capable: "capable",
+  Unsuited: "unsuited",
+} as const;
+/**
+ * How well an accelerator suits a workload class. Catalog data, not a scheduling guarantee.
+ */
+export type AffinityRating = ClosedEnum<typeof AffinityRating>;
+
+/** @internal */
+export const AffinityRating$inboundSchema: z.ZodNativeEnum<
+  typeof AffinityRating
+> = z.nativeEnum(AffinityRating);
+/** @internal */
+export const AffinityRating$outboundSchema: z.ZodNativeEnum<
+  typeof AffinityRating
+> = AffinityRating$inboundSchema;

package/src/models/components/availabilitypriceband.ts

@@ -0,0 +1,62 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * USD-per-hour price band observed within a bucket: exact min/max and the observation-weighted average, merged across anonymous providers. Percentiles are deliberately not served: they are not mergeable across providers from rollups.
+ */
+export type AvailabilityPriceBand = {
+  avg: number;
+  max: number;
+  min: number;
+};
+
+/** @internal */
+export const AvailabilityPriceBand$inboundSchema: z.ZodType<
+  AvailabilityPriceBand,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  avg: z.number(),
+  max: z.number(),
+  min: z.number(),
+});
+/** @internal */
+export type AvailabilityPriceBand$Outbound = {
+  avg: number;
+  max: number;
+  min: number;
+};
+
+/** @internal */
+export const AvailabilityPriceBand$outboundSchema: z.ZodType<
+  AvailabilityPriceBand$Outbound,
+  z.ZodTypeDef,
+  AvailabilityPriceBand
+> = z.object({
+  avg: z.number(),
+  max: z.number(),
+  min: z.number(),
+});
+
+export function availabilityPriceBandToJSON(
+  availabilityPriceBand: AvailabilityPriceBand,
+): string {
+  return JSON.stringify(
+    AvailabilityPriceBand$outboundSchema.parse(availabilityPriceBand),
+  );
+}
+export function availabilityPriceBandFromJSON(
+  jsonString: string,
+): SafeParseResult<AvailabilityPriceBand, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AvailabilityPriceBand$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AvailabilityPriceBand' from JSON`,
+  );
+}

package/src/models/components/deployment.ts

@@ -70,6 +70,14 @@ export type Deployment = {
   image: string | null;
   model: string;
   name: string;
+  /**
+   * Free-vocabulary refinement of status explaining why the current status persists (e.g. `awaiting_scheduler`, `tenant_blocked`, `budget_blocked`, `acquiring_capacity`, `rolling_update`, `draining`). Additive: values may appear, change, or disappear at any time, so clients must render it verbatim and must not switch on it — branch on `status` only. Absent when the status needs no explanation.
+   */
+  phase?: string | null | undefined;
+  /**
+   * Human-readable, provider-neutral sentence expanding on `phase` for direct display. Not stable, not machine-parseable; absent whenever `phase` is absent.
+   */
+  phaseMessage?: string | null | undefined;
   /**
    * Current config revision
    */
@@ -109,6 +117,8 @@ export const Deployment$inboundSchema: z.ZodType<
   image: z.nullable(z.string()),
   model: z.string(),
   name: z.string(),
+  phase: z.nullable(z.string()).optional(),
+  phase_message: z.nullable(z.string()).optional(),
   revision: z.number().int(),
   scaling: Scaling$inboundSchema,
   served_model_id: z.nullable(z.string()).optional(),
@@ -117,6 +127,7 @@ export const Deployment$inboundSchema: z.ZodType<
 }).transform((v) => {
   return remap$(v, {
     "created_at": "createdAt",
+    "phase_message": "phaseMessage",
     "served_model_id": "servedModelId",
     "updated_at": "updatedAt",
   });
@@ -131,6 +142,8 @@ export type Deployment$Outbound = {
   image: string | null;
   model: string;
   name: string;
+  phase?: string | null | undefined;
+  phase_message?: string | null | undefined;
   revision: number;
   scaling: Scaling$Outbound;
   served_model_id?: string | null | undefined;
@@ -152,6 +165,8 @@ export const Deployment$outboundSchema: z.ZodType<
   image: z.nullable(z.string()),
   model: z.string(),
   name: z.string(),
+  phase: z.nullable(z.string()).optional(),
+  phaseMessage: z.nullable(z.string()).optional(),
   revision: z.number().int(),
   scaling: Scaling$outboundSchema,
   servedModelId: z.nullable(z.string()).optional(),
@@ -160,6 +175,7 @@ export const Deployment$outboundSchema: z.ZodType<
 }).transform((v) => {
   return remap$(v, {
     createdAt: "created_at",
+    phaseMessage: "phase_message",
     servedModelId: "served_model_id",
     updatedAt: "updated_at",
   });

package/src/models/components/deploymentacceleratorspec.ts

@@ -11,14 +11,16 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 /**
  * Accelerator class: gpu (default) or cpu. For cpu-only recipes this is inferred; type is not required for cpu.
  */
-export const Class = {
+export const DeploymentAcceleratorSpecClass = {
   Gpu: "gpu",
   Cpu: "cpu",
 } as const;
 /**
  * Accelerator class: gpu (default) or cpu. For cpu-only recipes this is inferred; type is not required for cpu.
  */
-export type Class = ClosedEnum<typeof Class>;
+export type DeploymentAcceleratorSpecClass = ClosedEnum<
+  typeof DeploymentAcceleratorSpecClass
+>;
 
 /**
  * A hardware accelerator request for a deployment — GPU, NPU, TPU, or cpu-class serving.
@@ -31,7 +33,7 @@ export type DeploymentAcceleratorSpec = {
   /**
    * Accelerator class: gpu (default) or cpu. For cpu-only recipes this is inferred; type is not required for cpu.
    */
-  class?: Class | undefined;
+  class?: DeploymentAcceleratorSpecClass | undefined;
   /**
    * Accelerators per replica
    */
@@ -44,12 +46,13 @@ export type DeploymentAcceleratorSpec = {
 };
 
 /** @internal */
-export const Class$inboundSchema: z.ZodNativeEnum<typeof Class> = z.nativeEnum(
-  Class,
-);
+export const DeploymentAcceleratorSpecClass$inboundSchema: z.ZodNativeEnum<
+  typeof DeploymentAcceleratorSpecClass
+> = z.nativeEnum(DeploymentAcceleratorSpecClass);
 /** @internal */
-export const Class$outboundSchema: z.ZodNativeEnum<typeof Class> =
-  Class$inboundSchema;
+export const DeploymentAcceleratorSpecClass$outboundSchema: z.ZodNativeEnum<
+  typeof DeploymentAcceleratorSpecClass
+> = DeploymentAcceleratorSpecClass$inboundSchema;
 
 /** @internal */
 export const DeploymentAcceleratorSpec$inboundSchema: z.ZodType<
@@ -57,7 +60,7 @@ export const DeploymentAcceleratorSpec$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  class: Class$inboundSchema.default("gpu"),
+  class: DeploymentAcceleratorSpecClass$inboundSchema.default("gpu"),
   count: z.number().int().default(1),
   fallback: z.array(z.string()).optional(),
   type: z.string().optional(),
@@ -76,7 +79,7 @@ export const DeploymentAcceleratorSpec$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   DeploymentAcceleratorSpec
 > = z.object({
-  class: Class$outboundSchema.default("gpu"),
+  class: DeploymentAcceleratorSpecClass$outboundSchema.default("gpu"),
   count: z.number().int().default(1),
   fallback: z.array(z.string()).optional(),
   type: z.string().optional(),

package/src/models/components/deploymentcreate.ts

@@ -95,6 +95,9 @@ export type DeploymentCreate = {
    * Create-time scaling. Omitted min_containers defaults to one; explicit zero is preserved.
    */
   scaling?: DeploymentScalingCreate | undefined;
+  /**
+   * Each referenced secret must include "serving" in its allowed_use.
+   */
   secrets?: Array<string> | undefined;
   /**
    * How a config change or rollback is rolled out.

package/src/models/components/finetunejob.ts

@@ -41,6 +41,14 @@ export type FinetuneJob = {
    * 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;
+  /**
+   * Free-vocabulary refinement of status explaining why the current status persists (e.g. `seeking_capacity`, `awaiting_evaluation`, `acquiring_capacity`, `provisioning`, `finalizing`). Additive: values may appear, change, or disappear at any time, so clients must render it verbatim and must not switch on it — branch on `status` only. Absent when the status needs no explanation.
+   */
+  phase?: string | null | undefined;
+  /**
+   * Human-readable, provider-neutral sentence expanding on `phase` for direct display. Not stable, not machine-parseable; absent whenever `phase` is absent.
+   */
+  phaseMessage?: string | null | undefined;
   /**
    * 0.0–1.0 if known
    */
@@ -75,6 +83,8 @@ export const FinetuneJob$inboundSchema: z.ZodType<
   name: z.string(),
   output_model: z.nullable(z.string()).optional(),
   parent_job_id: z.nullable(z.string()).optional(),
+  phase: z.nullable(z.string()).optional(),
+  phase_message: z.nullable(z.string()).optional(),
   progress: z.nullable(z.number()).optional(),
   status: FinetuneJobStatus$inboundSchema,
 }).transform((v) => {
@@ -85,6 +95,7 @@ export const FinetuneJob$inboundSchema: z.ZodType<
     "from_checkpoint": "fromCheckpoint",
     "output_model": "outputModel",
     "parent_job_id": "parentJobId",
+    "phase_message": "phaseMessage",
   });
 });
 /** @internal */
@@ -99,6 +110,8 @@ export type FinetuneJob$Outbound = {
   name: string;
   output_model?: string | null | undefined;
   parent_job_id?: string | null | undefined;
+  phase?: string | null | undefined;
+  phase_message?: string | null | undefined;
   progress?: number | null | undefined;
   status: string;
 };
@@ -119,6 +132,8 @@ export const FinetuneJob$outboundSchema: z.ZodType<
   name: z.string(),
   outputModel: z.nullable(z.string()).optional(),
   parentJobId: z.nullable(z.string()).optional(),
+  phase: z.nullable(z.string()).optional(),
+  phaseMessage: z.nullable(z.string()).optional(),
   progress: z.nullable(z.number()).optional(),
   status: FinetuneJobStatus$outboundSchema,
 }).transform((v) => {
@@ -129,6 +144,7 @@ export const FinetuneJob$outboundSchema: z.ZodType<
     fromCheckpoint: "from_checkpoint",
     outputModel: "output_model",
     parentJobId: "parent_job_id",
+    phaseMessage: "phase_message",
   });
 });