@meetkai/mka1 0.54.33 → 0.54.34

package/src/models/components/computeservice.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 {
@@ -42,6 +43,12 @@ import {
   ComputeResourceState$inboundSchema,
   ComputeResourceState$outboundSchema,
 } from "./computeresourcestate.js";
+import {
+  ComputeServiceScaling,
+  ComputeServiceScaling$inboundSchema,
+  ComputeServiceScaling$Outbound,
+  ComputeServiceScaling$outboundSchema,
+} from "./computeservicescaling.js";
 import {
   ComputeSSH,
   ComputeSSH$inboundSchema,
@@ -61,17 +68,35 @@ import {
   ComputeVolume$outboundSchema,
 } from "./computevolume.js";
 
+export const ComputeServicePricingModel = {
+  InstanceMinutes: "instance_minutes",
+  InstanceSeconds: "instance_seconds",
+} as const;
+export type ComputeServicePricingModel = ClosedEnum<
+  typeof ComputeServicePricingModel
+>;
+
+export const Health = {
+  Healthy: "healthy",
+  Warming: "warming",
+  Degraded: "degraded",
+} as const;
+export type Health = ClosedEnum<typeof Health>;
+
 export type ComputeService = {
   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?: ComputeServicePricingModel | undefined;
   /**
    * Opaque compute-provider identifier. Supported values are deployment-specific.
    */
@@ -82,10 +107,28 @@ export type ComputeService = {
   state: ComputeResourceState;
   terminalAt: Date | null;
   volumes?: Array<ComputeStandaloneVolumeMount> | undefined;
+  health?: Health | undefined;
   ready: boolean;
+  scaling?: ComputeServiceScaling | undefined;
   volume?: ComputeVolume | undefined;
 };
 
+/** @internal */
+export const ComputeServicePricingModel$inboundSchema: z.ZodNativeEnum<
+  typeof ComputeServicePricingModel
+> = z.nativeEnum(ComputeServicePricingModel);
+/** @internal */
+export const ComputeServicePricingModel$outboundSchema: z.ZodNativeEnum<
+  typeof ComputeServicePricingModel
+> = ComputeServicePricingModel$inboundSchema;
+
+/** @internal */
+export const Health$inboundSchema: z.ZodNativeEnum<typeof Health> = z
+  .nativeEnum(Health);
+/** @internal */
+export const Health$outboundSchema: z.ZodNativeEnum<typeof Health> =
+  Health$inboundSchema;
+
 /** @internal */
 export const ComputeService$inboundSchema: z.ZodType<
   ComputeService,
@@ -98,12 +141,15 @@ export const ComputeService$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: ComputeServicePricingModel$inboundSchema.optional(),
   provider: z.string().optional(),
   reason: z.nullable(ComputeReason$inboundSchema),
   ssh: ComputeSSH$inboundSchema.optional(),
@@ -115,14 +161,19 @@ export const ComputeService$inboundSchema: z.ZodType<
     z.string().datetime({ offset: true }).transform(v => new Date(v)),
   ),
   volumes: z.array(ComputeStandaloneVolumeMount$inboundSchema).optional(),
+  health: Health$inboundSchema.optional(),
   ready: z.boolean(),
+  scaling: ComputeServiceScaling$inboundSchema.optional(),
   volume: ComputeVolume$inboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     "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",
   });
@@ -133,12 +184,15 @@ export type ComputeService$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;
@@ -146,7 +200,9 @@ export type ComputeService$Outbound = {
   state: string;
   terminal_at: string | null;
   volumes?: Array<ComputeStandaloneVolumeMount$Outbound> | undefined;
+  health?: string | undefined;
   ready: boolean;
+  scaling?: ComputeServiceScaling$Outbound | undefined;
   volume?: ComputeVolume$Outbound | undefined;
 };
 
@@ -160,12 +216,15 @@ export const ComputeService$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: ComputeServicePricingModel$outboundSchema.optional(),
   provider: z.string().optional(),
   reason: z.nullable(ComputeReason$outboundSchema),
   ssh: ComputeSSH$outboundSchema.optional(),
@@ -173,14 +232,19 @@ export const ComputeService$outboundSchema: z.ZodType<
   state: ComputeResourceState$outboundSchema,
   terminalAt: z.nullable(z.date().transform(v => v.toISOString())),
   volumes: z.array(ComputeStandaloneVolumeMount$outboundSchema).optional(),
+  health: Health$outboundSchema.optional(),
   ready: z.boolean(),
+  scaling: ComputeServiceScaling$outboundSchema.optional(),
   volume: ComputeVolume$outboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     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",
   });

package/src/models/components/computeservicescaling.ts

