@meetkai/mka1 0.54.32 → 0.54.34

package/src/models/components/computeinstance.ts

@@ -38,7 +38,10 @@ import {
 } from "./computessh.js";
 
 export type ComputeInstance = {
+  allocatedAt?: Date | undefined;
+  confirmedAbsentAt?: Date | undefined;
   createdAt?: Date | undefined;
+  drainingAt?: Date | undefined;
   endpoints: Array<ComputeEndpoint>;
   exitCode?: number | undefined;
   hardware: ComputeHardware;
@@ -56,7 +59,10 @@ export type ComputeInstance = {
   readyAt?: Date | undefined;
   reason?: ComputeReason | undefined;
   region?: string | undefined;
+  replicaActivationGeneration?: number | undefined;
+  replicaId?: string | undefined;
   replicaIndex?: number | undefined;
+  replicaOrdinal?: number | undefined;
   ssh?: ComputeSSH | undefined;
   startedAt?: Date | undefined;
   state: ComputeInstanceState;
@@ -69,8 +75,16 @@ export const ComputeInstance$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
+  allocated_at: z.string().datetime({ offset: true }).transform(v =>
+    new Date(v)
+  ).optional(),
+  confirmed_absent_at: z.string().datetime({ offset: true }).transform(v =>
+    new Date(v)
+  ).optional(),
   created_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
+  draining_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
+    .optional(),
   endpoints: z.array(ComputeEndpoint$inboundSchema),
   exit_code: z.number().int().optional(),
   hardware: ComputeHardware$inboundSchema,
@@ -86,7 +100,10 @@ export const ComputeInstance$inboundSchema: z.ZodType<
     .optional(),
   reason: ComputeReason$inboundSchema.optional(),
   region: z.string().optional(),
+  replica_activation_generation: z.number().int().optional(),
+  replica_id: z.string().optional(),
   replica_index: z.number().int().optional(),
+  replica_ordinal: z.number().int().optional(),
   ssh: ComputeSSH$inboundSchema.optional(),
   started_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
@@ -95,21 +112,30 @@ export const ComputeInstance$inboundSchema: z.ZodType<
     .optional(),
 }).transform((v) => {
   return remap$(v, {
+    "allocated_at": "allocatedAt",
+    "confirmed_absent_at": "confirmedAbsentAt",
     "created_at": "createdAt",
+    "draining_at": "drainingAt",
     "exit_code": "exitCode",
     "price_usd_hr": "priceUsdHr",
     "private_host": "privateHost",
     "provider_id": "providerId",
     "provider_resource_type": "providerResourceType",
     "ready_at": "readyAt",
+    "replica_activation_generation": "replicaActivationGeneration",
+    "replica_id": "replicaId",
     "replica_index": "replicaIndex",
+    "replica_ordinal": "replicaOrdinal",
     "started_at": "startedAt",
     "terminal_at": "terminalAt",
   });
 });
 /** @internal */
 export type ComputeInstance$Outbound = {
+  allocated_at?: string | undefined;
+  confirmed_absent_at?: string | undefined;
   created_at?: string | undefined;
+  draining_at?: string | undefined;
   endpoints: Array<ComputeEndpoint$Outbound>;
   exit_code?: number | undefined;
   hardware: ComputeHardware$Outbound;
@@ -124,7 +150,10 @@ export type ComputeInstance$Outbound = {
   ready_at?: string | undefined;
   reason?: ComputeReason$Outbound | undefined;
   region?: string | undefined;
+  replica_activation_generation?: number | undefined;
+  replica_id?: string | undefined;
   replica_index?: number | undefined;
+  replica_ordinal?: number | undefined;
   ssh?: ComputeSSH$Outbound | undefined;
   started_at?: string | undefined;
   state: string;
@@ -137,7 +166,10 @@ export const ComputeInstance$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ComputeInstance
 > = z.object({
+  allocatedAt: z.date().transform(v => v.toISOString()).optional(),
+  confirmedAbsentAt: z.date().transform(v => v.toISOString()).optional(),
   createdAt: z.date().transform(v => v.toISOString()).optional(),
+  drainingAt: z.date().transform(v => v.toISOString()).optional(),
   endpoints: z.array(ComputeEndpoint$outboundSchema),
   exitCode: z.number().int().optional(),
   hardware: ComputeHardware$outboundSchema,
@@ -152,21 +184,30 @@ export const ComputeInstance$outboundSchema: z.ZodType<
   readyAt: z.date().transform(v => v.toISOString()).optional(),
   reason: ComputeReason$outboundSchema.optional(),
   region: z.string().optional(),
+  replicaActivationGeneration: z.number().int().optional(),
+  replicaId: z.string().optional(),
   replicaIndex: z.number().int().optional(),
+  replicaOrdinal: z.number().int().optional(),
   ssh: ComputeSSH$outboundSchema.optional(),
   startedAt: z.date().transform(v => v.toISOString()).optional(),
   state: ComputeInstanceState$outboundSchema,
   terminalAt: z.date().transform(v => v.toISOString()).optional(),
 }).transform((v) => {
   return remap$(v, {
+    allocatedAt: "allocated_at",
+    confirmedAbsentAt: "confirmed_absent_at",
     createdAt: "created_at",
+    drainingAt: "draining_at",
     exitCode: "exit_code",
     priceUsdHr: "price_usd_hr",
     privateHost: "private_host",
     providerId: "provider_id",
     providerResourceType: "provider_resource_type",
     readyAt: "ready_at",
+    replicaActivationGeneration: "replica_activation_generation",
+    replicaId: "replica_id",
     replicaIndex: "replica_index",
+    replicaOrdinal: "replica_ordinal",
     startedAt: "started_at",
     terminalAt: "terminal_at",
   });

package/src/models/components/computejob.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 {
@@ -55,17 +56,26 @@ import {
   ComputeStandaloneVolumeMount$outboundSchema,
 } from "./computestandalonevolumemount.js";
 
+export const PricingModel = {
+  InstanceMinutes: "instance_minutes",
+  InstanceSeconds: "instance_seconds",
+} as const;
+export type PricingModel = ClosedEnum<typeof PricingModel>;
+
 export type ComputeJob = {
   accruedUsd: number;
   allocatedAt?: Date | undefined;
   compute: ComputeRequest;
   createdAt: Date;
+  currentPriceUsdHr?: number | undefined;
   endpoints: Array<ComputeEndpoint>;
   hardware?: ComputeHardware | undefined;
   id: string;
+  instancePriceUsdHr?: number | undefined;
   limits: ComputeLimits;
   name?: string | undefined;
   priceUsdHr?: number | undefined;
+  pricingModel?: PricingModel | undefined;
   /**
    * Opaque compute-provider identifier. Supported values are deployment-specific.
    */
@@ -79,6 +89,13 @@ export type ComputeJob = {
   exitCode?: number | undefined;
 };
 
+/** @internal */
+export const PricingModel$inboundSchema: z.ZodNativeEnum<typeof PricingModel> =
+  z.nativeEnum(PricingModel);
+/** @internal */
+export const PricingModel$outboundSchema: z.ZodNativeEnum<typeof PricingModel> =
+  PricingModel$inboundSchema;
+
 /** @internal */
 export const ComputeJob$inboundSchema: z.ZodType<
   ComputeJob,
@@ -91,12 +108,15 @@ export const ComputeJob$inboundSchema: z.ZodType<
   ).optional(),
   compute: ComputeRequest$inboundSchema,
   created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  current_price_usd_hr: z.number().optional(),
   endpoints: z.array(ComputeEndpoint$inboundSchema),
   hardware: ComputeHardware$inboundSchema.optional(),
   id: z.string(),
+  instance_price_usd_hr: z.number().optional(),
   limits: ComputeLimits$inboundSchema,
   name: z.string().optional(),
   price_usd_hr: z.number().optional(),
+  pricing_model: PricingModel$inboundSchema.optional(),
   provider: z.string().optional(),
   reason: z.nullable(ComputeReason$inboundSchema),
   ssh: ComputeSSH$inboundSchema.optional(),
@@ -114,7 +134,10 @@ export const ComputeJob$inboundSchema: z.ZodType<
     "accrued_usd": "accruedUsd",
     "allocated_at": "allocatedAt",
     "created_at": "createdAt",
+    "current_price_usd_hr": "currentPriceUsdHr",
+    "instance_price_usd_hr": "instancePriceUsdHr",
     "price_usd_hr": "priceUsdHr",
+    "pricing_model": "pricingModel",
     "started_at": "startedAt",
     "terminal_at": "terminalAt",
     "exit_code": "exitCode",
@@ -126,12 +149,15 @@ export type ComputeJob$Outbound = {
   allocated_at?: string | undefined;
   compute: ComputeRequest$Outbound;
   created_at: string;
+  current_price_usd_hr?: number | undefined;
   endpoints: Array<ComputeEndpoint$Outbound>;
   hardware?: ComputeHardware$Outbound | undefined;
   id: string;
+  instance_price_usd_hr?: number | undefined;
   limits: ComputeLimits$Outbound;
   name?: string | undefined;
   price_usd_hr?: number | undefined;
+  pricing_model?: string | undefined;
   provider?: string | undefined;
   reason: ComputeReason$Outbound | null;
   ssh?: ComputeSSH$Outbound | undefined;
@@ -152,12 +178,15 @@ export const ComputeJob$outboundSchema: z.ZodType<
   allocatedAt: z.date().transform(v => v.toISOString()).optional(),
   compute: ComputeRequest$outboundSchema,
   createdAt: z.date().transform(v => v.toISOString()),
+  currentPriceUsdHr: z.number().optional(),
   endpoints: z.array(ComputeEndpoint$outboundSchema),
   hardware: ComputeHardware$outboundSchema.optional(),
   id: z.string(),
+  instancePriceUsdHr: z.number().optional(),
   limits: ComputeLimits$outboundSchema,
   name: z.string().optional(),
   priceUsdHr: z.number().optional(),
+  pricingModel: PricingModel$outboundSchema.optional(),
   provider: z.string().optional(),
   reason: z.nullable(ComputeReason$outboundSchema),
   ssh: ComputeSSH$outboundSchema.optional(),
@@ -171,7 +200,10 @@ export const ComputeJob$outboundSchema: z.ZodType<
     accruedUsd: "accrued_usd",
     allocatedAt: "allocated_at",
     createdAt: "created_at",
+    currentPriceUsdHr: "current_price_usd_hr",
+    instancePriceUsdHr: "instance_price_usd_hr",
     priceUsdHr: "price_usd_hr",
+    pricingModel: "pricing_model",
     startedAt: "started_at",
     terminalAt: "terminal_at",
     exitCode: "exit_code",

package/src/models/components/computeoffer.ts

@@ -14,6 +14,10 @@ export type ComputeOfferCapabilities = {
   managedService: boolean;
   multiNode: boolean;
   persistentVolume: boolean;
+  /**
+   * The backend can pull image with the credential named by image_pull_secret.
+   */
+  privateImage: boolean;
   scaleToZero: boolean;
   sharedVolume: boolean;
   ssh: boolean;
@@ -63,6 +67,7 @@ export const ComputeOfferCapabilities$inboundSchema: z.ZodType<
   managed_service: z.boolean(),
   multi_node: z.boolean(),
   persistent_volume: z.boolean(),
+  private_image: z.boolean(),
   scale_to_zero: z.boolean(),
   shared_volume: z.boolean(),
   ssh: z.boolean(),
@@ -75,6 +80,7 @@ export const ComputeOfferCapabilities$inboundSchema: z.ZodType<
     "managed_service": "managedService",
     "multi_node": "multiNode",
     "persistent_volume": "persistentVolume",
+    "private_image": "privateImage",
     "scale_to_zero": "scaleToZero",
     "shared_volume": "sharedVolume",
     "standalone_volume": "standaloneVolume",
@@ -88,6 +94,7 @@ export type ComputeOfferCapabilities$Outbound = {
   managed_service: boolean;
   multi_node: boolean;
   persistent_volume: boolean;
+  private_image: boolean;
   scale_to_zero: boolean;
   shared_volume: boolean;
   ssh: boolean;
@@ -106,6 +113,7 @@ export const ComputeOfferCapabilities$outboundSchema: z.ZodType<
   managedService: z.boolean(),
   multiNode: z.boolean(),
   persistentVolume: z.boolean(),
+  privateImage: z.boolean(),
   scaleToZero: z.boolean(),
   sharedVolume: z.boolean(),
   ssh: z.boolean(),
@@ -118,6 +126,7 @@ export const ComputeOfferCapabilities$outboundSchema: z.ZodType<
     managedService: "managed_service",
     multiNode: "multi_node",
     persistentVolume: "persistent_volume",
+    privateImage: "private_image",
     scaleToZero: "scale_to_zero",
     sharedVolume: "shared_volume",
     standaloneVolume: "standalone_volume",

package/src/models/components/computequoterequest.ts

@@ -49,6 +49,7 @@ export type ComputeQuoteRequestAccess = {
 
 export type ComputeQuoteRequestContainer = {
   image: string;
+  imagePullSecret?: string | undefined;
   ports?: Array<ComputePort> | undefined;
 };
 
@@ -112,11 +113,17 @@ export const ComputeQuoteRequestContainer$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   image: z.string(),
+  image_pull_secret: z.string().optional(),
   ports: z.array(ComputePort$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "image_pull_secret": "imagePullSecret",
+  });
 });
 /** @internal */
 export type ComputeQuoteRequestContainer$Outbound = {
   image: string;
+  image_pull_secret?: string | undefined;
   ports?: Array<ComputePort$Outbound> | undefined;
 };
 
@@ -127,7 +134,12 @@ export const ComputeQuoteRequestContainer$outboundSchema: z.ZodType<
   ComputeQuoteRequestContainer
 > = z.object({
   image: z.string(),
+  imagePullSecret: z.string().optional(),
   ports: z.array(ComputePort$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    imagePullSecret: "image_pull_secret",
+  });
 });
 
 export function computeQuoteRequestContainerToJSON(

package/src/models/components/computeregistrycredential.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";
+
+/**
+ * A registry username and password supplied inline on the create request instead of naming a stored secret (a token is accepted as the password). Write-only: it is sealed at admission, presented to the registry named by image at provider handoff, never returned by any read, list, event or quote, and discarded when the resource reaches a terminal state. Use it when the caller must not be able to read the credential back through its own tenant secrets. When set, image must be a fully-qualified OCI reference with an explicit registry host; the registry is read from image, never from the credential. Mutually exclusive with image_pull_secret. Not accepted on quotes: quote the same shape with image_pull_secret set to any non-blank id.
+ */
+export type ComputeRegistryCredential = {
+  password: string;
+  username: string;
+};
+
+/** @internal */
+export const ComputeRegistryCredential$inboundSchema: z.ZodType<
+  ComputeRegistryCredential,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  password: z.string(),
+  username: z.string(),
+});
+/** @internal */
+export type ComputeRegistryCredential$Outbound = {
+  password: string;
+  username: string;
+};
+
+/** @internal */
+export const ComputeRegistryCredential$outboundSchema: z.ZodType<
+  ComputeRegistryCredential$Outbound,
+  z.ZodTypeDef,
+  ComputeRegistryCredential
+> = z.object({
+  password: z.string(),
+  username: z.string(),
+});
+
+export function computeRegistryCredentialToJSON(
+  computeRegistryCredential: ComputeRegistryCredential,
+): string {
+  return JSON.stringify(
+    ComputeRegistryCredential$outboundSchema.parse(computeRegistryCredential),
+  );
+}
+export function computeRegistryCredentialFromJSON(
+  jsonString: string,
+): SafeParseResult<ComputeRegistryCredential, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ComputeRegistryCredential$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ComputeRegistryCredential' from JSON`,
+  );
+}

package/src/models/components/computescalinginput.ts

@@ -12,6 +12,7 @@ export type ComputeScalingInput = {
   idleTimeoutSeconds: number;
   maxReplicas: number;
   minReplicas: number;
+  targetConcurrencyPerReplica?: number | undefined;
 };
 
 /** @internal */
@@ -23,11 +24,13 @@ export const ComputeScalingInput$inboundSchema: z.ZodType<
   idle_timeout_seconds: z.number().int(),
   max_replicas: z.number().int(),
   min_replicas: z.number().int(),
+  target_concurrency_per_replica: z.number().int().optional(),
 }).transform((v) => {
   return remap$(v, {
     "idle_timeout_seconds": "idleTimeoutSeconds",
     "max_replicas": "maxReplicas",
     "min_replicas": "minReplicas",
+    "target_concurrency_per_replica": "targetConcurrencyPerReplica",
   });
 });
 /** @internal */
