@meetkai/mka1 0.48.33 → 0.48.35

package/src/models/components/deploymentupdate.ts

@@ -0,0 +1,87 @@
+/*
+ * 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 {
+  DeployStrategy,
+  DeployStrategy$inboundSchema,
+  DeployStrategy$outboundSchema,
+} from "./deploystrategy.js";
+
+/**
+ * Patch a deployment's config. Triggers a new revision (rolling by default).
+ */
+export type DeploymentUpdate = {
+  model?: string | null | undefined;
+  image?: string | null | undefined;
+  secrets?: Array<string> | null | undefined;
+  engineArgs?: Array<string> | null | undefined;
+  /**
+   * How a config change or rollback is rolled out.
+   */
+  strategy?: DeployStrategy | undefined;
+};
+
+/** @internal */
+export const DeploymentUpdate$inboundSchema: z.ZodType<
+  DeploymentUpdate,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  model: z.nullable(z.string()).optional(),
+  image: 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, {
+    "engine_args": "engineArgs",
+  });
+});
+/** @internal */
+export type DeploymentUpdate$Outbound = {
+  model?: string | null | undefined;
+  image?: string | null | undefined;
+  secrets?: Array<string> | null | undefined;
+  engine_args?: Array<string> | null | undefined;
+  strategy?: string | undefined;
+};
+
+/** @internal */
+export const DeploymentUpdate$outboundSchema: z.ZodType<
+  DeploymentUpdate$Outbound,
+  z.ZodTypeDef,
+  DeploymentUpdate
+> = z.object({
+  model: z.nullable(z.string()).optional(),
+  image: 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, {
+    engineArgs: "engine_args",
+  });
+});
+
+export function deploymentUpdateToJSON(
+  deploymentUpdate: DeploymentUpdate,
+): string {
+  return JSON.stringify(
+    DeploymentUpdate$outboundSchema.parse(deploymentUpdate),
+  );
+}
+export function deploymentUpdateFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentUpdate, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentUpdate$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentUpdate' from JSON`,
+  );
+}

package/src/models/components/deploystrategy.ts

@@ -0,0 +1,27 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+/**
+ * How a config change or rollback is rolled out.
+ */
+export const DeployStrategy = {
+  Rolling: "rolling",
+  Recreate: "recreate",
+} as const;
+/**
+ * How a config change or rollback is rolled out.
+ */
+export type DeployStrategy = ClosedEnum<typeof DeployStrategy>;
+
+/** @internal */
+export const DeployStrategy$inboundSchema: z.ZodNativeEnum<
+  typeof DeployStrategy
+> = z.nativeEnum(DeployStrategy);
+/** @internal */
+export const DeployStrategy$outboundSchema: z.ZodNativeEnum<
+  typeof DeployStrategy
+> = DeployStrategy$inboundSchema;

package/src/models/components/effectivepricerow.ts