@@ -0,0 +1,116 @@
+/*
+ * 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 {
+  ComputeAutoscalerState,
+  ComputeAutoscalerState$inboundSchema,
+  ComputeAutoscalerState$Outbound,
+  ComputeAutoscalerState$outboundSchema,
+} from "./computeautoscalerstate.js";
+import {
+  ComputeScalingInput,
+  ComputeScalingInput$inboundSchema,
+  ComputeScalingInput$Outbound,
+  ComputeScalingInput$outboundSchema,
+} from "./computescalinginput.js";
+import {
+  ComputeScalingReplicas,
+  ComputeScalingReplicas$inboundSchema,
+  ComputeScalingReplicas$Outbound,
+  ComputeScalingReplicas$outboundSchema,
+} from "./computescalingreplicas.js";
+
+export type ComputeServiceScaling = {
+  applied: ComputeScalingInput | null;
+  appliedAt: Date | null;
+  appliedGeneration: number;
+  autoscaler: ComputeAutoscalerState;
+  desired: ComputeScalingInput;
+  desiredGeneration: number;
+  desiredUpdatedAt: Date;
+  replicas: ComputeScalingReplicas;
+};
+
+/** @internal */
+export const ComputeServiceScaling$inboundSchema: z.ZodType<
+  ComputeServiceScaling,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  applied: z.nullable(ComputeScalingInput$inboundSchema),
+  applied_at: z.nullable(
+    z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  ),
+  applied_generation: z.number().int(),
+  autoscaler: ComputeAutoscalerState$inboundSchema,
+  desired: ComputeScalingInput$inboundSchema,
+  desired_generation: z.number().int(),
+  desired_updated_at: z.string().datetime({ offset: true }).transform(v =>
+    new Date(v)
+  ),
+  replicas: ComputeScalingReplicas$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "applied_at": "appliedAt",
+    "applied_generation": "appliedGeneration",
+    "desired_generation": "desiredGeneration",
+    "desired_updated_at": "desiredUpdatedAt",
+  });
+});
+/** @internal */
+export type ComputeServiceScaling$Outbound = {
+  applied: ComputeScalingInput$Outbound | null;
+  applied_at: string | null;
+  applied_generation: number;
+  autoscaler: ComputeAutoscalerState$Outbound;
+  desired: ComputeScalingInput$Outbound;
+  desired_generation: number;
+  desired_updated_at: string;
+  replicas: ComputeScalingReplicas$Outbound;
+};
+
+/** @internal */
+export const ComputeServiceScaling$outboundSchema: z.ZodType<
+  ComputeServiceScaling$Outbound,
+  z.ZodTypeDef,
+  ComputeServiceScaling
+> = z.object({
+  applied: z.nullable(ComputeScalingInput$outboundSchema),
+  appliedAt: z.nullable(z.date().transform(v => v.toISOString())),
+  appliedGeneration: z.number().int(),
+  autoscaler: ComputeAutoscalerState$outboundSchema,
+  desired: ComputeScalingInput$outboundSchema,
+  desiredGeneration: z.number().int(),
+  desiredUpdatedAt: z.date().transform(v => v.toISOString()),
+  replicas: ComputeScalingReplicas$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    appliedAt: "applied_at",
+    appliedGeneration: "applied_generation",
+    desiredGeneration: "desired_generation",
+    desiredUpdatedAt: "desired_updated_at",
+  });
+});
+
+export function computeServiceScalingToJSON(
+  computeServiceScaling: ComputeServiceScaling,
+): string {
+  return JSON.stringify(
+    ComputeServiceScaling$outboundSchema.parse(computeServiceScaling),
+  );
+}
+export function computeServiceScalingFromJSON(
+  jsonString: string,
+): SafeParseResult<ComputeServiceScaling, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ComputeServiceScaling$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ComputeServiceScaling' from JSON`,
+  );
+}

package/src/models/components/computetenant.ts

