@phala/cloud 0.1.2 → 0.2.1-beta.1

package/dist/index.mjs

@@ -12,8 +12,11 @@ var ApiErrorSchema = z.object({
       z.object({
         msg: z.string(),
         type: z.string().optional(),
-        ctx: z.record(z.unknown()).optional()
-      })
+        ctx: z.record(z.unknown()).optional(),
+        loc: z.array(z.union([z.string(), z.number()])).optional(),
+        input: z.unknown().optional()
+      }).passthrough()
+      // Allow additional fields
     ),
     z.record(z.unknown())
   ]).optional(),
@@ -116,6 +119,9 @@ var UnknownError = class extends PhalaCloudError {
   }
 };
 function extractFieldPath(loc) {
+  if (!loc || !Array.isArray(loc)) {
+    return "unknown";
+  }
   const filtered = loc.filter((part) => {
     if (typeof part === "string") {
       return !["body", "query", "path", "header"].includes(part);
@@ -131,12 +137,21 @@ function parseValidationErrors(detail) {
       message: typeof detail === "string" ? detail : "Validation error"
     };
   }
-  const errors = detail.map((item) => ({
-    field: extractFieldPath(item.loc),
-    message: item.msg,
-    type: item.type,
-    context: item.ctx
-  }));
+  const errors = detail.map(
+    (item, index) => {
+      const field = extractFieldPath(item.loc);
+      let displayField = field;
+      if (field === "unknown" && item.type) {
+        displayField = item.type === "missing" ? "required field" : item.type;
+      }
+      return {
+        field: displayField,
+        message: item.msg,
+        type: item.type,
+        context: item.ctx
+      };
+    }
+  );
   const count = errors.length;
   const message = count === 1 ? `Validation failed: ${errors[0].message}` : `Validation failed (${count} issue${count > 1 ? "s" : ""})`;
   return { errors, message };
@@ -179,13 +194,21 @@ function parseApiError(requestError) {
   const status = requestError.status ?? 0;
   const statusText = requestError.statusText ?? "Unknown Error";
   const detail = requestError.detail;
+  const structured = parseStructuredError(detail);
+  if (structured) {
+    return new ResourceError(structured.message, {
+      status,
+      statusText,
+      detail,
+      errorCode: structured.error_code,
+      structuredDetails: structured.details,
+      suggestions: structured.suggestions,
+      links: structured.links
+    });
+  }
   const errorType = categorizeErrorType(status);
   const message = extractPrimaryMessage(status, detail, requestError.message);
-  const commonData = {
-    status,
-    statusText,
-    detail
-  };
+  const commonData = { status, statusText, detail };
   if (errorType === "validation" && Array.isArray(detail)) {
     const { errors } = parseValidationErrors(detail);
     return new ValidationError(message, {
@@ -247,6 +270,67 @@ function getErrorMessage(error) {
   }
   return "Unknown error occurred";
 }
+var ResourceError = class extends BusinessError {
+  constructor(message, data) {
+    super(message, data);
+    this.isResourceError = true;
+    this.errorCode = data.errorCode;
+    this.structuredDetails = data.structuredDetails;
+    this.suggestions = data.suggestions;
+    this.links = data.links;
+  }
+};
+function parseStructuredError(detail) {
+  if (!detail || typeof detail !== "object") {
+    return null;
+  }
+  const obj = detail;
+  if (obj.error_code && typeof obj.error_code === "string" && obj.message && typeof obj.message === "string") {
+    return {
+      error_code: obj.error_code,
+      message: obj.message,
+      details: obj.details,
+      suggestions: obj.suggestions,
+      links: obj.links
+    };
+  }
+  return null;
+}
+function formatStructuredError(error, options) {
+  const { showErrorCode = true, showSuggestions = true, showLinks = true } = options ?? {};
+  const parts = [];
+  if (showErrorCode && error.errorCode) {
+    parts.push(`Error [${error.errorCode}]: ${error.message}`);
+  } else {
+    parts.push(error.message);
+  }
+  if (error.structuredDetails && error.structuredDetails.length > 0) {
+    parts.push("");
+    parts.push("Details:");
+    error.structuredDetails.forEach((d) => {
+      if (d.message) {
+        parts.push(`  - ${d.message}`);
+      } else if (d.field && d.value !== void 0) {
+        parts.push(`  - ${d.field}: ${d.value}`);
+      }
+    });
+  }
+  if (showSuggestions && error.suggestions && error.suggestions.length > 0) {
+    parts.push("");
+    parts.push("Suggestions:");
+    error.suggestions.forEach((s) => {
+      parts.push(`  - ${s}`);
+    });
+  }
+  if (showLinks && error.links && error.links.length > 0) {
+    parts.push("");
+    parts.push("Learn more:");
+    error.links.forEach((link) => {
+      parts.push(`  - ${link.label}: ${link.url}`);
+    });
+  }
+  return parts.join("\n");
+}
 
 // src/client.ts
 var SUPPORTED_API_VERSIONS = ["2025-05-31", "2025-10-28"];
@@ -804,10 +888,6 @@ var { action: getAvailableNodes, safeAction: safeGetAvailableNodes } = defineSim
 
 // src/actions/list-instance-types.ts
 import { z as z5 } from "zod";
-var ListInstanceTypesRequestSchema = z5.object({
-  page: z5.number().int().min(1).optional().default(1),
-  page_size: z5.number().int().min(1).max(1e3).optional().default(100)
-}).strict();
 var InstanceTypeSchema = z5.object({
   id: z5.string(),
   name: z5.string(),
@@ -816,22 +896,34 @@ var InstanceTypeSchema = z5.object({
   memory_mb: z5.number(),
   hourly_rate: z5.string(),
   requires_gpu: z5.boolean(),
-  public: z5.boolean(),
-  enabled: z5.boolean()
+  default_disk_size_gb: z5.number().default(20),
+  family: z5.string().nullable()
 }).passthrough();
-var PaginatedInstanceTypesSchema = z5.object({
+var FamilyGroupSchema = z5.object({
+  name: z5.string(),
+  items: z5.array(InstanceTypeSchema),
+  total: z5.number()
+}).strict();
+var AllFamiliesResponseSchema = z5.object({
+  result: z5.array(FamilyGroupSchema)
+}).strict();
+var FamilyInstanceTypesResponseSchema = z5.object({
   items: z5.array(InstanceTypeSchema),
   total: z5.number(),
-  page: z5.number(),
-  page_size: z5.number(),
-  pages: z5.number()
+  family: z5.string()
 }).strict();
-var { action: listInstanceTypes, safeAction: safeListInstanceTypes } = defineAction(PaginatedInstanceTypesSchema, async (client, request) => {
-  const validatedRequest = ListInstanceTypesRequestSchema.parse(request ?? {});
-  const queryParams = new URLSearchParams();
-  queryParams.append("page", validatedRequest.page.toString());
-  queryParams.append("page_size", validatedRequest.page_size.toString());
-  return await client.get(`/api/instance-types?${queryParams.toString()}`);
+var ListFamilyInstanceTypesRequestSchema = z5.object({
+  family: z5.string()
+}).strict();
+var { action: listAllInstanceTypeFamilies, safeAction: safeListAllInstanceTypeFamilies } = defineAction(
+  AllFamiliesResponseSchema,
+  async (client) => {
+    return await client.get("/instance-types");
+  }
+);
+var { action: listFamilyInstanceTypes, safeAction: safeListFamilyInstanceTypes } = defineAction(FamilyInstanceTypesResponseSchema, async (client, request) => {
+  const validated = ListFamilyInstanceTypesRequestSchema.parse(request);
+  return await client.get(`/instance-types/${validated.family}`);
 });
 
 // src/actions/workspaces/list_workspaces.ts
@@ -1051,6 +1143,7 @@ var ProvisionCvmSchema = z10.object({
   fmspc: z10.string().nullable().optional(),
   device_id: z10.string().nullable().optional(),
   os_image_hash: z10.string().nullable().optional(),
+  instance_type: z10.string().nullable().optional(),
   teepod_id: z10.number().nullable().optional(),
   // Will be transformed to node_id
   node_id: z10.number().nullable().optional(),
@@ -1064,19 +1157,24 @@ var ProvisionCvmSchema = z10.object({
 });
 var ProvisionCvmRequestSchema = z10.object({
   node_id: z10.number().optional(),
-  // recommended
+  // recommended - optional, system auto-selects if not specified
   teepod_id: z10.number().optional(),
   // deprecated, for compatibility
+  region: z10.string().optional(),
+  // optional - region filter for auto-selection
   name: z10.string(),
-  image: z10.string(),
-  vcpu: z10.number(),
-  memory: z10.number(),
-  disk_size: z10.number(),
+  instance_type: z10.string().default("tdx.small"),
+  // defaults to "tdx.small"
+  image: z10.string().optional(),
+  vcpu: z10.number().optional(),
+  memory: z10.number().optional(),
+  disk_size: z10.number().optional(),
   compose_file: z10.object({
     allowed_envs: z10.array(z10.string()).optional(),
     pre_launch_script: z10.string().optional(),
     docker_compose_file: z10.string().optional(),
-    name: z10.string().optional(),
+    name: z10.string().optional().default(""),
+    // optional with default empty string
     kms_enabled: z10.boolean().optional(),
     public_logs: z10.boolean().optional(),
     public_sysinfo: z10.boolean().optional(),
@@ -1086,8 +1184,11 @@ var ProvisionCvmRequestSchema = z10.object({
     // deprecated, for compatibility
   }),
   listed: z10.boolean().optional(),
-  instance_type: z10.string().nullable().optional(),
   kms_id: z10.string().optional(),
+  kms: z10.enum(["PHALA", "ETHEREUM", "BASE"]).optional(),
+  // KMS type selection (defaults to PHALA)
+  kms_contract: z10.string().optional(),
+  // KMS contract address for on-chain KMS
   env_keys: z10.array(z10.string()).optional()
 }).passthrough();
 function handleGatewayCompatibility(appCompose) {
@@ -1112,7 +1213,8 @@ function handleGatewayCompatibility(appCompose) {
   };
 }
 var { action: provisionCvm, safeAction: safeProvisionCvm } = defineAction(ProvisionCvmSchema, async (client, appCompose) => {
-  const body = handleGatewayCompatibility(appCompose);
+  const validated = ProvisionCvmRequestSchema.parse(appCompose);
+  const body = handleGatewayCompatibility(validated);
   let requestBody = { ...body };
   if (typeof body.node_id === "number") {
     requestBody = { ...body, teepod_id: body.node_id };
@@ -1156,7 +1258,7 @@ var CommitCvmProvisionSchema = z11.object({
 var CommitCvmProvisionRequestSchema = z11.object({
   encrypted_env: z11.string().optional().nullable(),
   app_id: z11.string(),
-  compose_hash: z11.string().optional(),
+  compose_hash: z11.string(),
   kms_id: z11.string().optional(),
   contract_address: z11.string().optional(),
   deployer_address: z11.string().optional(),
@@ -1369,6 +1471,26 @@ var { action: getAppEnvEncryptPubKey, safeAction: safeGetAppEnvEncryptPubKey } =
   return await client.get(`/kms/${validatedRequest.kms}/pubkey/${validatedRequest.app_id}`);
 });
 
+// src/actions/kms/next_app_ids.ts
+import { z as z18 } from "zod";
+var NextAppIdsRequestSchema = z18.object({
+  counts: z18.number().int().min(1).max(20).optional().default(1)
+}).strict();
+var NextAppIdsSchema = z18.object({
+  app_ids: z18.array(
+    z18.object({
+      app_id: z18.string(),
+      nonce: z18.number().int().min(0)
+    })
+  )
+}).strict();
+var { action: nextAppIds, safeAction: safeNextAppIds } = defineAction(NextAppIdsSchema, async (client, payload) => {
+  const validatedRequest = NextAppIdsRequestSchema.parse(payload ?? {});
+  const params = new URLSearchParams();
+  params.append("counts", validatedRequest.counts.toString());
+  return await client.get(`/kms/phala/next_app_id?${params.toString()}`);
+});
+
 // src/actions/cvms/start_cvm.ts
 var StartCvmRequestSchema = CvmIdSchema;
 var { action: startCvm, safeAction: safeStartCvm } = defineAction(VMSchema, async (client, request) => {
@@ -1394,10 +1516,10 @@ var { action: shutdownCvm, safeAction: safeShutdownCvm } = defineAction(VMSchema
 });
 
 // src/actions/cvms/restart_cvm.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var RestartCvmRequestSchema = refineCvmId(
   CvmIdObjectSchema.extend({
-    force: z18.boolean().optional()
+    force: z19.boolean().optional()
   })
 );
 var { action: restartCvm, safeAction: safeRestartCvm } = defineAction(VMSchema, async (client, request) => {
@@ -1408,10 +1530,10 @@ var { action: restartCvm, safeAction: safeRestartCvm } = defineAction(VMSchema,
 });
 
 // src/actions/cvms/delete_cvm.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var DeleteCvmRequestSchema = CvmIdSchema;
 var { action: deleteCvm, safeAction: safeDeleteCvm } = defineAction(
-  z19.void(),
+  z20.void(),
   async (client, request) => {
     const { cvmId } = DeleteCvmRequestSchema.parse(request);
     await client.delete(`/cvms/${cvmId}`);
@@ -1420,41 +1542,41 @@ var { action: deleteCvm, safeAction: safeDeleteCvm } = defineAction(
 );
 
 // src/actions/cvms/get_cvm_stats.ts
-import { z as z20 } from "zod";
-var DiskInfoSchema = z20.object({
-  name: z20.string(),
-  mount_point: z20.string(),
-  total_size: z20.number(),
-  free_size: z20.number()
+import { z as z21 } from "zod";
+var DiskInfoSchema = z21.object({
+  name: z21.string(),
+  mount_point: z21.string(),
+  total_size: z21.number(),
+  free_size: z21.number()
 });
-var SystemInfoSchema = z20.object({
-  os_name: z20.string(),
-  os_version: z20.string(),
-  kernel_version: z20.string(),
-  cpu_model: z20.string(),
-  num_cpus: z20.number(),
-  total_memory: z20.number(),
-  available_memory: z20.number(),
-  used_memory: z20.number(),
-  free_memory: z20.number(),
-  total_swap: z20.number(),
-  used_swap: z20.number(),
-  free_swap: z20.number(),
-  uptime: z20.number(),
-  loadavg_one: z20.number(),
-  loadavg_five: z20.number(),
-  loadavg_fifteen: z20.number(),
-  disks: z20.array(DiskInfoSchema)
+var SystemInfoSchema = z21.object({
+  os_name: z21.string(),
+  os_version: z21.string(),
+  kernel_version: z21.string(),
+  cpu_model: z21.string(),
+  num_cpus: z21.number(),
+  total_memory: z21.number(),
+  available_memory: z21.number(),
+  used_memory: z21.number(),
+  free_memory: z21.number(),
+  total_swap: z21.number(),
+  used_swap: z21.number(),
+  free_swap: z21.number(),
+  uptime: z21.number(),
+  loadavg_one: z21.number(),
+  loadavg_five: z21.number(),
+  loadavg_fifteen: z21.number(),
+  disks: z21.array(DiskInfoSchema)
 });
-var CvmSystemInfoSchema = z20.object({
-  is_online: z20.boolean(),
-  is_public: z20.boolean().default(false),
-  error: z20.string().nullable(),
+var CvmSystemInfoSchema = z21.object({
+  is_online: z21.boolean(),
+  is_public: z21.boolean().default(false),
+  error: z21.string().nullable(),
   sysinfo: SystemInfoSchema.nullable(),
-  status: z20.string().nullable(),
-  in_progress: z20.boolean().default(false),
-  boot_progress: z20.string().nullable(),
-  boot_error: z20.string().nullable()
+  status: z21.string().nullable(),
+  in_progress: z21.boolean().default(false),
+  boot_progress: z21.string().nullable(),
+  boot_error: z21.string().nullable()
 });
 var GetCvmStatsRequestSchema = CvmIdSchema;
 var { action: getCvmStats, safeAction: safeGetCvmStats } = defineAction(CvmSystemInfoSchema, async (client, request) => {
@@ -1463,18 +1585,18 @@ var { action: getCvmStats, safeAction: safeGetCvmStats } = defineAction(CvmSyste
 });
 
 // src/actions/cvms/get_cvm_network.ts
-import { z as z21 } from "zod";
-var CvmNetworkUrlsSchema2 = z21.object({
-  app: z21.string(),
-  instance: z21.string()
+import { z as z22 } from "zod";
+var CvmNetworkUrlsSchema2 = z22.object({
+  app: z22.string(),
+  instance: z22.string()
 });
-var CvmNetworkSchema = z21.object({
-  is_online: z21.boolean(),
-  is_public: z21.boolean().default(true),
-  error: z21.string().nullable(),
-  internal_ip: z21.string().nullable(),
-  latest_handshake: z21.string().nullable(),
-  public_urls: z21.array(CvmNetworkUrlsSchema2).nullable()
+var CvmNetworkSchema = z22.object({
+  is_online: z22.boolean(),
+  is_public: z22.boolean().default(true),
+  error: z22.string().nullable(),
+  internal_ip: z22.string().nullable(),
+  latest_handshake: z22.string().nullable(),
+  public_urls: z22.array(CvmNetworkUrlsSchema2).nullable()
 });
 var GetCvmNetworkRequestSchema = CvmIdSchema;
 var { action: getCvmNetwork, safeAction: safeGetCvmNetwork } = defineAction(CvmNetworkSchema, async (client, request) => {
@@ -1483,36 +1605,36 @@ var { action: getCvmNetwork, safeAction: safeGetCvmNetwork } = defineAction(CvmN
 });
 
 // src/actions/cvms/get_cvm_docker_compose.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var GetCvmDockerComposeRequestSchema = CvmIdSchema;
-var { action: getCvmDockerCompose, safeAction: safeGetCvmDockerCompose } = defineAction(z22.string(), async (client, request) => {
+var { action: getCvmDockerCompose, safeAction: safeGetCvmDockerCompose } = defineAction(z23.string(), async (client, request) => {
   const { cvmId } = GetCvmDockerComposeRequestSchema.parse(request);
   return await client.get(`/cvms/${cvmId}/docker-compose.yml`);
 });
 
 // src/actions/cvms/get_cvm_containers_stats.ts
-import { z as z23 } from "zod";
-var ContainerInfoSchema = z23.object({
-  id: z23.string(),
-  names: z23.array(z23.string()),
-  image: z23.string(),
-  image_id: z23.string(),
-  command: z23.string().nullable().optional(),
-  created: z23.number(),
-  state: z23.string(),
-  status: z23.string(),
-  log_endpoint: z23.string().nullable()
+import { z as z24 } from "zod";
+var ContainerInfoSchema = z24.object({
+  id: z24.string(),
+  names: z24.array(z24.string()),
+  image: z24.string(),
+  image_id: z24.string(),
+  command: z24.string().nullable().optional(),
+  created: z24.number(),
+  state: z24.string(),
+  status: z24.string(),
+  log_endpoint: z24.string().nullable()
 });
-var CvmContainersStatsSchema = z23.object({
-  is_online: z23.boolean(),
-  is_public: z23.boolean().default(true),
-  error: z23.string().nullable(),
-  docker_compose_file: z23.string().nullable(),
-  manifest_version: z23.number().nullable(),
-  version: z23.string().nullable(),
-  runner: z23.string().nullable(),
-  features: z23.array(z23.string()).nullable(),
-  containers: z23.array(ContainerInfoSchema).nullable()
+var CvmContainersStatsSchema = z24.object({
+  is_online: z24.boolean(),
+  is_public: z24.boolean().default(true),
+  error: z24.string().nullable(),
+  docker_compose_file: z24.string().nullable(),
+  manifest_version: z24.number().nullable(),
+  version: z24.string().nullable(),
+  runner: z24.string().nullable(),
+  features: z24.array(z24.string()).nullable(),
+  containers: z24.array(ContainerInfoSchema).nullable()
 });
 var GetCvmContainersStatsRequestSchema = CvmIdSchema;
 var { action: getCvmContainersStats, safeAction: safeGetCvmContainersStats } = defineAction(CvmContainersStatsSchema, async (client, request) => {
@@ -1521,62 +1643,62 @@ var { action: getCvmContainersStats, safeAction: safeGetCvmContainersStats } = d
 });
 
 // src/actions/cvms/get_cvm_attestation.ts
-import { z as z24 } from "zod";
-var CertificateSubjectSchema = z24.object({
-  common_name: z24.string().nullable(),
-  organization: z24.string().nullable(),
-  country: z24.string().nullable(),
-  state: z24.string().nullable(),
-  locality: z24.string().nullable()
+import { z as z25 } from "zod";
+var CertificateSubjectSchema = z25.object({
+  common_name: z25.string().nullable(),
+  organization: z25.string().nullable(),
+  country: z25.string().nullable(),
+  state: z25.string().nullable(),
+  locality: z25.string().nullable()
 });
-var CertificateIssuerSchema = z24.object({
-  common_name: z24.string().nullable(),
-  organization: z24.string().nullable(),
-  country: z24.string().nullable()
+var CertificateIssuerSchema = z25.object({
+  common_name: z25.string().nullable(),
+  organization: z25.string().nullable(),
+  country: z25.string().nullable()
 });
-var CertificateSchema = z24.object({
+var CertificateSchema = z25.object({
   subject: CertificateSubjectSchema,
   issuer: CertificateIssuerSchema,
-  serial_number: z24.string(),
-  not_before: z24.string(),
+  serial_number: z25.string(),
+  not_before: z25.string(),
   // datetime serialized as ISO string
-  not_after: z24.string(),
+  not_after: z25.string(),
   // datetime serialized as ISO string
-  version: z24.string(),
-  fingerprint: z24.string(),
-  signature_algorithm: z24.string(),
-  sans: z24.array(z24.string()).nullable(),
-  is_ca: z24.boolean(),
-  position_in_chain: z24.number().nullable(),
-  quote: z24.string().nullable(),
-  app_id: z24.string().nullable().optional(),
-  cert_usage: z24.string().nullable().optional()
+  version: z25.string(),
+  fingerprint: z25.string(),
+  signature_algorithm: z25.string(),
+  sans: z25.array(z25.string()).nullable(),
+  is_ca: z25.boolean(),
+  position_in_chain: z25.number().nullable(),
+  quote: z25.string().nullable(),
+  app_id: z25.string().nullable().optional(),
+  cert_usage: z25.string().nullable().optional()
 });
-var EventLogSchema = z24.object({
-  imr: z24.number(),
-  event_type: z24.number(),
-  digest: z24.string(),
-  event: z24.string(),
-  event_payload: z24.string()
+var EventLogSchema = z25.object({
+  imr: z25.number(),
+  event_type: z25.number(),
+  digest: z25.string(),
+  event: z25.string(),
+  event_payload: z25.string()
 });
-var TcbInfoSchema = z24.object({
-  mrtd: z24.string(),
-  rootfs_hash: z24.string().nullable().optional(),
-  rtmr0: z24.string(),
-  rtmr1: z24.string(),
-  rtmr2: z24.string(),
-  rtmr3: z24.string(),
-  event_log: z24.array(EventLogSchema),
-  app_compose: z24.string()
+var TcbInfoSchema = z25.object({
+  mrtd: z25.string(),
+  rootfs_hash: z25.string().nullable().optional(),
+  rtmr0: z25.string(),
+  rtmr1: z25.string(),
+  rtmr2: z25.string(),
+  rtmr3: z25.string(),
+  event_log: z25.array(EventLogSchema),
+  app_compose: z25.string()
 });
-var CvmAttestationSchema = z24.object({
-  name: z24.string().nullable(),
-  is_online: z24.boolean(),
-  is_public: z24.boolean().default(true),
-  error: z24.string().nullable(),
-  app_certificates: z24.array(CertificateSchema).nullable(),
+var CvmAttestationSchema = z25.object({
+  name: z25.string().nullable(),
+  is_online: z25.boolean(),
+  is_public: z25.boolean().default(true),
+  error: z25.string().nullable(),
+  app_certificates: z25.array(CertificateSchema).nullable(),
   tcb_info: TcbInfoSchema.nullable(),
-  compose_file: z24.string().nullable()
+  compose_file: z25.string().nullable()
 });
 var GetCvmAttestationRequestSchema = CvmIdSchema;
 var { action: getCvmAttestation, safeAction: safeGetCvmAttestation } = defineAction(CvmAttestationSchema, async (client, request) => {
@@ -1585,17 +1707,17 @@ var { action: getCvmAttestation, safeAction: safeGetCvmAttestation } = defineAct
 });
 
 // src/actions/cvms/update_cvm_resources.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 var UpdateCvmResourcesRequestSchema = refineCvmId(
   CvmIdObjectSchema.extend({
-    vcpu: z25.number().optional(),
-    memory: z25.number().optional(),
-    disk_size: z25.number().optional(),
-    instance_type: z25.string().optional(),
-    allow_restart: z25.boolean().optional()
+    vcpu: z26.number().optional(),
+    memory: z26.number().optional(),
+    disk_size: z26.number().optional(),
+    instance_type: z26.string().optional(),
+    allow_restart: z26.boolean().optional()
   })
 );
-var { action: updateCvmResources, safeAction: safeUpdateCvmResources } = defineAction(z25.void(), async (client, request) => {
+var { action: updateCvmResources, safeAction: safeUpdateCvmResources } = defineAction(z26.void(), async (client, request) => {
   const parsed = UpdateCvmResourcesRequestSchema.parse(request);
   const { cvmId } = CvmIdSchema.parse(parsed);
   const { ...body } = parsed;
@@ -1604,11 +1726,11 @@ var { action: updateCvmResources, safeAction: safeUpdateCvmResources } = defineA
 });
 
 // src/actions/cvms/update_cvm_visibility.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var UpdateCvmVisibilityRequestSchema = refineCvmId(
   CvmIdObjectSchema.extend({
-    public_sysinfo: z26.boolean(),
-    public_logs: z26.boolean()
+    public_sysinfo: z27.boolean(),
+    public_logs: z27.boolean()
   })
 );
 var { action: updateCvmVisibility, safeAction: safeUpdateCvmVisibility } = defineAction(CvmLegacyDetailSchema, async (client, request) => {
@@ -1618,6 +1740,59 @@ var { action: updateCvmVisibility, safeAction: safeUpdateCvmVisibility } = defin
   return await client.patch(`/cvms/${cvmId}/visibility`, { public_sysinfo, public_logs });
 });
 
+// src/actions/cvms/get_available_os_images.ts
+import { z as z28 } from "zod";
+var OSImageVariantSchema = z28.object({
+  name: z28.string(),
+  os_image_hash: z28.string().nullable(),
+  is_current: z28.boolean()
+});
+var AvailableOSImageSchema2 = z28.object({
+  version: z28.union([
+    z28.tuple([z28.number(), z28.number(), z28.number(), z28.number()]),
+    z28.tuple([z28.number(), z28.number(), z28.number()])
+  ]),
+  prod: OSImageVariantSchema.nullable(),
+  dev: OSImageVariantSchema.nullable()
+});
+var GetAvailableOSImagesResponseSchema = z28.array(AvailableOSImageSchema2);
+var GetAvailableOSImagesRequestSchema = CvmIdSchema;
+var { action: getAvailableOsImages, safeAction: safeGetAvailableOsImages } = defineAction(GetAvailableOSImagesResponseSchema, async (client, request) => {
+  const { cvmId } = GetAvailableOSImagesRequestSchema.parse(request);
+  return await client.get(`/cvms/${cvmId}/available-os-images`);
+});
+
+// src/actions/cvms/update_os_image.ts
+import { z as z29 } from "zod";
+var UpdateOsImageRequestSchema = refineCvmId(
+  CvmIdObjectSchema.extend({
+    os_image_name: z29.string().min(1, "OS image name is required")
+  })
+);
+var { action: updateOsImage, safeAction: safeUpdateOsImage } = defineAction(z29.void(), async (client, request) => {
+  const parsed = UpdateOsImageRequestSchema.parse(request);
+  const { cvmId } = CvmIdSchema.parse(parsed);
+  const { os_image_name } = parsed;
+  await client.patch(`/cvms/${cvmId}/os-image`, { os_image_name });
+  return void 0;
+});
+
+// src/actions/cvms/get_cvm_state.ts
+import { z as z30 } from "zod";
+var CvmStateSchema = z30.object({
+  status: z30.string(),
+  derived_status: z30.string().optional(),
+  vm_uuid: z30.string().optional(),
+  instance_id: z30.string().optional(),
+  uptime: z30.string().optional()
+  // Add other state fields as needed
+});
+var GetCvmStateRequestSchema = CvmIdSchema;
+var { action: getCvmState, safeAction: safeGetCvmState } = defineAction(CvmStateSchema, async (client, request) => {
+  const { cvmId } = GetCvmStateRequestSchema.parse(request);
+  return await client.get(`/cvms/${cvmId}/state`);
+});
+
 // src/create-client.ts
 function createClient2(config = {}) {
   const client = createClient(config);
@@ -1626,8 +1801,10 @@ function createClient2(config = {}) {
     safeGetCurrentUser,
     getAvailableNodes,
     safeGetAvailableNodes,
-    listInstanceTypes,
-    safeListInstanceTypes,
+    listAllInstanceTypeFamilies,
+    safeListAllInstanceTypeFamilies,
+    listFamilyInstanceTypes,
+    safeListFamilyInstanceTypes,
     listWorkspaces,
     safeListWorkspaces,
     getWorkspace,
@@ -1670,18 +1847,26 @@ function createClient2(config = {}) {
     safeUpdateCvmResources,
     updateCvmVisibility,
     safeUpdateCvmVisibility,
+    getAvailableOsImages,
+    safeGetAvailableOsImages,
+    updateOsImage,
+    safeUpdateOsImage,
     getKmsInfo,
     safeGetKmsInfo,
     getKmsList,
     safeGetKmsList,
     getAppEnvEncryptPubKey,
-    safeGetAppEnvEncryptPubKey
+    safeGetAppEnvEncryptPubKey,
+    nextAppIds,
+    safeNextAppIds,
+    getCvmState,
+    safeGetCvmState
   };
   return client.extend(allActions);
 }
 
 // src/actions/blockchains/deploy_app_auth.ts
-import { z as z27 } from "zod";
+import { z as z31 } from "zod";
 import {
   createPublicClient as createPublicClient2,
   createWalletClient as createWalletClient2,
@@ -2342,25 +2527,25 @@ var kmsAuthAbi = [
     anonymous: false
   }
 ];
-var DeployAppAuthRequestBaseSchema = z27.object({
+var DeployAppAuthRequestBaseSchema = z31.object({
   // Chain configuration (conditionally required)
-  chain: z27.unknown().optional(),
-  rpcUrl: z27.string().optional(),
+  chain: z31.unknown().optional(),
+  rpcUrl: z31.string().optional(),
   // Contract configuration (required)
-  kmsContractAddress: z27.string(),
+  kmsContractAddress: z31.string(),
   // Authentication mode: either privateKey OR walletClient (required, mutually exclusive)
-  privateKey: z27.string().optional(),
-  walletClient: z27.unknown().optional(),
+  privateKey: z31.string().optional(),
+  walletClient: z31.unknown().optional(),
   // Public client (optional, will create default if not provided)
-  publicClient: z27.unknown().optional(),
+  publicClient: z31.unknown().optional(),
   // App configuration (optional)
-  allowAnyDevice: z27.boolean().optional().default(false),
-  deviceId: z27.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
-  composeHash: z27.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
-  disableUpgrades: z27.boolean().optional().default(false),
+  allowAnyDevice: z31.boolean().optional().default(false),
+  deviceId: z31.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
+  composeHash: z31.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
+  disableUpgrades: z31.boolean().optional().default(false),
   // Validation configuration (optional)
-  skipPrerequisiteChecks: z27.boolean().optional().default(false),
-  minBalance: z27.string().optional()
+  skipPrerequisiteChecks: z31.boolean().optional().default(false),
+  minBalance: z31.string().optional()
   // ETH amount as string, e.g., "0.01"
 }).passthrough();
 var DeployAppAuthRequestSchema = DeployAppAuthRequestBaseSchema.refine(
@@ -2388,13 +2573,13 @@ var DeployAppAuthRequestSchema = DeployAppAuthRequestBaseSchema.refine(
     path: ["chain"]
   }
 );
-var DeployAppAuthSchema = z27.object({
-  appId: z27.string(),
-  appAuthAddress: z27.string(),
-  deployer: z27.string(),
-  transactionHash: z27.string(),
-  blockNumber: z27.bigint().optional(),
-  gasUsed: z27.bigint().optional()
+var DeployAppAuthSchema = z31.object({
+  appId: z31.string(),
+  appAuthAddress: z31.string(),
+  deployer: z31.string(),
+  transactionHash: z31.string(),
+  blockNumber: z31.bigint().optional(),
+  gasUsed: z31.bigint().optional()
 }).passthrough();
 function parseDeploymentResult(receipt, deployer, kmsContractAddress) {
   try {
@@ -2640,7 +2825,7 @@ async function safeDeployAppAuth(request, parameters) {
 }
 
 // src/actions/blockchains/add_compose_hash.ts
-import { z as z28 } from "zod";
+import { z as z32 } from "zod";
 import {
   createPublicClient as createPublicClient3,
   createWalletClient as createWalletClient3,
@@ -2664,29 +2849,29 @@ var appAuthAbi = [
     anonymous: false
   }
 ];
-var AddComposeHashRequestSchema = z28.object({
+var AddComposeHashRequestSchema = z32.object({
   // Chain configuration (conditionally required)
-  chain: z28.unknown().optional(),
-  rpcUrl: z28.string().optional(),
-  appId: z28.string(),
-  composeHash: z28.string(),
+  chain: z32.unknown().optional(),
+  rpcUrl: z32.string().optional(),
+  appId: z32.string(),
+  composeHash: z32.string(),
   // Authentication mode: either privateKey OR walletClient (required, mutually exclusive)
-  privateKey: z28.string().optional(),
-  walletClient: z28.unknown().optional(),
+  privateKey: z32.string().optional(),
+  walletClient: z32.unknown().optional(),
   // Public client (optional, will create default if not provided)
-  publicClient: z28.unknown().optional(),
+  publicClient: z32.unknown().optional(),
   // Validation configuration (optional)
-  skipPrerequisiteChecks: z28.boolean().optional().default(false),
-  minBalance: z28.string().optional(),
+  skipPrerequisiteChecks: z32.boolean().optional().default(false),
+  minBalance: z32.string().optional(),
   // ETH amount as string, e.g., "0.01"
   // Transaction control options
-  timeout: z28.number().optional().default(12e4),
-  retryOptions: z28.unknown().optional(),
-  signal: z28.unknown().optional(),
+  timeout: z32.number().optional().default(12e4),
+  retryOptions: z32.unknown().optional(),
+  signal: z32.unknown().optional(),
   // Progress callbacks
-  onTransactionStateChange: z28.function().optional(),
-  onTransactionSubmitted: z28.function().optional(),
-  onTransactionConfirmed: z28.function().optional()
+  onTransactionStateChange: z32.function().optional(),
+  onTransactionSubmitted: z32.function().optional(),
+  onTransactionConfirmed: z32.function().optional()
 }).passthrough().refine(
   (data) => {
     const hasPrivateKey = !!data.privateKey;
@@ -2710,12 +2895,12 @@ var AddComposeHashRequestSchema = z28.object({
     path: ["chain"]
   }
 );
-var AddComposeHashSchema = z28.object({
-  composeHash: z28.string(),
-  appId: z28.string(),
-  transactionHash: z28.string(),
-  blockNumber: z28.bigint().optional(),
-  gasUsed: z28.bigint().optional()
+var AddComposeHashSchema = z32.object({
+  composeHash: z32.string(),
+  appId: z32.string(),
+  transactionHash: z32.string(),
+  blockNumber: z32.bigint().optional(),
+  gasUsed: z32.bigint().optional()
 }).passthrough();
 function parseComposeHashResult(receipt, composeHash, appAuthAddress, appId) {
   console.log(receipt.logs);
@@ -2906,6 +3091,200 @@ async function safeAddComposeHash(request, parameters) {
   }
 }
 
+// src/actions/cvms/watch_cvm_state.ts
+import { z as z33 } from "zod";
+var WatchCvmStateParamsSchema = z33.object({
+  target: z33.string().describe("Target status to wait for (e.g., 'running', 'stopped')"),
+  interval: z33.number().min(5).max(30).default(5).describe("Polling interval in seconds"),
+  timeout: z33.number().min(10).max(600).default(300).describe("Timeout per attempt in seconds"),
+  maxRetries: z33.number().min(0).default(Number.POSITIVE_INFINITY).describe("Maximum number of retry attempts (Infinity for unlimited)"),
+  retryDelay: z33.number().min(0).default(5e3).describe("Delay between retries in milliseconds")
+});
+var WatchCvmStateRequestSchema = WatchCvmStateParamsSchema;
+var WatchAbortedError = class extends Error {
+  constructor() {
+    super("Watch operation was aborted");
+    this.name = "WatchAbortedError";
+  }
+};
+var MaxRetriesExceededError = class extends Error {
+  constructor(attempts) {
+    super(`Maximum retry attempts (${attempts}) exceeded`);
+    this.attempts = attempts;
+    this.name = "MaxRetriesExceededError";
+  }
+};
+function parseSSEEvent(eventType, data) {
+  try {
+    const parsed = JSON.parse(data);
+    return { type: eventType, data: parsed };
+  } catch {
+    return { type: "error", data: { error: "Failed to parse SSE event" } };
+  }
+}
+async function watchCvmState(client, request, options = {}) {
+  const { cvmId } = CvmIdSchema.parse(request);
+  const { target, interval, timeout, maxRetries, retryDelay } = WatchCvmStateParamsSchema.parse(request);
+  const { signal, onEvent } = options;
+  let attempt = 0;
+  while (attempt < maxRetries) {
+    if (signal?.aborted) {
+      throw new WatchAbortedError();
+    }
+    attempt++;
+    try {
+      const result = await watchSingleAttempt(
+        client,
+        cvmId,
+        target,
+        interval,
+        timeout,
+        signal,
+        onEvent
+      );
+      if (result) {
+        return result;
+      }
+      if (attempt >= maxRetries) {
+        throw new MaxRetriesExceededError(attempt);
+      }
+      await sleep(retryDelay, signal);
+    } catch (error) {
+      if (signal?.aborted) {
+        throw new WatchAbortedError();
+      }
+      if (error instanceof WatchAbortedError || error instanceof MaxRetriesExceededError) {
+        throw error;
+      }
+      if (attempt >= maxRetries) {
+        throw error;
+      }
+      if (onEvent) {
+        onEvent({
+          type: "error",
+          data: { error: error instanceof Error ? error.message : String(error) }
+        });
+      }
+      await sleep(retryDelay, signal);
+    }
+  }
+  throw new MaxRetriesExceededError(attempt);
+}
+async function watchSingleAttempt(client, cvmId, target, interval, timeout, signal, onEvent) {
+  const params = new URLSearchParams({
+    target,
+    interval: String(interval),
+    timeout: String(timeout)
+  });
+  const baseURL = client.config.baseURL || "";
+  const fullUrl = `${baseURL}/cvms/${cvmId}/state?${params.toString()}`;
+  const headers = {
+    Accept: "text/event-stream",
+    "Cache-Control": "no-cache"
+  };
+  if (!client.config.useCookieAuth && client.config.apiKey) {
+    headers["X-API-Key"] = client.config.apiKey;
+  }
+  if (client.config.headers) {
+    Object.entries(client.config.headers).forEach(([key, value]) => {
+      if (typeof value === "string") {
+        headers[key] = value;
+      }
+    });
+  }
+  const response = await client.raw.native(fullUrl, {
+    method: "GET",
+    headers,
+    signal,
+    ...client.config.useCookieAuth ? { credentials: "include" } : {}
+  });
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  }
+  if (!response.body) {
+    throw new Error("Response body is null");
+  }
+  return parseSSEStream(response.body, signal, onEvent);
+}
+async function parseSSEStream(stream, signal, onEvent) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let finalState = null;
+  let currentEvent = "";
+  let currentData = "";
+  const processLine = (line) => {
+    if (line.startsWith("event:")) {
+      currentEvent = line.slice(6).trim();
+    } else if (line.startsWith("data:")) {
+      currentData = line.slice(5).trim();
+    } else if (line === "") {
+      if (currentEvent && currentData) {
+        const event = parseSSEEvent(currentEvent, currentData);
+        if (event.type === "state") {
+          finalState = event.data;
+        }
+        onEvent?.(event);
+        if (event.type === "complete") {
+          return "complete";
+        }
+        if (event.type === "timeout") {
+          return "timeout";
+        }
+      }
+      currentEvent = "";
+      currentData = "";
+    }
+    return null;
+  };
+  try {
+    while (true) {
+      if (signal?.aborted) {
+        throw new WatchAbortedError();
+      }
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const result = processLine(line.trim());
+        if (result === "complete") {
+          return finalState;
+        }
+        if (result === "timeout") {
+          return null;
+        }
+      }
+    }
+    return finalState;
+  } catch (error) {
+    if (error instanceof WatchAbortedError) {
+      throw error;
+    }
+    throw new Error(`SSE stream error: ${error instanceof Error ? error.message : String(error)}`);
+  } finally {
+    reader.releaseLock();
+  }
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new WatchAbortedError());
+      return;
+    }
+    const timer = setTimeout(resolve, ms);
+    if (signal) {
+      signal.addEventListener("abort", () => {
+        clearTimeout(timer);
+        reject(new WatchAbortedError());
+      });
+    }
+  });
+}
+
 // src/parse_dotenv.ts
 var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
 function parseEnv(input) {
@@ -2945,6 +3324,7 @@ import { getComposeHash as getComposeHash2 } from "@phala/dstack-sdk/get-compose
 import { verifyEnvEncryptPublicKey } from "@phala/dstack-sdk/verify-env-encrypt-public-key";
 export {
   AddComposeHashSchema,
+  AllFamiliesResponseSchema,
   ApiErrorSchema,
   AuthError,
   AvailableNodesSchema,
@@ -2964,12 +3344,17 @@ export {
   CvmNetworkSchema,
   CvmNetworkUrlsSchema,
   CvmNodeSchema,
+  CvmStateSchema,
   CvmSystemInfoSchema,
   DeleteCvmRequestSchema,
   DeployAppAuthRequestSchema,
   DeployAppAuthSchema,
+  FamilyGroupSchema,
+  FamilyInstanceTypesResponseSchema,
   GetAppEnvEncryptPubKeyRequestSchema,
   GetAppEnvEncryptPubKeySchema,
+  GetAvailableOSImagesRequestSchema,
+  GetAvailableOSImagesResponseSchema,
   GetCvmAttestationRequestSchema,
   GetCvmComposeFileRequestSchema,
   GetCvmContainersStatsRequestSchema,
@@ -2978,17 +3363,21 @@ export {
   GetCvmListRequestSchema,
   GetCvmListSchema,
   GetCvmNetworkRequestSchema,
+  GetCvmStateRequestSchema,
   GetCvmStatsRequestSchema,
   GetKmsInfoRequestSchema,
   GetKmsListRequestSchema,
   GetKmsListSchema,
   InstanceTypeSchema,
   KmsInfoSchema,
-  ListInstanceTypesRequestSchema,
+  ListFamilyInstanceTypesRequestSchema,
   ListWorkspacesSchema,
   ManagedUserSchema,
+  MaxRetriesExceededError,
   NetworkError,
-  PaginatedInstanceTypesSchema,
+  NextAppIdsRequestSchema,
+  NextAppIdsSchema,
+  OSImageVariantSchema,
   PaginationMetadataSchema,
   PhalaCloudError,
   ProvisionCvmComposeFileUpdateRequestSchema,
@@ -2996,6 +3385,7 @@ export {
   ProvisionCvmRequestSchema,
   ProvisionCvmSchema,
   RequestError,
+  ResourceError,
   RestartCvmRequestSchema,
   SUPPORTED_CHAINS,
   ServerError,
@@ -3006,10 +3396,13 @@ export {
   UnknownError,
   UpdateCvmResourcesRequestSchema,
   UpdateCvmVisibilityRequestSchema,
+  UpdateOsImageRequestSchema,
   VMSchema,
   ValidationError,
   VmInfoSchema,
   WalletError,
+  WatchAbortedError,
+  WatchCvmStateRequestSchema,
   WorkspaceResponseSchema,
   addComposeHash,
   addNetwork,
@@ -3037,9 +3430,11 @@ export {
   executeTransactionWithRetry,
   extractNetworkClients,
   formatErrorMessage,
+  formatStructuredError,
   formatValidationErrors,
   getAppEnvEncryptPubKey,
   getAvailableNodes,
+  getAvailableOsImages,
   getComposeHash2 as getComposeHash,
   getCurrentUser,
   getCvmAttestation,
@@ -3049,14 +3444,17 @@ export {
   getCvmInfo,
   getCvmList,
   getCvmNetwork,
+  getCvmState,
   getCvmStats,
   getErrorMessage,
   getKmsInfo,
   getKmsList,
   getValidationFields,
   getWorkspace,
-  listInstanceTypes,
+  listAllInstanceTypeFamilies,
+  listFamilyInstanceTypes,
   listWorkspaces,
+  nextAppIds,
   parseApiError,
   parseEnv,
   parseEnvVars,
@@ -3072,6 +3470,7 @@ export {
   safeDeployAppAuth,
   safeGetAppEnvEncryptPubKey,
   safeGetAvailableNodes,
+  safeGetAvailableOsImages,
   safeGetCurrentUser,
   safeGetCvmAttestation,
   safeGetCvmComposeFile,
@@ -3080,12 +3479,15 @@ export {
   safeGetCvmInfo,
   safeGetCvmList,
   safeGetCvmNetwork,
+  safeGetCvmState,
   safeGetCvmStats,
   safeGetKmsInfo,
   safeGetKmsList,
   safeGetWorkspace,
-  safeListInstanceTypes,
+  safeListAllInstanceTypeFamilies,
+  safeListFamilyInstanceTypes,
   safeListWorkspaces,
+  safeNextAppIds,
   safeProvisionCvm,
   safeProvisionCvmComposeFileUpdate,
   safeRestartCvm,
@@ -3094,6 +3496,7 @@ export {
   safeStopCvm,
   safeUpdateCvmResources,
   safeUpdateCvmVisibility,
+  safeUpdateOsImage,
   safeValidateActionParameters,
   shutdownCvm,
   sortObject,
@@ -3102,9 +3505,11 @@ export {
   switchToNetwork,
   updateCvmResources,
   updateCvmVisibility,
+  updateOsImage,
   validateActionParameters,
   validateNetworkPrerequisites,
   verifyEnvEncryptPublicKey,
   waitForTransactionReceipt,
+  watchCvmState,
   withComposeMethods
 };