@@ -0,0 +1,170 @@
+/*
+ * 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";
+
+export type EffectivePriceRowRates = {
+  inputTokens?: number | undefined;
+  outputTokens?: number | undefined;
+  cachedTokens?: number | undefined;
+  reasoningTokens?: number | undefined;
+  characters?: number | undefined;
+  seconds?: number | undefined;
+  image?: number | undefined;
+  imageTiers?: { [k: string]: number } | undefined;
+  searches?: number | undefined;
+};
+
+export const EffectivePriceRowSource = {
+  OrgOverride: "org_override",
+  ClusterDefault: "cluster_default",
+  Unpriced: "unpriced",
+} as const;
+export type EffectivePriceRowSource = ClosedEnum<
+  typeof EffectivePriceRowSource
+>;
+
+export type EffectivePriceRow = {
+  model: string;
+  rates: EffectivePriceRowRates | null;
+  source: EffectivePriceRowSource;
+};
+
+/** @internal */
+export const EffectivePriceRowRates$inboundSchema: z.ZodType<
+  EffectivePriceRowRates,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  input_tokens: z.number().optional(),
+  output_tokens: z.number().optional(),
+  cached_tokens: z.number().optional(),
+  reasoning_tokens: z.number().optional(),
+  characters: z.number().optional(),
+  seconds: z.number().optional(),
+  image: z.number().optional(),
+  image_tiers: z.record(z.number()).optional(),
+  searches: z.number().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "input_tokens": "inputTokens",
+    "output_tokens": "outputTokens",
+    "cached_tokens": "cachedTokens",
+    "reasoning_tokens": "reasoningTokens",
+    "image_tiers": "imageTiers",
+  });
+});
+/** @internal */
+export type EffectivePriceRowRates$Outbound = {
+  input_tokens?: number | undefined;
+  output_tokens?: number | undefined;
+  cached_tokens?: number | undefined;
+  reasoning_tokens?: number | undefined;
+  characters?: number | undefined;
+  seconds?: number | undefined;
+  image?: number | undefined;
+  image_tiers?: { [k: string]: number } | undefined;
+  searches?: number | undefined;
+};
+
+/** @internal */
+export const EffectivePriceRowRates$outboundSchema: z.ZodType<
+  EffectivePriceRowRates$Outbound,
+  z.ZodTypeDef,
+  EffectivePriceRowRates
+> = z.object({
+  inputTokens: z.number().optional(),
+  outputTokens: z.number().optional(),
+  cachedTokens: z.number().optional(),
+  reasoningTokens: z.number().optional(),
+  characters: z.number().optional(),
+  seconds: z.number().optional(),
+  image: z.number().optional(),
+  imageTiers: z.record(z.number()).optional(),
+  searches: z.number().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    inputTokens: "input_tokens",
+    outputTokens: "output_tokens",
+    cachedTokens: "cached_tokens",
+    reasoningTokens: "reasoning_tokens",
+    imageTiers: "image_tiers",
+  });
+});
+
+export function effectivePriceRowRatesToJSON(
+  effectivePriceRowRates: EffectivePriceRowRates,
+): string {
+  return JSON.stringify(
+    EffectivePriceRowRates$outboundSchema.parse(effectivePriceRowRates),
+  );
+}
+export function effectivePriceRowRatesFromJSON(
+  jsonString: string,
+): SafeParseResult<EffectivePriceRowRates, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EffectivePriceRowRates$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EffectivePriceRowRates' from JSON`,
+  );
+}
+
+/** @internal */
+export const EffectivePriceRowSource$inboundSchema: z.ZodNativeEnum<
+  typeof EffectivePriceRowSource
+> = z.nativeEnum(EffectivePriceRowSource);
+/** @internal */
+export const EffectivePriceRowSource$outboundSchema: z.ZodNativeEnum<
+  typeof EffectivePriceRowSource
+> = EffectivePriceRowSource$inboundSchema;
+
+/** @internal */
+export const EffectivePriceRow$inboundSchema: z.ZodType<
+  EffectivePriceRow,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  model: z.string(),
+  rates: z.nullable(z.lazy(() => EffectivePriceRowRates$inboundSchema)),
+  source: EffectivePriceRowSource$inboundSchema,
+});
+/** @internal */
+export type EffectivePriceRow$Outbound = {
+  model: string;
+  rates: EffectivePriceRowRates$Outbound | null;
+  source: string;
+};
+
+/** @internal */
+export const EffectivePriceRow$outboundSchema: z.ZodType<
+  EffectivePriceRow$Outbound,
+  z.ZodTypeDef,
+  EffectivePriceRow
+> = z.object({
+  model: z.string(),
+  rates: z.nullable(z.lazy(() => EffectivePriceRowRates$outboundSchema)),
+  source: EffectivePriceRowSource$outboundSchema,
+});
+
+export function effectivePriceRowToJSON(
+  effectivePriceRow: EffectivePriceRow,
+): string {
+  return JSON.stringify(
+    EffectivePriceRow$outboundSchema.parse(effectivePriceRow),
+  );
+}
+export function effectivePriceRowFromJSON(
+  jsonString: string,
+): SafeParseResult<EffectivePriceRow, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EffectivePriceRow$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EffectivePriceRow' from JSON`,
+  );
+}

package/src/models/components/effectivepricesresponse.ts