@@ -12,6 +12,7 @@ export type ComputeTenant = {
   createdAt: Date;
   enabled: boolean;
   maxLiveJobs: number | null;
+  maxLiveServiceReplicas: number | null;
   maxLiveServices: number | null;
   maxLiveVolumes: number | null;
   orgId: string;
@@ -27,6 +28,7 @@ export const ComputeTenant$inboundSchema: z.ZodType<
   created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
   enabled: z.boolean(),
   max_live_jobs: z.nullable(z.number().int()),
+  max_live_service_replicas: z.nullable(z.number().int()),
   max_live_services: z.nullable(z.number().int()),
   max_live_volumes: z.nullable(z.number().int()),
   org_id: z.string(),
@@ -35,6 +37,7 @@ export const ComputeTenant$inboundSchema: z.ZodType<
   return remap$(v, {
     "created_at": "createdAt",
     "max_live_jobs": "maxLiveJobs",
+    "max_live_service_replicas": "maxLiveServiceReplicas",
     "max_live_services": "maxLiveServices",
     "max_live_volumes": "maxLiveVolumes",
     "org_id": "orgId",
@@ -46,6 +49,7 @@ export type ComputeTenant$Outbound = {
   created_at: string;
   enabled: boolean;
   max_live_jobs: number | null;
+  max_live_service_replicas: number | null;
   max_live_services: number | null;
   max_live_volumes: number | null;
   org_id: string;
@@ -61,6 +65,7 @@ export const ComputeTenant$outboundSchema: z.ZodType<
   createdAt: z.date().transform(v => v.toISOString()),
   enabled: z.boolean(),
   maxLiveJobs: z.nullable(z.number().int()),
+  maxLiveServiceReplicas: z.nullable(z.number().int()),
   maxLiveServices: z.nullable(z.number().int()),
   maxLiveVolumes: z.nullable(z.number().int()),
   orgId: z.string(),
@@ -69,6 +74,7 @@ export const ComputeTenant$outboundSchema: z.ZodType<
   return remap$(v, {
     createdAt: "created_at",
     maxLiveJobs: "max_live_jobs",
+    maxLiveServiceReplicas: "max_live_service_replicas",
     maxLiveServices: "max_live_services",
     maxLiveVolumes: "max_live_volumes",
     orgId: "org_id",

package/src/models/components/computetenantupdate.ts

@@ -11,6 +11,7 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 export type ComputeTenantUpdate = {
   enabled?: boolean | undefined;
   maxLiveJobs?: number | null | undefined;
+  maxLiveServiceReplicas?: number | null | undefined;
   maxLiveServices?: number | null | undefined;
   maxLiveVolumes?: number | null | undefined;
 };
@@ -23,11 +24,13 @@ export const ComputeTenantUpdate$inboundSchema: z.ZodType<
 > = z.object({
   enabled: z.boolean().optional(),
   max_live_jobs: z.nullable(z.number().int()).optional(),
+  max_live_service_replicas: z.nullable(z.number().int()).optional(),
   max_live_services: z.nullable(z.number().int()).optional(),
   max_live_volumes: z.nullable(z.number().int()).optional(),
 }).transform((v) => {
   return remap$(v, {
     "max_live_jobs": "maxLiveJobs",
+    "max_live_service_replicas": "maxLiveServiceReplicas",
     "max_live_services": "maxLiveServices",
     "max_live_volumes": "maxLiveVolumes",
   });
@@ -36,6 +39,7 @@ export const ComputeTenantUpdate$inboundSchema: z.ZodType<
 export type ComputeTenantUpdate$Outbound = {
   enabled?: boolean | undefined;
   max_live_jobs?: number | null | undefined;
+  max_live_service_replicas?: number | null | undefined;
   max_live_services?: number | null | undefined;
   max_live_volumes?: number | null | undefined;
 };
@@ -48,11 +52,13 @@ export const ComputeTenantUpdate$outboundSchema: z.ZodType<
 > = z.object({
   enabled: z.boolean().optional(),
   maxLiveJobs: z.nullable(z.number().int()).optional(),
+  maxLiveServiceReplicas: z.nullable(z.number().int()).optional(),
   maxLiveServices: z.nullable(z.number().int()).optional(),
   maxLiveVolumes: z.nullable(z.number().int()).optional(),
 }).transform((v) => {
   return remap$(v, {
     maxLiveJobs: "max_live_jobs",
+    maxLiveServiceReplicas: "max_live_service_replicas",
     maxLiveServices: "max_live_services",
     maxLiveVolumes: "max_live_volumes",
   });

package/src/models/components/computeusage.ts

@@ -24,6 +24,10 @@ export type ComputeUsageData = {
   billableSeconds: number;
   costBreakdownUsd?: CostBreakdownUsd | undefined;
   name: string;
+  /**
+   * Summed per-incarnation compute seconds; present for service rows.
+   */
+  replicaSeconds?: number | undefined;
   resourceId: string;
   resourceType: ComputeUsageResourceType;
   storedByteSeconds?: number | undefined;
@@ -157,6 +161,7 @@ export const ComputeUsageData$inboundSchema: z.ZodType<
   billable_seconds: z.number(),
   cost_breakdown_usd: z.lazy(() => CostBreakdownUsd$inboundSchema).optional(),
   name: z.string(),
+  replica_seconds: z.number().optional(),
   resource_id: z.string(),
   resource_type: ComputeUsageResourceType$inboundSchema,
   stored_byte_seconds: z.number().optional(),
@@ -166,6 +171,7 @@ export const ComputeUsageData$inboundSchema: z.ZodType<
     "accrued_usd": "accruedUsd",
     "billable_seconds": "billableSeconds",
     "cost_breakdown_usd": "costBreakdownUsd",
+    "replica_seconds": "replicaSeconds",
     "resource_id": "resourceId",
     "resource_type": "resourceType",
     "stored_byte_seconds": "storedByteSeconds",
@@ -178,6 +184,7 @@ export type ComputeUsageData$Outbound = {
   billable_seconds: number;
   cost_breakdown_usd?: CostBreakdownUsd$Outbound | undefined;
   name: string;
+  replica_seconds?: number | undefined;
   resource_id: string;
   resource_type: string;
   stored_byte_seconds?: number | undefined;
@@ -194,6 +201,7 @@ export const ComputeUsageData$outboundSchema: z.ZodType<
   billableSeconds: z.number(),
   costBreakdownUsd: z.lazy(() => CostBreakdownUsd$outboundSchema).optional(),
   name: z.string(),
+  replicaSeconds: z.number().optional(),
   resourceId: z.string(),
   resourceType: ComputeUsageResourceType$outboundSchema,
   storedByteSeconds: z.number().optional(),
@@ -203,6 +211,7 @@ export const ComputeUsageData$outboundSchema: z.ZodType<
     accruedUsd: "accrued_usd",
     billableSeconds: "billable_seconds",
     costBreakdownUsd: "cost_breakdown_usd",
+    replicaSeconds: "replica_seconds",
     resourceId: "resource_id",
     resourceType: "resource_type",
     storedByteSeconds: "stored_byte_seconds",

package/src/models/components/index.ts

@@ -83,6 +83,7 @@ export * from "./compoundfilter.js";
 export * from "./computeaccelerator.js";
 export * from "./computeacceleratorlist.js";
 export * from "./computeaccesscreate.js";
+export * from "./computeautoscalerstate.js";
 export * from "./computecontainercreate.js";
 export * from "./computeendpoint.js";
 export * from "./computeerror.js";
@@ -117,6 +118,7 @@ export * from "./computequoterequest.js";
 export * from "./computeraction.js";
 export * from "./computereadiness.js";
 export * from "./computereason.js";
+export * from "./computeregistrycredential.js";
 export * from "./computerequest.js";
 export * from "./computeresourcecreate.js";
 export * from "./computeresourcestate.js";
@@ -128,6 +130,7 @@ export * from "./computertoolcalloutputwithid.js";
 export * from "./computertoolcallwithid.js";
 export * from "./computerusetooldefinition.js";
 export * from "./computescalinginput.js";
+export * from "./computescalingreplicas.js";
 export * from "./computesecret.js";
 export * from "./computesecretcreate.js";
 export * from "./computesecretlist.js";
@@ -135,6 +138,7 @@ export * from "./computesecretreference.js";
 export * from "./computeservice.js";
 export * from "./computeserviceinput.js";
 export * from "./computeservicelist.js";
+export * from "./computeservicescaling.js";
 export * from "./computessh.js";
 export * from "./computestandalonevolume.js";
 export * from "./computestandalonevolumeattachment.js";

package/src/models/operations/index.ts

@@ -364,6 +364,7 @@ export * from "./updateresponse.js";
 export * from "./updateresponsefeedback.js";
 export * from "./updatescopedapikey.js";
 export * from "./updateserviceaccountapikey.js";
+export * from "./updateservicescaling.js";
 export * from "./updateskill.js";
 export * from "./updateteam.js";
 export * from "./updatevectorstorefileattributes.js";

package/src/models/operations/listserviceinstances.ts

@@ -18,6 +18,10 @@ export type ListServiceInstancesRequest = {
    * asc pages oldest-first (default); desc pages newest-first. A cursor is only valid within a traversal that keeps the same order.
    */
   order?: components.ComputeOrder | undefined;
+  /**
+   * Include retained terminal service-incarnation history. The default returns only current non-terminal incarnations.
+   */
+  history?: boolean | undefined;
   /**
    * Optional external end-user identifier forwarded by the API gateway.
    */
@@ -39,6 +43,7 @@ export const ListServiceInstancesRequest$inboundSchema: z.ZodType<
   cursor: z.string().optional(),
   limit: z.number().int().default(50),
   order: components.ComputeOrder$inboundSchema.default("asc"),
+  history: z.boolean().default(false),
   "X-On-Behalf-Of": z.string().optional(),
 }).transform((v) => {
   return remap$(v, {
@@ -52,6 +57,7 @@ export type ListServiceInstancesRequest$Outbound = {
   cursor?: string | undefined;
   limit: number;
   order: string;
+  history: boolean;
   "X-On-Behalf-Of"?: string | undefined;
 };
 
@@ -66,6 +72,7 @@ export const ListServiceInstancesRequest$outboundSchema: z.ZodType<
   cursor: z.string().optional(),
   limit: z.number().int().default(50),
   order: components.ComputeOrder$outboundSchema.default("asc"),
+  history: z.boolean().default(false),
   xOnBehalfOf: z.string().optional(),
 }).transform((v) => {
   return remap$(v, {