@@ -35,6 +38,7 @@ export type ComputeScalingInput$Outbound = {
   idle_timeout_seconds: number;
   max_replicas: number;
   min_replicas: number;
+  target_concurrency_per_replica?: number | undefined;
 };
 
 /** @internal */
@@ -46,11 +50,13 @@ export const ComputeScalingInput$outboundSchema: z.ZodType<
   idleTimeoutSeconds: z.number().int(),
   maxReplicas: z.number().int(),
   minReplicas: z.number().int(),
+  targetConcurrencyPerReplica: z.number().int().optional(),
 }).transform((v) => {
   return remap$(v, {
     idleTimeoutSeconds: "idle_timeout_seconds",
     maxReplicas: "max_replicas",
     minReplicas: "min_replicas",
+    targetConcurrencyPerReplica: "target_concurrency_per_replica",
   });
 });
 

package/src/models/components/computescalingreplicas.ts

@@ -0,0 +1,111 @@
+/*
+ * 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 Decision = {
+  Create: "create",
+  Manual: "manual",
+  Autoscaler: "autoscaler",
+} as const;
+export type Decision = ClosedEnum<typeof Decision>;
+
+export type ComputeScalingReplicas = {
+  allocated: number;
+  applied: number;
+  appliedGeneration: number;
+  decision: Decision;
+  desired: number;
+  desiredGeneration: number;
+  draining: number;
+  ready: number;
+  updatedAt: Date;
+};
+
+/** @internal */
+export const Decision$inboundSchema: z.ZodNativeEnum<typeof Decision> = z
+  .nativeEnum(Decision);
+/** @internal */
+export const Decision$outboundSchema: z.ZodNativeEnum<typeof Decision> =
+  Decision$inboundSchema;
+
+/** @internal */
+export const ComputeScalingReplicas$inboundSchema: z.ZodType<
+  ComputeScalingReplicas,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  allocated: z.number().int(),
+  applied: z.number().int(),
+  applied_generation: z.number().int(),
+  decision: Decision$inboundSchema,
+  desired: z.number().int(),
+  desired_generation: z.number().int(),
+  draining: z.number().int(),
+  ready: z.number().int(),
+  updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+}).transform((v) => {
+  return remap$(v, {
+    "applied_generation": "appliedGeneration",
+    "desired_generation": "desiredGeneration",
+    "updated_at": "updatedAt",
+  });
+});
+/** @internal */
+export type ComputeScalingReplicas$Outbound = {
+  allocated: number;
+  applied: number;
+  applied_generation: number;
+  decision: string;
+  desired: number;
+  desired_generation: number;
+  draining: number;
+  ready: number;
+  updated_at: string;
+};
+
+/** @internal */
+export const ComputeScalingReplicas$outboundSchema: z.ZodType<
+  ComputeScalingReplicas$Outbound,
+  z.ZodTypeDef,
+  ComputeScalingReplicas
+> = z.object({
+  allocated: z.number().int(),
+  applied: z.number().int(),
+  appliedGeneration: z.number().int(),
+  decision: Decision$outboundSchema,
+  desired: z.number().int(),
+  desiredGeneration: z.number().int(),
+  draining: z.number().int(),
+  ready: z.number().int(),
+  updatedAt: z.date().transform(v => v.toISOString()),
+}).transform((v) => {
+  return remap$(v, {
+    appliedGeneration: "applied_generation",
+    desiredGeneration: "desired_generation",
+    updatedAt: "updated_at",
+  });
+});
+
+export function computeScalingReplicasToJSON(
+  computeScalingReplicas: ComputeScalingReplicas,
+): string {
+  return JSON.stringify(
+    ComputeScalingReplicas$outboundSchema.parse(computeScalingReplicas),
+  );
+}
+export function computeScalingReplicasFromJSON(
+  jsonString: string,
+): SafeParseResult<ComputeScalingReplicas, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ComputeScalingReplicas$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ComputeScalingReplicas' from JSON`,
+  );
+}