@@ -0,0 +1,65 @@
+/*
+ * 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 {
+  EffectivePriceRow,
+  EffectivePriceRow$inboundSchema,
+  EffectivePriceRow$Outbound,
+  EffectivePriceRow$outboundSchema,
+} from "./effectivepricerow.js";
+
+export type EffectivePricesResponse = {
+  object: "list";
+  currency: string | null;
+  data: Array<EffectivePriceRow>;
+};
+
+/** @internal */
+export const EffectivePricesResponse$inboundSchema: z.ZodType<
+  EffectivePricesResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  object: z.literal("list"),
+  currency: z.nullable(z.string()),
+  data: z.array(EffectivePriceRow$inboundSchema),
+});
+/** @internal */
+export type EffectivePricesResponse$Outbound = {
+  object: "list";
+  currency: string | null;
+  data: Array<EffectivePriceRow$Outbound>;
+};
+
+/** @internal */
+export const EffectivePricesResponse$outboundSchema: z.ZodType<
+  EffectivePricesResponse$Outbound,
+  z.ZodTypeDef,
+  EffectivePricesResponse
+> = z.object({
+  object: z.literal("list"),
+  currency: z.nullable(z.string()),
+  data: z.array(EffectivePriceRow$outboundSchema),
+});
+
+export function effectivePricesResponseToJSON(
+  effectivePricesResponse: EffectivePricesResponse,
+): string {
+  return JSON.stringify(
+    EffectivePricesResponse$outboundSchema.parse(effectivePricesResponse),
+  );
+}
+export function effectivePricesResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<EffectivePricesResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EffectivePricesResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EffectivePricesResponse' from JSON`,
+  );
+}

package/src/models/components/engine.ts

@@ -0,0 +1,25 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+/**
+ * Inference engine that backs a deployment.
+ */
+export const Engine = {
+  Vllm: "vllm",
+  Sglang: "sglang",
+} as const;
+/**
+ * Inference engine that backs a deployment.
+ */
+export type Engine = ClosedEnum<typeof Engine>;
+
+/** @internal */
+export const Engine$inboundSchema: z.ZodNativeEnum<typeof Engine> = z
+  .nativeEnum(Engine);
+/** @internal */
+export const Engine$outboundSchema: z.ZodNativeEnum<typeof Engine> =
+  Engine$inboundSchema;

package/src/models/components/errordetail.ts

@@ -0,0 +1,58 @@
+/*
+ * 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";
+
+/**
+ * The body of an error response.
+ */
+export type ErrorDetail = {
+  code: string;
+  message: string;
+  type: string;
+};
+
+/** @internal */
+export const ErrorDetail$inboundSchema: z.ZodType<
+  ErrorDetail,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: z.string(),
+  message: z.string(),
+  type: z.string(),
+});
+/** @internal */
+export type ErrorDetail$Outbound = {
+  code: string;
+  message: string;
+  type: string;
+};
+
+/** @internal */
+export const ErrorDetail$outboundSchema: z.ZodType<
+  ErrorDetail$Outbound,
+  z.ZodTypeDef,
+  ErrorDetail
+> = z.object({
+  code: z.string(),
+  message: z.string(),
+  type: z.string(),
+});
+
+export function errorDetailToJSON(errorDetail: ErrorDetail): string {
+  return JSON.stringify(ErrorDetail$outboundSchema.parse(errorDetail));
+}
+export function errorDetailFromJSON(
+  jsonString: string,
+): SafeParseResult<ErrorDetail, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ErrorDetail$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ErrorDetail' from JSON`,
+  );
+}

package/src/models/components/finetunejob.ts

@@ -0,0 +1,119 @@
+/*
+ * 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";
+
+export const FinetuneJobStatus = {
+  Queued: "queued",
+  Running: "running",
+  Succeeded: "succeeded",
+  Failed: "failed",
+  Cancelled: "cancelled",
+} as const;
+export type FinetuneJobStatus = ClosedEnum<typeof FinetuneJobStatus>;
+
+/**
+ * A fine-tune job.
+ */
+export type FinetuneJob = {
+  id: string;
+  name: string;
+  status: FinetuneJobStatus;
+  baseModel: string;
+  method: string;
+  /**
+   * 0.0–1.0 if known
+   */
+  progress?: number | null | undefined;
+  checkpoints?: Array<string> | undefined;
+  createdAt: Date;
+  finishedAt?: Date | null | undefined;
+};
+
+/** @internal */
+export const FinetuneJobStatus$inboundSchema: z.ZodNativeEnum<
+  typeof FinetuneJobStatus
+> = z.nativeEnum(FinetuneJobStatus);
+/** @internal */
+export const FinetuneJobStatus$outboundSchema: z.ZodNativeEnum<
+  typeof FinetuneJobStatus
+> = FinetuneJobStatus$inboundSchema;
+
+/** @internal */
+export const FinetuneJob$inboundSchema: z.ZodType<
+  FinetuneJob,
+  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(),
+}).transform((v) => {
+  return remap$(v, {
+    "base_model": "baseModel",
+    "created_at": "createdAt",
+    "finished_at": "finishedAt",
+  });
+});
+/** @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;
+};
+
+/** @internal */
+export const FinetuneJob$outboundSchema: z.ZodType<
+  FinetuneJob$Outbound,
+  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(),
+}).transform((v) => {
+  return remap$(v, {
+    baseModel: "base_model",
+    createdAt: "created_at",
+    finishedAt: "finished_at",
+  });
+});
+
+export function finetuneJobToJSON(finetuneJob: FinetuneJob): string {
+  return JSON.stringify(FinetuneJob$outboundSchema.parse(finetuneJob));
+}
+export function finetuneJobFromJSON(
+  jsonString: string,
+): SafeParseResult<FinetuneJob, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FinetuneJob$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FinetuneJob' from JSON`,
+  );
+}

package/src/models/components/finetunejobcreate.ts

@@ -0,0 +1,138 @@
+/*
+ * 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 {
+  AcceleratorSpec,
+  AcceleratorSpec$inboundSchema,
+  AcceleratorSpec$Outbound,
+  AcceleratorSpec$outboundSchema,
+} from "./acceleratorspec.js";
+
+export const FinetuneJobCreateMethod = {
+  Lora: "lora",
+  Qlora: "qlora",
+  Full: "full",
+} as const;
+export type FinetuneJobCreateMethod = ClosedEnum<
+  typeof FinetuneJobCreateMethod
+>;
+
+/**
+ * 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.
+   *
+   * @remarks
+   *
+   * Request an accelerator by type and count, with optional fallback types.
+   */
+  accelerator: AcceleratorSpec;
+  /**
+   * Volume where checkpoints are written
+   */
+  outputVolume: string;
+  /**
+   * Name/ID of a built image; defaults to a stock trainer
+   */
+  image?: string | null | undefined;
+  secrets?: Array<string> | undefined;
+  hyperparameters?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const FinetuneJobCreateMethod$inboundSchema: z.ZodNativeEnum<
+  typeof FinetuneJobCreateMethod
+> = z.nativeEnum(FinetuneJobCreateMethod);
+/** @internal */
+export const FinetuneJobCreateMethod$outboundSchema: z.ZodNativeEnum<
+  typeof FinetuneJobCreateMethod
+> = FinetuneJobCreateMethod$inboundSchema;
+
+/** @internal */
+export const FinetuneJobCreate$inboundSchema: z.ZodType<
+  FinetuneJobCreate,
+  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(),
+  image: z.nullable(z.string()).optional(),
+  secrets: z.array(z.string()).optional(),
+  hyperparameters: z.record(z.any()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "base_model": "baseModel",
+    "output_volume": "outputVolume",
+  });
+});
+/** @internal */
+export type FinetuneJobCreate$Outbound = {
+  name: string;
+  base_model: string;
+  method: string;
+  dataset: string;
+  accelerator: AcceleratorSpec$Outbound;
+  output_volume: string;
+  image?: string | null | undefined;
+  secrets?: Array<string> | undefined;
+  hyperparameters?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const FinetuneJobCreate$outboundSchema: z.ZodType<
+  FinetuneJobCreate$Outbound,
+  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(),
+  image: z.nullable(z.string()).optional(),
+  secrets: z.array(z.string()).optional(),
+  hyperparameters: z.record(z.any()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    baseModel: "base_model",
+    outputVolume: "output_volume",
+  });
+});
+
+export function finetuneJobCreateToJSON(
+  finetuneJobCreate: FinetuneJobCreate,
+): string {
+  return JSON.stringify(
+    FinetuneJobCreate$outboundSchema.parse(finetuneJobCreate),
+  );
+}
+export function finetuneJobCreateFromJSON(
+  jsonString: string,
+): SafeParseResult<FinetuneJobCreate, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FinetuneJobCreate$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FinetuneJobCreate' from JSON`,
+  );
+}