@phala/cloud 0.2.1-beta.3 → 0.2.1

package/dist/index.js

@@ -33,33 +33,65 @@ __export(index_exports, {
   AddComposeHashSchema: () => AddComposeHashSchema,
   AllFamiliesResponseSchema: () => AllFamiliesResponseSchema,
   ApiErrorSchema: () => ApiErrorSchema,
+  AppRevisionDetailResponseSchema: () => AppRevisionDetailResponseSchema,
+  AppRevisionResponseSchema: () => AppRevisionResponseSchema,
+  AppRevisionsResponseSchema: () => AppRevisionsResponseSchema,
   AuthError: () => AuthError,
+  AuthResponseSchema: () => CurrentUserV20260121Schema,
   AvailableNodesSchema: () => AvailableNodesSchema,
+  BillingPeriodSchema: () => BillingPeriodSchema,
   BusinessError: () => BusinessError,
   CommitCvmComposeFileUpdateRequestSchema: () => CommitCvmComposeFileUpdateRequestSchema,
   CommitCvmComposeFileUpdateSchema: () => CommitCvmComposeFileUpdateSchema,
   CommitCvmProvisionRequestSchema: () => CommitCvmProvisionRequestSchema,
   CommitCvmProvisionSchema: () => CommitCvmProvisionSchema,
-  CurrentUserSchema: () => CurrentUserSchema,
+  CreditsInfoSchema: () => CreditsInfoSchema,
+  CurrentUserSchema: () => CurrentUserV20251028Schema,
+  CurrentUserV20251028Schema: () => CurrentUserV20251028Schema,
+  CurrentUserV20260121Schema: () => CurrentUserV20260121Schema,
   CvmAttestationSchema: () => CvmAttestationSchema,
+  CvmBasicInfoV20251028Schema: () => CvmBasicInfoV20251028Schema,
   CvmContainersStatsSchema: () => CvmContainersStatsSchema,
+  CvmDetailV20251028Schema: () => CvmDetailV20251028Schema,
+  CvmGatewayInfoV20260121Schema: () => CvmGatewayInfoV20260121Schema,
   CvmIdBaseSchema: () => CvmIdBaseSchema,
   CvmIdObjectSchema: () => CvmIdObjectSchema,
   CvmIdSchema: () => CvmIdSchema,
-  CvmInfoSchema: () => CvmInfoSchema,
-  CvmLegacyDetailSchema: () => CvmLegacyDetailSchema,
+  CvmInfoDetailV20260121Schema: () => CvmInfoDetailV20260121Schema,
+  CvmInfoV20251028Schema: () => CvmInfoV20251028Schema,
+  CvmInfoV20260121Schema: () => CvmInfoV20260121Schema,
+  CvmKmsInfoV20260121Schema: () => CvmKmsInfoV20260121Schema,
   CvmNetworkSchema: () => CvmNetworkSchema,
-  CvmNetworkUrlsSchema: () => CvmNetworkUrlsSchema,
-  CvmNodeSchema: () => CvmNodeSchema,
+  CvmNetworkUrlsV20251028Schema: () => CvmNetworkUrlsV20251028Schema,
+  CvmNodeInfoV20260121Schema: () => CvmNodeInfoV20260121Schema,
+  CvmNodeV20251028Schema: () => CvmNodeV20251028Schema,
+  CvmOsInfoV20260121Schema: () => CvmOsInfoV20260121Schema,
+  CvmProgressInfoV20260121Schema: () => CvmProgressInfoV20260121Schema,
+  CvmRefSchema: () => CvmRefSchema,
+  CvmResourceInfoV20260121Schema: () => CvmResourceInfoV20260121Schema,
   CvmStateSchema: () => CvmStateSchema,
+  CvmStatusSchema: () => CvmStatusSchema,
   CvmSystemInfoSchema: () => CvmSystemInfoSchema,
   DeleteCvmRequestSchema: () => DeleteCvmRequestSchema,
   DeployAppAuthRequestSchema: () => DeployAppAuthRequestSchema,
   DeployAppAuthSchema: () => DeployAppAuthSchema,
+  DstackAppFullResponseV20251028Schema: () => DstackAppFullResponseV20251028Schema,
+  DstackAppFullResponseV20260121Schema: () => DstackAppFullResponseV20260121Schema,
+  DstackAppListResponseV20251028Schema: () => DstackAppListResponseV20251028Schema,
+  DstackAppListResponseV20260121Schema: () => DstackAppListResponseV20260121Schema,
+  DstackAppMinimalResponseV20251028Schema: () => DstackAppMinimalResponseV20251028Schema,
+  DstackAppMinimalResponseV20260121Schema: () => DstackAppMinimalResponseV20260121Schema,
+  DstackAppWithCvmResponseV20251028Schema: () => DstackAppWithCvmResponseV20251028Schema,
+  DstackAppWithCvmResponseV20260121Schema: () => DstackAppWithCvmResponseV20260121Schema,
   FamilyGroupSchema: () => FamilyGroupSchema,
   FamilyInstanceTypesResponseSchema: () => FamilyInstanceTypesResponseSchema,
+  GetAppCvmsRequestSchema: () => GetAppCvmsRequestSchema,
   GetAppEnvEncryptPubKeyRequestSchema: () => GetAppEnvEncryptPubKeyRequestSchema,
   GetAppEnvEncryptPubKeySchema: () => GetAppEnvEncryptPubKeySchema,
+  GetAppInfoRequestSchema: () => GetAppInfoRequestSchema,
+  GetAppListRequestSchema: () => GetAppListRequestSchema,
+  GetAppRevisionDetailRequestSchema: () => GetAppRevisionDetailRequestSchema,
+  GetAppRevisionsRequestSchema: () => GetAppRevisionsRequestSchema,
   GetAvailableOSImagesRequestSchema: () => GetAvailableOSImagesRequestSchema,
   GetAvailableOSImagesResponseSchema: () => GetAvailableOSImagesResponseSchema,
   GetCvmAttestationRequestSchema: () => GetCvmAttestationRequestSchema,
@@ -68,29 +100,39 @@ __export(index_exports, {
   GetCvmDockerComposeRequestSchema: () => GetCvmDockerComposeRequestSchema,
   GetCvmInfoRequestSchema: () => GetCvmInfoRequestSchema,
   GetCvmListRequestSchema: () => GetCvmListRequestSchema,
-  GetCvmListSchema: () => GetCvmListSchema,
   GetCvmNetworkRequestSchema: () => GetCvmNetworkRequestSchema,
+  GetCvmPreLaunchScriptRequestSchema: () => GetCvmPreLaunchScriptRequestSchema,
   GetCvmStateRequestSchema: () => GetCvmStateRequestSchema,
   GetCvmStatsRequestSchema: () => GetCvmStatsRequestSchema,
+  GetCvmStatusBatchRequestSchema: () => GetCvmStatusBatchRequestSchema,
+  GetCvmStatusBatchResponseSchema: () => GetCvmStatusBatchResponseSchema,
   GetKmsInfoRequestSchema: () => GetKmsInfoRequestSchema,
   GetKmsListRequestSchema: () => GetKmsListRequestSchema,
   GetKmsListSchema: () => GetKmsListSchema,
+  GetWorkspaceNodesSchema: () => GetWorkspaceNodesSchema,
+  GetWorkspaceQuotasSchema: () => GetWorkspaceQuotasSchema,
   InstanceTypeSchema: () => InstanceTypeSchema,
   KmsInfoSchema: () => KmsInfoSchema,
+  KmsTypeSchema: () => KmsTypeSchema,
   ListFamilyInstanceTypesRequestSchema: () => ListFamilyInstanceTypesRequestSchema,
   ListWorkspacesSchema: () => ListWorkspacesSchema,
-  ManagedUserSchema: () => ManagedUserSchema,
+  MachineInfoV20251028Schema: () => MachineInfoV20251028Schema,
+  ManagedUserV20251028Schema: () => ManagedUserV20251028Schema,
   MaxRetriesExceededError: () => MaxRetriesExceededError,
   NetworkError: () => NetworkError,
   NextAppIdsRequestSchema: () => NextAppIdsRequestSchema,
   NextAppIdsSchema: () => NextAppIdsSchema,
+  NodeInfoSchema: () => NodeInfoSchema,
   OSImageVariantSchema: () => OSImageVariantSchema,
+  PaginatedCvmInfosV20251028Schema: () => PaginatedCvmInfosV20251028Schema,
+  PaginatedCvmInfosV20260121Schema: () => PaginatedCvmInfosV20260121Schema,
   PaginationMetadataSchema: () => PaginationMetadataSchema,
   PhalaCloudError: () => PhalaCloudError,
   ProvisionCvmComposeFileUpdateRequestSchema: () => ProvisionCvmComposeFileUpdateRequestSchema,
   ProvisionCvmComposeFileUpdateResultSchema: () => ProvisionCvmComposeFileUpdateResultSchema,
   ProvisionCvmRequestSchema: () => ProvisionCvmRequestSchema,
   ProvisionCvmSchema: () => ProvisionCvmSchema,
+  QuotaMetricSchema: () => QuotaMetricSchema,
   RequestError: () => RequestError,
   ResourceError: () => ResourceError,
   RestartCvmRequestSchema: () => RestartCvmRequestSchema,
@@ -102,15 +144,27 @@ __export(index_exports, {
   StopCvmRequestSchema: () => StopCvmRequestSchema,
   TransactionError: () => TransactionError,
   UnknownError: () => UnknownError,
+  UpdateCvmEnvsRequestSchema: () => UpdateCvmEnvsRequestSchema,
+  UpdateCvmEnvsResultSchema: () => UpdateCvmEnvsResultSchema,
   UpdateCvmResourcesRequestSchema: () => UpdateCvmResourcesRequestSchema,
   UpdateCvmVisibilityRequestSchema: () => UpdateCvmVisibilityRequestSchema,
+  UpdateDockerComposeRequestSchema: () => UpdateDockerComposeRequestSchema,
+  UpdateDockerComposeResultSchema: () => UpdateDockerComposeResultSchema,
   UpdateOsImageRequestSchema: () => UpdateOsImageRequestSchema,
+  UpdatePreLaunchScriptRequestSchema: () => UpdatePreLaunchScriptRequestSchema,
+  UpdatePreLaunchScriptResultSchema: () => UpdatePreLaunchScriptResultSchema,
+  UserInfoSchema: () => UserInfoSchema,
+  UserRefSchema: () => UserRefSchema,
   VMSchema: () => VMSchema,
   ValidationError: () => ValidationError,
-  VmInfoSchema: () => VmInfoSchema,
+  VmInfoV20251028Schema: () => VmInfoV20251028Schema,
   WalletError: () => WalletError,
   WatchAbortedError: () => WatchAbortedError,
   WatchCvmStateRequestSchema: () => WatchCvmStateRequestSchema,
+  WorkspaceInfoSchema: () => WorkspaceInfoSchema,
+  WorkspaceQuotasSchema: () => WorkspaceQuotasSchema,
+  WorkspaceRefSchema: () => WorkspaceRefSchema,
+  WorkspaceReservedGpuQuotaSchema: () => WorkspaceReservedGpuQuotaSchema,
   WorkspaceResponseSchema: () => WorkspaceResponseSchema,
   addComposeHash: () => addComposeHash,
   addNetwork: () => addNetwork,
@@ -120,6 +174,7 @@ __export(index_exports, {
   checkNetworkStatus: () => checkNetworkStatus,
   commitCvmComposeFileUpdate: () => commitCvmComposeFileUpdate,
   commitCvmProvision: () => commitCvmProvision,
+  convertToHostname: () => convertToHostname,
   createBaseClient: () => createClient,
   createClient: () => createClient2,
   createClientsFromBrowser: () => createClientsFromBrowser,
@@ -140,7 +195,14 @@ __export(index_exports, {
   formatErrorMessage: () => formatErrorMessage,
   formatStructuredError: () => formatStructuredError,
   formatValidationErrors: () => formatValidationErrors,
+  generateDefaultCvmName: () => generateDefaultCvmName,
+  generateFallbackHostname: () => generateFallbackHostname,
+  getAppCvms: () => getAppCvms,
   getAppEnvEncryptPubKey: () => getAppEnvEncryptPubKey,
+  getAppInfo: () => getAppInfo,
+  getAppList: () => getAppList,
+  getAppRevisionDetail: () => getAppRevisionDetail,
+  getAppRevisions: () => getAppRevisions,
   getAvailableNodes: () => getAvailableNodes,
   getAvailableOsImages: () => getAvailableOsImages,
   getComposeHash: () => import_get_compose_hash3.getComposeHash,
@@ -152,13 +214,18 @@ __export(index_exports, {
   getCvmInfo: () => getCvmInfo,
   getCvmList: () => getCvmList,
   getCvmNetwork: () => getCvmNetwork,
+  getCvmPreLaunchScript: () => getCvmPreLaunchScript,
   getCvmState: () => getCvmState,
   getCvmStats: () => getCvmStats,
+  getCvmStatusBatch: () => getCvmStatusBatch,
   getErrorMessage: () => getErrorMessage,
   getKmsInfo: () => getKmsInfo,
   getKmsList: () => getKmsList,
   getValidationFields: () => getValidationFields,
   getWorkspace: () => getWorkspace,
+  getWorkspaceNodes: () => getWorkspaceNodes,
+  getWorkspaceQuotas: () => getWorkspaceQuotas,
+  isValidHostname: () => isValidHostname,
   listAllInstanceTypeFamilies: () => listAllInstanceTypeFamilies,
   listFamilyInstanceTypes: () => listFamilyInstanceTypes,
   listWorkspaces: () => listWorkspaces,
@@ -176,7 +243,12 @@ __export(index_exports, {
   safeCommitCvmProvision: () => safeCommitCvmProvision,
   safeDeleteCvm: () => safeDeleteCvm,
   safeDeployAppAuth: () => safeDeployAppAuth,
+  safeGetAppCvms: () => safeGetAppCvms,
   safeGetAppEnvEncryptPubKey: () => safeGetAppEnvEncryptPubKey,
+  safeGetAppInfo: () => safeGetAppInfo,
+  safeGetAppList: () => safeGetAppList,
+  safeGetAppRevisionDetail: () => safeGetAppRevisionDetail,
+  safeGetAppRevisions: () => safeGetAppRevisions,
   safeGetAvailableNodes: () => safeGetAvailableNodes,
   safeGetAvailableOsImages: () => safeGetAvailableOsImages,
   safeGetCurrentUser: () => safeGetCurrentUser,
@@ -187,11 +259,15 @@ __export(index_exports, {
   safeGetCvmInfo: () => safeGetCvmInfo,
   safeGetCvmList: () => safeGetCvmList,
   safeGetCvmNetwork: () => safeGetCvmNetwork,
+  safeGetCvmPreLaunchScript: () => safeGetCvmPreLaunchScript,
   safeGetCvmState: () => safeGetCvmState,
   safeGetCvmStats: () => safeGetCvmStats,
+  safeGetCvmStatusBatch: () => safeGetCvmStatusBatch,
   safeGetKmsInfo: () => safeGetKmsInfo,
   safeGetKmsList: () => safeGetKmsList,
   safeGetWorkspace: () => safeGetWorkspace,
+  safeGetWorkspaceNodes: () => safeGetWorkspaceNodes,
+  safeGetWorkspaceQuotas: () => safeGetWorkspaceQuotas,
   safeListAllInstanceTypeFamilies: () => safeListAllInstanceTypeFamilies,
   safeListFamilyInstanceTypes: () => safeListFamilyInstanceTypes,
   safeListWorkspaces: () => safeListWorkspaces,
@@ -202,18 +278,24 @@ __export(index_exports, {
   safeShutdownCvm: () => safeShutdownCvm,
   safeStartCvm: () => safeStartCvm,
   safeStopCvm: () => safeStopCvm,
+  safeUpdateCvmEnvs: () => safeUpdateCvmEnvs,
   safeUpdateCvmResources: () => safeUpdateCvmResources,
   safeUpdateCvmVisibility: () => safeUpdateCvmVisibility,
+  safeUpdateDockerCompose: () => safeUpdateDockerCompose,
   safeUpdateOsImage: () => safeUpdateOsImage,
+  safeUpdatePreLaunchScript: () => safeUpdatePreLaunchScript,
   safeValidateActionParameters: () => safeValidateActionParameters,
   shutdownCvm: () => shutdownCvm,
   sortObject: () => sortObject,
   startCvm: () => startCvm,
   stopCvm: () => stopCvm,
   switchToNetwork: () => switchToNetwork,
+  updateCvmEnvs: () => updateCvmEnvs,
   updateCvmResources: () => updateCvmResources,
   updateCvmVisibility: () => updateCvmVisibility,
+  updateDockerCompose: () => updateDockerCompose,
   updateOsImage: () => updateOsImage,
+  updatePreLaunchScript: () => updatePreLaunchScript,
   validateActionParameters: () => validateActionParameters,
   validateNetworkPrerequisites: () => validateNetworkPrerequisites,
   verifyEnvEncryptPublicKey: () => import_verify_env_encrypt_public_key.verifyEnvEncryptPublicKey,
@@ -558,7 +640,11 @@ function formatStructuredError(error, options) {
 }
 
 // src/client.ts
-var SUPPORTED_API_VERSIONS = ["2025-05-31", "2025-10-28"];
+var SUPPORTED_API_VERSIONS = [
+  "2025-10-28",
+  "2026-01-21"
+];
+var DEFAULT_API_VERSION = "2026-01-21";
 var logger = (0, import_debug.default)("phala::api-client");
 function formatHeaders(headers) {
   return Object.entries(headers).map(([key, value]) => `    -H "${key}: ${value}"`).join("\n");
@@ -582,17 +668,19 @@ function formatResponse(status, statusText, headers, body) {
     bodyStr
   ].filter(Boolean).join("\n");
 }
-var Client = class {
+var Client = class _Client {
   constructor(config = {}) {
     this.emitter = (0, import_mitt.default)();
-    const resolvedConfig = {
+    const resolvedApiKey = config.apiKey || process?.env?.PHALA_CLOUD_API_KEY;
+    const resolvedBaseURL = config.baseURL || process?.env?.PHALA_CLOUD_API_PREFIX || "https://cloud-api.phala.network/api/v1";
+    const version = config.version && SUPPORTED_API_VERSIONS.includes(config.version) ? config.version : DEFAULT_API_VERSION;
+    this.config = {
       ...config,
-      apiKey: config.apiKey || process?.env?.PHALA_CLOUD_API_KEY,
-      baseURL: config.baseURL || process?.env?.PHALA_CLOUD_API_PREFIX || "https://cloud-api.phala.network/api/v1"
+      apiKey: resolvedApiKey,
+      baseURL: resolvedBaseURL,
+      version
     };
-    const version = resolvedConfig.version && SUPPORTED_API_VERSIONS.includes(resolvedConfig.version) ? resolvedConfig.version : SUPPORTED_API_VERSIONS[SUPPORTED_API_VERSIONS.length - 1];
-    this.config = resolvedConfig;
-    const { apiKey, baseURL, timeout, headers, useCookieAuth, onResponseError, ...fetchOptions } = resolvedConfig;
+    const { apiKey, baseURL, timeout, headers, useCookieAuth, onResponseError, ...fetchOptions } = this.config;
     const requestHeaders = {
       "X-Phala-Version": version,
       "Content-Type": "application/json"
@@ -651,8 +739,8 @@ var Client = class {
       },
       // Generic handlers for response error (similar to request.ts)
       onResponseError: ({ request, response, options }) => {
-        console.warn(`HTTP ${response.status}: ${response.url}`);
         if (logger.enabled) {
+          console.warn(`HTTP ${response.status}: ${response.url}`);
           const method = options.method || "GET";
           const url = typeof request === "string" ? request : request.url;
           logger(
@@ -688,6 +776,49 @@ var Client = class {
     this.emitter.on(type, wrappedHandler);
   }
   // ===== Direct methods (throw on error) =====
+  /**
+   * Generic request method (throws PhalaCloudError on error)
+   */
+  async request(url, options) {
+    try {
+      const method = options?.method || "GET";
+      return await this.fetchInstance(url, {
+        ...options,
+        method
+      });
+    } catch (error) {
+      const requestError = this.convertToRequestError(error);
+      const phalaCloudError = this.emitError(requestError);
+      throw phalaCloudError;
+    }
+  }
+  /**
+   * Generic request method that returns the full response (status + headers + data)
+   *
+   * Unlike other direct methods, this does NOT throw for non-2xx HTTP statuses.
+   * It only throws for network/transport/unexpected errors.
+   */
+  async requestFull(url, options) {
+    try {
+      const method = options?.method || "GET";
+      const response = await this.fetchInstance.raw(url, {
+        ...options,
+        method,
+        ignoreResponseError: true
+      });
+      return {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+        data: response._data,
+        ok: response.ok
+      };
+    } catch (error) {
+      const requestError = this.convertToRequestError(error);
+      const phalaCloudError = this.emitError(requestError);
+      throw phalaCloudError;
+    }
+  }
   /**
    * Perform GET request (throws PhalaCloudError on error)
    */
@@ -838,6 +969,34 @@ var Client = class {
   async safeDelete(request, options) {
     return this.safeRequest(() => this.delete(request, options));
   }
+  /**
+   * Safe wrapper around the generic request method (returns SafeResult)
+   */
+  async safeRequestMethod(url, options) {
+    return this.safeRequest(() => this.request(url, options));
+  }
+  /**
+   * Safe wrapper around requestFull (returns SafeResult)
+   */
+  async safeRequestFull(url, options) {
+    return this.safeRequest(() => this.requestFull(url, options));
+  }
+  /**
+   * Create a new client with a different API version
+   *
+   * @example
+   * ```typescript
+   * const client = createClient(); // defaults to 2026-01-21
+   * const legacyClient = client.withVersion("2025-10-28");
+   * const data = await getCvmInfo(legacyClient, { id: "xxx" });
+   * ```
+   */
+  withVersion(version) {
+    return new _Client({
+      ...this.config,
+      version
+    });
+  }
   /**
    * Extend client with additional actions
    *
@@ -865,8 +1024,113 @@ function createClient(config = {}) {
   return new Client(config);
 }
 
-// src/actions/get_current_user.ts
+// src/credentials/current_user_v20260121.ts
 var import_zod2 = require("zod");
+var UserInfoSchema = import_zod2.z.object({
+  username: import_zod2.z.string(),
+  email: import_zod2.z.string(),
+  role: import_zod2.z.enum(["admin", "user"]),
+  avatar: import_zod2.z.string(),
+  email_verified: import_zod2.z.boolean(),
+  totp_enabled: import_zod2.z.boolean(),
+  has_backup_codes: import_zod2.z.boolean(),
+  flag_has_password: import_zod2.z.boolean()
+}).passthrough();
+var WorkspaceInfoSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  name: import_zod2.z.string(),
+  slug: import_zod2.z.string().nullable(),
+  tier: import_zod2.z.string(),
+  role: import_zod2.z.string(),
+  avatar: import_zod2.z.string().nullable().optional()
+}).passthrough();
+var CreditsInfoSchema = import_zod2.z.object({
+  balance: import_zod2.z.string().or(import_zod2.z.number()),
+  granted_balance: import_zod2.z.string().or(import_zod2.z.number()),
+  is_post_paid: import_zod2.z.boolean(),
+  outstanding_amount: import_zod2.z.string().or(import_zod2.z.number()).nullable()
+}).passthrough();
+var CurrentUserV20260121Schema = import_zod2.z.object({
+  user: UserInfoSchema,
+  workspace: WorkspaceInfoSchema,
+  credits: CreditsInfoSchema
+}).passthrough();
+
+// src/credentials/current_user_v20251028.ts
+var import_zod3 = require("zod");
+var CurrentUserV20251028Schema = import_zod3.z.object({
+  username: import_zod3.z.string(),
+  email: import_zod3.z.string(),
+  credits: import_zod3.z.number(),
+  granted_credits: import_zod3.z.number(),
+  avatar: import_zod3.z.string(),
+  team_name: import_zod3.z.string(),
+  team_tier: import_zod3.z.string()
+}).passthrough();
+
+// src/actions/get_current_user.ts
+function getSchemaForVersion(version) {
+  return version === "2025-10-28" ? CurrentUserV20251028Schema : CurrentUserV20260121Schema;
+}
+async function getCurrentUser(client, parameters) {
+  const response = await client.get("/auth/me");
+  if (parameters?.schema === false) {
+    return response;
+  }
+  const schema = parameters?.schema || getSchemaForVersion(client.config.version);
+  return schema.parse(response);
+}
+async function safeGetCurrentUser(client, parameters) {
+  try {
+    const data = await getCurrentUser(client, parameters);
+    return { success: true, data };
+  } catch (error) {
+    if (error && typeof error === "object" && ("status" in error || "issues" in error)) {
+      return { success: false, error };
+    }
+    return {
+      success: false,
+      error: {
+        name: "Error",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
+
+// src/actions/get_available_nodes.ts
+var import_zod5 = require("zod");
+
+// src/types/kms_info.ts
+var import_zod4 = require("zod");
+
+// src/types/supported_chains.ts
+var import_chains = require("viem/chains");
+var SUPPORTED_CHAINS = {
+  [import_chains.mainnet.id]: import_chains.mainnet,
+  [import_chains.base.id]: import_chains.base,
+  [import_chains.anvil.id]: import_chains.anvil
+};
+
+// src/types/kms_info.ts
+var KmsInfoBaseSchema = import_zod4.z.object({
+  id: import_zod4.z.string(),
+  slug: import_zod4.z.string().nullable(),
+  url: import_zod4.z.string(),
+  version: import_zod4.z.string(),
+  chain_id: import_zod4.z.number().nullable(),
+  kms_contract_address: import_zod4.z.string().nullable().transform((val) => val),
+  gateway_app_id: import_zod4.z.string().nullable().transform((val) => val)
+}).passthrough();
+var KmsInfoSchema = KmsInfoBaseSchema.transform((data) => {
+  if (data.chain_id != null) {
+    const chain = SUPPORTED_CHAINS[data.chain_id];
+    if (chain) {
+      return { ...data, chain };
+    }
+  }
+  return data;
+});
 
 // src/utils/validate-parameters.ts
 function validateActionParameters(parameters) {
@@ -1014,95 +1278,44 @@ function defineAction(schema, fn) {
   };
 }
 
-// src/actions/get_current_user.ts
-var CurrentUserSchema = import_zod2.z.object({
-  username: import_zod2.z.string(),
-  email: import_zod2.z.string(),
-  credits: import_zod2.z.number(),
-  granted_credits: import_zod2.z.number(),
-  avatar: import_zod2.z.string(),
-  team_name: import_zod2.z.string(),
-  team_tier: import_zod2.z.string()
-}).passthrough();
-var { action: getCurrentUser, safeAction: safeGetCurrentUser } = defineSimpleAction(
-  CurrentUserSchema,
-  async (client) => {
-    return await client.get("/auth/me");
-  }
-);
-
 // src/actions/get_available_nodes.ts
-var import_zod4 = require("zod");
-
-// src/types/kms_info.ts
-var import_zod3 = require("zod");
-
-// src/types/supported_chains.ts
-var import_chains = require("viem/chains");
-var SUPPORTED_CHAINS = {
-  [import_chains.mainnet.id]: import_chains.mainnet,
-  [import_chains.base.id]: import_chains.base,
-  [import_chains.anvil.id]: import_chains.anvil
-};
-
-// src/types/kms_info.ts
-var KmsInfoBaseSchema = import_zod3.z.object({
-  id: import_zod3.z.string(),
-  slug: import_zod3.z.string().nullable(),
-  url: import_zod3.z.string(),
-  version: import_zod3.z.string(),
-  chain_id: import_zod3.z.number().nullable(),
-  kms_contract_address: import_zod3.z.string().nullable().transform((val) => val),
-  gateway_app_id: import_zod3.z.string().nullable().transform((val) => val)
-}).passthrough();
-var KmsInfoSchema = KmsInfoBaseSchema.transform((data) => {
-  if (data.chain_id != null) {
-    const chain = SUPPORTED_CHAINS[data.chain_id];
-    if (chain) {
-      return { ...data, chain };
-    }
-  }
-  return data;
-});
-
-// src/actions/get_available_nodes.ts
-var AvailableOSImageSchema = import_zod4.z.object({
-  name: import_zod4.z.string(),
-  is_dev: import_zod4.z.boolean(),
-  version: import_zod4.z.union([
-    import_zod4.z.tuple([import_zod4.z.number(), import_zod4.z.number(), import_zod4.z.number()]),
-    import_zod4.z.tuple([import_zod4.z.number(), import_zod4.z.number(), import_zod4.z.number(), import_zod4.z.number()])
+var AvailableOSImageSchema = import_zod5.z.object({
+  name: import_zod5.z.string(),
+  is_dev: import_zod5.z.boolean(),
+  version: import_zod5.z.union([
+    import_zod5.z.tuple([import_zod5.z.number(), import_zod5.z.number(), import_zod5.z.number()]),
+    import_zod5.z.tuple([import_zod5.z.number(), import_zod5.z.number(), import_zod5.z.number(), import_zod5.z.number()])
   ]),
-  os_image_hash: import_zod4.z.string().nullable().optional()
+  os_image_hash: import_zod5.z.string().nullable().optional()
 }).passthrough();
-var TeepodCapacitySchema = import_zod4.z.object({
-  teepod_id: import_zod4.z.number(),
-  name: import_zod4.z.string(),
-  listed: import_zod4.z.boolean(),
-  resource_score: import_zod4.z.number(),
-  remaining_vcpu: import_zod4.z.number(),
-  remaining_memory: import_zod4.z.number(),
-  remaining_cvm_slots: import_zod4.z.number(),
-  images: import_zod4.z.array(AvailableOSImageSchema),
-  support_onchain_kms: import_zod4.z.boolean().optional(),
-  fmspc: import_zod4.z.string().nullable().optional(),
-  device_id: import_zod4.z.string().nullable().optional(),
-  region_identifier: import_zod4.z.string().nullable().optional(),
-  default_kms: import_zod4.z.string().nullable().optional(),
-  kms_list: import_zod4.z.array(import_zod4.z.string()).default([])
+var TeepodCapacitySchema = import_zod5.z.object({
+  teepod_id: import_zod5.z.number(),
+  name: import_zod5.z.string(),
+  listed: import_zod5.z.boolean(),
+  resource_score: import_zod5.z.number(),
+  remaining_vcpu: import_zod5.z.number(),
+  remaining_memory: import_zod5.z.number(),
+  remaining_cvm_slots: import_zod5.z.number(),
+  images: import_zod5.z.array(AvailableOSImageSchema),
+  support_onchain_kms: import_zod5.z.boolean().optional(),
+  fmspc: import_zod5.z.string().nullable().optional(),
+  device_id: import_zod5.z.string().nullable().optional(),
+  region_identifier: import_zod5.z.string().nullable().optional(),
+  default_kms: import_zod5.z.string().nullable().optional(),
+  kms_list: import_zod5.z.array(import_zod5.z.string()).default([])
 }).passthrough();
-var ResourceThresholdSchema = import_zod4.z.object({
-  max_instances: import_zod4.z.number().nullable().optional(),
-  max_vcpu: import_zod4.z.number().nullable().optional(),
-  max_memory: import_zod4.z.number().nullable().optional(),
-  max_disk: import_zod4.z.number().nullable().optional()
+var ResourceThresholdSchema = import_zod5.z.object({
+  max_instances: import_zod5.z.number().nullable().optional(),
+  max_vcpu: import_zod5.z.number().nullable().optional(),
+  max_memory: import_zod5.z.number().nullable().optional(),
+  max_disk: import_zod5.z.number().nullable().optional()
 }).passthrough();
-var AvailableNodesSchema = import_zod4.z.object({
-  tier: import_zod4.z.string(),
+var AvailableNodesSchema = import_zod5.z.object({
+  tier: import_zod5.z.string(),
   // TeamTier is string enum
   capacity: ResourceThresholdSchema,
-  nodes: import_zod4.z.array(TeepodCapacitySchema),
-  kms_list: import_zod4.z.array(KmsInfoSchema)
+  nodes: import_zod5.z.array(TeepodCapacitySchema),
+  kms_list: import_zod5.z.array(KmsInfoSchema)
 }).passthrough();
 var { action: getAvailableNodes, safeAction: safeGetAvailableNodes } = defineSimpleAction(
   AvailableNodesSchema,
@@ -1112,33 +1325,33 @@ var { action: getAvailableNodes, safeAction: safeGetAvailableNodes } = defineSim
 );
 
 // src/actions/list-instance-types.ts
-var import_zod5 = require("zod");
-var InstanceTypeSchema = import_zod5.z.object({
-  id: import_zod5.z.string(),
-  name: import_zod5.z.string(),
-  description: import_zod5.z.string(),
-  vcpu: import_zod5.z.number(),
-  memory_mb: import_zod5.z.number(),
-  hourly_rate: import_zod5.z.string(),
-  requires_gpu: import_zod5.z.boolean(),
-  default_disk_size_gb: import_zod5.z.number().default(20),
-  family: import_zod5.z.string().nullable()
+var import_zod6 = require("zod");
+var InstanceTypeSchema = import_zod6.z.object({
+  id: import_zod6.z.string(),
+  name: import_zod6.z.string(),
+  description: import_zod6.z.string(),
+  vcpu: import_zod6.z.number(),
+  memory_mb: import_zod6.z.number(),
+  hourly_rate: import_zod6.z.string(),
+  requires_gpu: import_zod6.z.boolean(),
+  default_disk_size_gb: import_zod6.z.number().default(20),
+  family: import_zod6.z.string().nullable()
 }).passthrough();
-var FamilyGroupSchema = import_zod5.z.object({
-  name: import_zod5.z.string(),
-  items: import_zod5.z.array(InstanceTypeSchema),
-  total: import_zod5.z.number()
+var FamilyGroupSchema = import_zod6.z.object({
+  name: import_zod6.z.string(),
+  items: import_zod6.z.array(InstanceTypeSchema),
+  total: import_zod6.z.number()
 }).strict();
-var AllFamiliesResponseSchema = import_zod5.z.object({
-  result: import_zod5.z.array(FamilyGroupSchema)
+var AllFamiliesResponseSchema = import_zod6.z.object({
+  result: import_zod6.z.array(FamilyGroupSchema)
 }).strict();
-var FamilyInstanceTypesResponseSchema = import_zod5.z.object({
-  items: import_zod5.z.array(InstanceTypeSchema),
-  total: import_zod5.z.number(),
-  family: import_zod5.z.string()
+var FamilyInstanceTypesResponseSchema = import_zod6.z.object({
+  items: import_zod6.z.array(InstanceTypeSchema),
+  total: import_zod6.z.number(),
+  family: import_zod6.z.string()
 }).strict();
-var ListFamilyInstanceTypesRequestSchema = import_zod5.z.object({
-  family: import_zod5.z.string()
+var ListFamilyInstanceTypesRequestSchema = import_zod6.z.object({
+  family: import_zod6.z.string()
 }).strict();
 var { action: listAllInstanceTypeFamilies, safeAction: safeListAllInstanceTypeFamilies } = defineAction(
   AllFamiliesResponseSchema,
@@ -1152,22 +1365,22 @@ var { action: listFamilyInstanceTypes, safeAction: safeListFamilyInstanceTypes }
 });
 
 // src/actions/workspaces/list_workspaces.ts
-var import_zod6 = require("zod");
-var WorkspaceResponseSchema = import_zod6.z.object({
-  id: import_zod6.z.string(),
-  name: import_zod6.z.string(),
-  slug: import_zod6.z.string().nullable(),
-  tier: import_zod6.z.string(),
-  role: import_zod6.z.string(),
-  created_at: import_zod6.z.string()
+var import_zod7 = require("zod");
+var WorkspaceResponseSchema = import_zod7.z.object({
+  id: import_zod7.z.string(),
+  name: import_zod7.z.string(),
+  slug: import_zod7.z.string().nullable(),
+  tier: import_zod7.z.string(),
+  role: import_zod7.z.string(),
+  created_at: import_zod7.z.string()
 }).passthrough();
-var PaginationMetadataSchema = import_zod6.z.object({
-  has_more: import_zod6.z.boolean(),
-  next_cursor: import_zod6.z.string().nullable(),
-  total: import_zod6.z.number().nullable()
+var PaginationMetadataSchema = import_zod7.z.object({
+  has_more: import_zod7.z.boolean(),
+  next_cursor: import_zod7.z.string().nullable(),
+  total: import_zod7.z.number().nullable()
 }).passthrough();
-var ListWorkspacesSchema = import_zod6.z.object({
-  data: import_zod6.z.array(WorkspaceResponseSchema),
+var ListWorkspacesSchema = import_zod7.z.object({
+  data: import_zod7.z.array(WorkspaceResponseSchema),
   pagination: PaginationMetadataSchema
 }).passthrough();
 var { action: listWorkspaces, safeAction: safeListWorkspaces } = defineAction(ListWorkspacesSchema, async (client, request) => {
@@ -1183,196 +1396,393 @@ var { action: getWorkspace, safeAction: safeGetWorkspace } = defineAction(Worksp
   return await client.get(`/workspaces/${teamSlug}`);
 });
 
-// src/types/cvm_info.ts
-var import_zod7 = require("zod");
-var VmInfoSchema = import_zod7.z.object({
-  id: import_zod7.z.string(),
-  name: import_zod7.z.string(),
-  status: import_zod7.z.string(),
-  uptime: import_zod7.z.string(),
-  app_url: import_zod7.z.string().nullable(),
-  app_id: import_zod7.z.string(),
-  instance_id: import_zod7.z.string().nullable(),
-  configuration: import_zod7.z.any().optional(),
-  // TODO: add VmConfiguration schema if needed
-  exited_at: import_zod7.z.string().nullable(),
-  boot_progress: import_zod7.z.string().nullable(),
-  boot_error: import_zod7.z.string().nullable(),
-  shutdown_progress: import_zod7.z.string().nullable(),
-  image_version: import_zod7.z.string().nullable()
-});
-var ManagedUserSchema = import_zod7.z.object({
-  id: import_zod7.z.number(),
-  username: import_zod7.z.string()
-});
-var CvmNodeSchema = import_zod7.z.object({
-  id: import_zod7.z.number(),
-  name: import_zod7.z.string(),
-  region_identifier: import_zod7.z.string().nullable().optional()
+// src/types/cvm_info_v20251028.ts
+var import_zod8 = require("zod");
+var VmInfoV20251028Schema = import_zod8.z.object({
+  id: import_zod8.z.string(),
+  name: import_zod8.z.string(),
+  status: import_zod8.z.string(),
+  uptime: import_zod8.z.string(),
+  app_url: import_zod8.z.string().nullable(),
+  app_id: import_zod8.z.string(),
+  instance_id: import_zod8.z.string().nullable(),
+  configuration: import_zod8.z.any().optional(),
+  exited_at: import_zod8.z.string().nullable(),
+  boot_progress: import_zod8.z.string().nullable(),
+  boot_error: import_zod8.z.string().nullable(),
+  shutdown_progress: import_zod8.z.string().nullable(),
+  image_version: import_zod8.z.string().nullable()
 });
-var CvmNetworkUrlsSchema = import_zod7.z.object({
-  app: import_zod7.z.string(),
-  instance: import_zod7.z.string()
+var ManagedUserV20251028Schema = import_zod8.z.object({
+  id: import_zod8.z.number(),
+  username: import_zod8.z.string()
 });
-var CvmInfoSchema = import_zod7.z.object({
-  hosted: VmInfoSchema,
-  name: import_zod7.z.string(),
-  managed_user: ManagedUserSchema.nullable(),
-  node: CvmNodeSchema.nullable(),
-  listed: import_zod7.z.boolean().default(false),
-  status: import_zod7.z.string(),
-  in_progress: import_zod7.z.boolean().default(false),
-  dapp_dashboard_url: import_zod7.z.string().nullable(),
-  syslog_endpoint: import_zod7.z.string().nullable(),
-  allow_upgrade: import_zod7.z.boolean().default(false),
-  project_id: import_zod7.z.string().nullable(),
-  // HashedId is represented as string in JS
-  project_type: import_zod7.z.string().nullable(),
-  billing_period: import_zod7.z.string().nullable(),
+var CvmNodeV20251028Schema = import_zod8.z.object({
+  id: import_zod8.z.number(),
+  name: import_zod8.z.string(),
+  region_identifier: import_zod8.z.string().nullable().optional()
+});
+var MachineInfoV20251028Schema = import_zod8.z.object({
+  vcpu: import_zod8.z.number(),
+  memory: import_zod8.z.number(),
+  disk_size: import_zod8.z.number(),
+  gpu_count: import_zod8.z.number().default(0)
+});
+var CvmNetworkUrlsV20251028Schema = import_zod8.z.object({
+  app: import_zod8.z.string(),
+  instance: import_zod8.z.string()
+});
+var CvmInfoV20251028Schema = import_zod8.z.object({
+  hosted: VmInfoV20251028Schema,
+  name: import_zod8.z.string(),
+  managed_user: ManagedUserV20251028Schema.nullable(),
+  node: CvmNodeV20251028Schema.nullable(),
+  listed: import_zod8.z.boolean().default(false),
+  status: import_zod8.z.string(),
+  in_progress: import_zod8.z.boolean().default(false),
+  dapp_dashboard_url: import_zod8.z.string().nullable(),
+  syslog_endpoint: import_zod8.z.string().nullable(),
+  allow_upgrade: import_zod8.z.boolean().default(false),
+  project_id: import_zod8.z.string().nullable(),
+  project_type: import_zod8.z.string().nullable(),
+  billing_period: import_zod8.z.string().nullable(),
   kms_info: KmsInfoSchema.nullable(),
-  vcpu: import_zod7.z.number().nullable(),
-  memory: import_zod7.z.number().nullable(),
-  disk_size: import_zod7.z.number().nullable(),
-  gateway_domain: import_zod7.z.string().nullable(),
-  public_urls: import_zod7.z.array(CvmNetworkUrlsSchema)
-});
-var CvmLegacyDetailSchema = import_zod7.z.object({
-  id: import_zod7.z.number(),
-  name: import_zod7.z.string(),
-  status: import_zod7.z.string(),
-  in_progress: import_zod7.z.boolean().optional().default(false),
-  teepod_id: import_zod7.z.number().nullable(),
-  teepod: CvmNodeSchema.optional().nullable(),
-  app_id: import_zod7.z.string(),
-  vm_uuid: import_zod7.z.string().nullable(),
-  instance_id: import_zod7.z.string().nullable(),
-  vcpu: import_zod7.z.number(),
-  memory: import_zod7.z.number(),
-  disk_size: import_zod7.z.number(),
-  base_image: import_zod7.z.string().nullable(),
-  encrypted_env_pubkey: import_zod7.z.string().nullable(),
-  listed: import_zod7.z.boolean().optional().default(false),
-  project_id: import_zod7.z.string().optional().nullable(),
-  project_type: import_zod7.z.string().optional().nullable(),
-  public_sysinfo: import_zod7.z.boolean().optional().default(false),
-  public_logs: import_zod7.z.boolean().optional().default(false),
-  dapp_dashboard_url: import_zod7.z.string().optional().nullable(),
-  syslog_endpoint: import_zod7.z.string().optional().nullable(),
+  vcpu: import_zod8.z.number().nullable(),
+  memory: import_zod8.z.number().nullable(),
+  disk_size: import_zod8.z.number().nullable(),
+  gateway_domain: import_zod8.z.string().nullable(),
+  public_urls: import_zod8.z.array(CvmNetworkUrlsV20251028Schema),
+  machine_info: MachineInfoV20251028Schema.nullable().optional(),
+  updated_at: import_zod8.z.string().nullable().optional()
+});
+var CvmDetailV20251028Schema = import_zod8.z.object({
+  id: import_zod8.z.number(),
+  name: import_zod8.z.string(),
+  status: import_zod8.z.string(),
+  in_progress: import_zod8.z.boolean().optional().default(false),
+  teepod_id: import_zod8.z.number().nullable(),
+  teepod: CvmNodeV20251028Schema.optional().nullable(),
+  app_id: import_zod8.z.string(),
+  vm_uuid: import_zod8.z.string().nullable(),
+  instance_id: import_zod8.z.string().nullable(),
+  vcpu: import_zod8.z.number(),
+  memory: import_zod8.z.number(),
+  disk_size: import_zod8.z.number(),
+  base_image: import_zod8.z.string().nullable(),
+  encrypted_env_pubkey: import_zod8.z.string().nullable(),
+  listed: import_zod8.z.boolean().optional().default(false),
+  project_id: import_zod8.z.string().optional().nullable(),
+  project_type: import_zod8.z.string().optional().nullable(),
+  instance_type: import_zod8.z.string().optional().nullable(),
+  public_sysinfo: import_zod8.z.boolean().optional().default(false),
+  public_logs: import_zod8.z.boolean().optional().default(false),
+  dapp_dashboard_url: import_zod8.z.string().optional().nullable(),
+  syslog_endpoint: import_zod8.z.string().optional().nullable(),
   kms_info: KmsInfoSchema.optional().nullable(),
-  contract_address: import_zod7.z.string().optional().nullable(),
-  deployer_address: import_zod7.z.string().optional().nullable(),
-  scheduled_delete_at: import_zod7.z.string().optional().nullable(),
-  public_urls: import_zod7.z.array(CvmNetworkUrlsSchema).optional().default([]),
-  gateway_domain: import_zod7.z.string().optional().nullable()
-});
-var VMSchema = import_zod7.z.object({
-  id: import_zod7.z.number(),
-  name: import_zod7.z.string(),
-  status: import_zod7.z.string(),
-  teepod_id: import_zod7.z.number(),
-  teepod: CvmNodeSchema.optional().nullable(),
-  user_id: import_zod7.z.number().optional().nullable(),
-  app_id: import_zod7.z.string(),
-  vm_uuid: import_zod7.z.string().nullable(),
-  instance_id: import_zod7.z.string().nullable(),
-  app_url: import_zod7.z.string().optional().nullable(),
-  base_image: import_zod7.z.string().nullable(),
-  vcpu: import_zod7.z.number(),
-  memory: import_zod7.z.number(),
-  disk_size: import_zod7.z.number(),
-  manifest_version: import_zod7.z.number().optional().nullable(),
-  version: import_zod7.z.string().optional().nullable(),
-  runner: import_zod7.z.string().optional().nullable(),
-  docker_compose_file: import_zod7.z.string().optional().nullable(),
-  features: import_zod7.z.array(import_zod7.z.string()).optional().nullable(),
-  created_at: import_zod7.z.string(),
-  // datetime serialized as ISO string
-  encrypted_env_pubkey: import_zod7.z.string().nullable()
+  contract_address: import_zod8.z.string().optional().nullable(),
+  deployer_address: import_zod8.z.string().optional().nullable(),
+  scheduled_delete_at: import_zod8.z.string().optional().nullable(),
+  public_urls: import_zod8.z.array(CvmNetworkUrlsV20251028Schema).optional().default([]),
+  gateway_domain: import_zod8.z.string().optional().nullable(),
+  machine_info: MachineInfoV20251028Schema.optional().nullable(),
+  updated_at: import_zod8.z.string().optional().nullable()
+});
+var PaginatedCvmInfosV20251028Schema = import_zod8.z.object({
+  items: import_zod8.z.array(CvmInfoV20251028Schema),
+  total: import_zod8.z.number(),
+  page: import_zod8.z.number(),
+  page_size: import_zod8.z.number(),
+  pages: import_zod8.z.number()
+});
+
+// src/types/cvm_info_v20260121.ts
+var import_zod9 = require("zod");
+var BillingPeriodSchema = import_zod9.z.enum(["skip", "hourly", "monthly"]);
+var KmsTypeSchema = import_zod9.z.enum(["phala", "ethereum", "base", "legacy"]);
+var UserRefSchema = import_zod9.z.object({
+  object_type: import_zod9.z.literal("user"),
+  id: import_zod9.z.string().nullable().optional(),
+  username: import_zod9.z.string().nullable().optional(),
+  avatar_url: import_zod9.z.string().nullable().optional()
+});
+var WorkspaceRefSchema = import_zod9.z.object({
+  object_type: import_zod9.z.literal("workspace"),
+  id: import_zod9.z.string(),
+  name: import_zod9.z.string(),
+  slug: import_zod9.z.string().nullable().optional(),
+  avatar_url: import_zod9.z.string().nullable().optional()
+});
+var CvmResourceInfoV20260121Schema = import_zod9.z.object({
+  instance_type: import_zod9.z.string().nullable().optional(),
+  vcpu: import_zod9.z.number().int().nullable().optional(),
+  memory_in_gb: import_zod9.z.number().nullable().optional(),
+  disk_in_gb: import_zod9.z.number().int().nullable().optional(),
+  gpus: import_zod9.z.number().int().nullable().optional(),
+  compute_billing_price: import_zod9.z.string().nullable().optional(),
+  billing_period: BillingPeriodSchema.nullable().optional()
+});
+var CvmOsInfoV20260121Schema = import_zod9.z.object({
+  name: import_zod9.z.string().nullable().optional(),
+  version: import_zod9.z.string().nullable().optional(),
+  is_dev: import_zod9.z.boolean().nullable().optional(),
+  os_image_hash: import_zod9.z.string().nullable().optional()
+});
+var CvmKmsInfoV20260121Schema = import_zod9.z.object({
+  chain_id: import_zod9.z.number().int().nullable().optional(),
+  dstack_kms_address: import_zod9.z.string().nullable().optional(),
+  dstack_app_address: import_zod9.z.string().nullable().optional(),
+  deployer_address: import_zod9.z.string().nullable().optional(),
+  rpc_endpoint: import_zod9.z.string().nullable().optional(),
+  encrypted_env_pubkey: import_zod9.z.string().nullable().optional()
+});
+var CvmProgressInfoV20260121Schema = import_zod9.z.object({
+  target: import_zod9.z.string().nullable().optional(),
+  started_at: import_zod9.z.string().nullable().optional(),
+  correlation_id: import_zod9.z.string().nullable().optional()
+});
+var CvmGatewayInfoV20260121Schema = import_zod9.z.object({
+  base_domain: import_zod9.z.string().nullable().optional(),
+  cname: import_zod9.z.string().nullable().optional()
+});
+var CvmNodeInfoV20260121Schema = import_zod9.z.object({
+  name: import_zod9.z.string().nullable().optional(),
+  region: import_zod9.z.string().nullable().optional(),
+  device_id: import_zod9.z.string().nullable().optional(),
+  ppid: import_zod9.z.string().nullable().optional(),
+  status: import_zod9.z.string().nullable().optional(),
+  version: import_zod9.z.string().nullable().optional()
+});
+var CvmInfoV20260121Schema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  // hashed CvmId
+  name: import_zod9.z.string(),
+  app_id: import_zod9.z.string().nullable().optional(),
+  vm_uuid: import_zod9.z.string().nullable().optional(),
+  resource: CvmResourceInfoV20260121Schema,
+  node_info: CvmNodeInfoV20260121Schema.nullable().optional(),
+  os: CvmOsInfoV20260121Schema.nullable().optional(),
+  kms_type: KmsTypeSchema.nullable().optional(),
+  kms_info: CvmKmsInfoV20260121Schema.nullable().optional(),
+  status: import_zod9.z.string(),
+  progress: CvmProgressInfoV20260121Schema.nullable().optional(),
+  compose_hash: import_zod9.z.string().nullable().optional(),
+  gateway: CvmGatewayInfoV20260121Schema,
+  services: import_zod9.z.array(import_zod9.z.record(import_zod9.z.any())).optional().default([]),
+  endpoints: import_zod9.z.array(CvmNetworkUrlsV20251028Schema).nullable().optional(),
+  public_logs: import_zod9.z.boolean().optional(),
+  public_sysinfo: import_zod9.z.boolean().optional(),
+  public_tcbinfo: import_zod9.z.boolean().optional(),
+  gateway_enabled: import_zod9.z.boolean().optional(),
+  secure_time: import_zod9.z.boolean().optional(),
+  storage_fs: import_zod9.z.string().optional(),
+  workspace: WorkspaceRefSchema.nullable().optional(),
+  creator: UserRefSchema.nullable().optional()
+});
+var CvmInfoDetailV20260121Schema = CvmInfoV20260121Schema.extend({
+  compose_file: import_zod9.z.union([import_zod9.z.record(import_zod9.z.any()), import_zod9.z.string()]).nullable().optional()
+});
+var PaginatedCvmInfosV20260121Schema = import_zod9.z.object({
+  items: import_zod9.z.array(CvmInfoV20260121Schema),
+  total: import_zod9.z.number(),
+  page: import_zod9.z.number(),
+  page_size: import_zod9.z.number(),
+  pages: import_zod9.z.number()
 });
 
 // src/types/cvm_id.ts
-var import_zod8 = require("zod");
-var CvmIdObjectSchema = import_zod8.z.object({
-  /** Direct CVM ID (any format) */
-  id: import_zod8.z.string().optional(),
+var import_zod10 = require("zod");
+
+// src/utils/hostname.ts
+function isValidHostname(name) {
+  if (typeof name !== "string" || name.length < 5 || name.length > 63) {
+    return false;
+  }
+  return /^[a-zA-Z](?!.*--)([a-zA-Z0-9-]*[a-zA-Z0-9])?$/.test(name);
+}
+function convertToHostname(input) {
+  if (typeof input !== "string") {
+    return generateFallbackHostname();
+  }
+  let result = input;
+  result = result.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+  result = result.replace(/_/g, "-");
+  result = result.replace(/[^a-z0-9\s-]/gi, "-").replace(/\s+/g, "-");
+  result = result.replace(/-+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+  if (result.length === 0) {
+    return generateFallbackHostname();
+  }
+  if (/^\d/.test(result)) {
+    result = `dstack-app-${result}`;
+  }
+  if (result.length < 5) {
+    result = `dstack-app-${result}`;
+  }
+  result = result.slice(0, 63).replace(/-+$/, "");
+  if (result.length === 0) {
+    return generateFallbackHostname();
+  }
+  if (!isValidHostname(result)) {
+    return generateFallbackHostname();
+  }
+  return result;
+}
+function generateFallbackHostname() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 6);
+  return `dstack-app-${timestamp}-${random}`;
+}
+function generateDefaultCvmName(prefix = "dstack-app") {
+  const random = Array.from(
+    { length: 5 },
+    () => "abcdefghijklmnopqrstuvwxyz0123456789"[Math.floor(Math.random() * 36)]
+  ).join("");
+  const result = `${prefix}-${random}`;
+  if (result.length > 63) {
+    const shortRandom = Array.from(
+      { length: 3 },
+      () => "abcdefghijklmnopqrstuvwxyz0123456789"[Math.floor(Math.random() * 36)]
+    ).join("");
+    return `${prefix.slice(0, 55)}-${shortRandom}`;
+  }
+  return result;
+}
+
+// src/types/cvm_id.ts
+var CvmIdObjectSchema = import_zod10.z.object({
+  /** Direct CVM ID (any format) - accepts any string including names */
+  id: import_zod10.z.string().optional(),
   /** UUID format (with or without dashes) */
-  uuid: import_zod8.z.string().regex(
+  uuid: import_zod10.z.string().regex(
     /^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i,
     "Invalid UUID format"
   ).optional(),
   /** App ID (40 characters, optionally prefixed with 'app_id_') */
-  app_id: import_zod8.z.string().optional(),
+  app_id: import_zod10.z.string().optional(),
   /** Instance ID (40 characters, optionally prefixed with 'instance_') */
-  instance_id: import_zod8.z.string().optional()
+  instance_id: import_zod10.z.string().optional(),
+  /** CVM name (RFC 1123 hostname format: 5-63 chars, starts with letter, alphanumeric + hyphens) */
+  name: import_zod10.z.string().refine(isValidHostname, {
+    message: "Name must be 5-63 characters, start with letter, and contain only letters/numbers/hyphens"
+  }).optional()
 });
 var refineCvmId = (schema) => schema.refine(
   (data) => {
     const obj = data;
-    return !!(obj.id || obj.uuid || obj.app_id || obj.instance_id);
+    return !!(obj.id || obj.uuid || obj.app_id || obj.instance_id || obj.name);
   },
   {
-    message: "One of id, uuid, app_id, or instance_id must be provided"
+    message: "One of id, uuid, app_id, instance_id, or name must be provided"
   }
 );
 var CvmIdBaseSchema = refineCvmId(CvmIdObjectSchema);
 var CvmIdSchema = CvmIdBaseSchema.transform((data) => {
-  let cvmId;
+  let rawValue;
   if (data.id) {
-    cvmId = data.id;
+    rawValue = data.id;
   } else if (data.uuid) {
-    cvmId = data.uuid.replace(/-/g, "");
+    rawValue = data.uuid;
   } else if (data.app_id) {
-    cvmId = data.app_id.startsWith("app_") ? data.app_id : `app_${data.app_id}`;
+    rawValue = data.app_id;
   } else if (data.instance_id) {
-    cvmId = data.instance_id.startsWith("instance_") ? data.instance_id : `instance_${data.instance_id}`;
+    rawValue = data.instance_id;
+  } else if (data.name) {
+    return { cvmId: data.name };
   } else {
     throw new Error("No valid identifier provided");
   }
+  const uuidRegex = /^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i;
+  const appIdRegex = /^[0-9a-f]{40}$/i;
+  let cvmId;
+  if (uuidRegex.test(rawValue)) {
+    cvmId = rawValue.replace(/-/g, "");
+  } else if (appIdRegex.test(rawValue)) {
+    cvmId = `app_${rawValue}`;
+  } else {
+    cvmId = rawValue;
+  }
   return { cvmId };
 });
 
 // src/actions/cvms/get_cvm_info.ts
 var GetCvmInfoRequestSchema = CvmIdSchema;
-var { action: getCvmInfo, safeAction: safeGetCvmInfo } = defineAction(CvmLegacyDetailSchema, async (client, request) => {
+function getSchemaForVersion2(version) {
+  return version === "2025-10-28" ? CvmDetailV20251028Schema : CvmInfoDetailV20260121Schema;
+}
+async function getCvmInfo(client, request) {
   const { cvmId } = GetCvmInfoRequestSchema.parse(request);
-  return await client.get(`/cvms/${cvmId}`);
-});
+  const response = await client.get(`/cvms/${cvmId}`);
+  const schema = getSchemaForVersion2(client.config.version);
+  return schema.parse(response);
+}
+async function safeGetCvmInfo(client, request) {
+  try {
+    const data = await getCvmInfo(client, request);
+    return { success: true, data };
+  } catch (error) {
+    if (error && typeof error === "object" && ("status" in error || "issues" in error)) {
+      return { success: false, error };
+    }
+    return {
+      success: false,
+      error: {
+        name: "Error",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
 
 // src/actions/cvms/get_cvm_list.ts
-var import_zod9 = require("zod");
-var GetCvmListRequestSchema = import_zod9.z.object({
-  page: import_zod9.z.number().int().min(1).optional(),
-  page_size: import_zod9.z.number().int().min(1).optional(),
-  node_id: import_zod9.z.number().int().min(1).optional(),
-  teepod_id: import_zod9.z.number().int().min(1).optional(),
-  user_id: import_zod9.z.string().optional()
-}).strict();
-var GetCvmListSchema = import_zod9.z.object({
-  items: import_zod9.z.array(CvmInfoSchema),
-  total: import_zod9.z.number(),
-  page: import_zod9.z.number(),
-  page_size: import_zod9.z.number(),
-  pages: import_zod9.z.number()
+var import_zod11 = require("zod");
+var GetCvmListRequestSchema = import_zod11.z.object({
+  page: import_zod11.z.number().int().min(1).optional(),
+  page_size: import_zod11.z.number().int().min(1).optional(),
+  node_id: import_zod11.z.number().int().min(1).optional(),
+  teepod_id: import_zod11.z.number().int().min(1).optional(),
+  user_id: import_zod11.z.string().optional()
 }).strict();
-var { action: getCvmList, safeAction: safeGetCvmList } = defineAction(GetCvmListSchema, async (client, request) => {
+function getSchemaForVersion3(version) {
+  return version === "2025-10-28" ? PaginatedCvmInfosV20251028Schema : PaginatedCvmInfosV20260121Schema;
+}
+async function getCvmList(client, request) {
   const validatedRequest = GetCvmListRequestSchema.parse(request ?? {});
-  return await client.get("/cvms/paginated", { params: validatedRequest });
-});
+  const response = await client.get("/cvms/paginated", { params: validatedRequest });
+  const schema = getSchemaForVersion3(client.config.version);
+  return schema.parse(response);
+}
+async function safeGetCvmList(client, request) {
+  try {
+    const data = await getCvmList(client, request);
+    return { success: true, data };
+  } catch (error) {
+    if (error && typeof error === "object" && ("status" in error || "issues" in error)) {
+      return { success: false, error };
+    }
+    return {
+      success: false,
+      error: {
+        name: "Error",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
 
 // src/actions/cvms/provision_cvm.ts
-var import_zod10 = require("zod");
-var ProvisionCvmSchema = import_zod10.z.object({
-  app_id: import_zod10.z.string().nullable().optional(),
-  app_env_encrypt_pubkey: import_zod10.z.string().nullable().optional(),
-  compose_hash: import_zod10.z.string(),
-  fmspc: import_zod10.z.string().nullable().optional(),
-  device_id: import_zod10.z.string().nullable().optional(),
-  os_image_hash: import_zod10.z.string().nullable().optional(),
-  instance_type: import_zod10.z.string().nullable().optional(),
-  teepod_id: import_zod10.z.number().nullable().optional(),
+var import_zod12 = require("zod");
+var ProvisionCvmSchema = import_zod12.z.object({
+  app_id: import_zod12.z.string().nullable().optional(),
+  app_env_encrypt_pubkey: import_zod12.z.string().nullable().optional(),
+  compose_hash: import_zod12.z.string(),
+  kms_info: KmsInfoSchema.nullable().optional(),
+  fmspc: import_zod12.z.string().nullable().optional(),
+  device_id: import_zod12.z.string().nullable().optional(),
+  os_image_hash: import_zod12.z.string().nullable().optional(),
+  instance_type: import_zod12.z.string().nullable().optional(),
+  teepod_id: import_zod12.z.number().nullable().optional(),
   // Will be transformed to node_id
-  node_id: import_zod10.z.number().nullable().optional(),
-  kms_id: import_zod10.z.string().nullable().optional()
+  node_id: import_zod12.z.number().nullable().optional(),
+  kms_id: import_zod12.z.string().nullable().optional()
 }).passthrough().transform((data) => {
   if ("teepod_id" in data && data.teepod_id !== void 0) {
     const { teepod_id, ...rest } = data;
@@ -1380,47 +1790,55 @@ var ProvisionCvmSchema = import_zod10.z.object({
   }
   return data;
 });
-var ProvisionCvmRequestSchema = import_zod10.z.object({
-  node_id: import_zod10.z.number().optional(),
+var NAME_VALIDATION_MESSAGE = "Name must be 5-63 characters, start with letter, and contain only letters/numbers/hyphens";
+var ProvisionCvmRequestSchema = import_zod12.z.object({
+  node_id: import_zod12.z.number().optional(),
   // recommended - optional, system auto-selects if not specified
-  teepod_id: import_zod10.z.number().optional(),
+  teepod_id: import_zod12.z.number().optional(),
   // deprecated, for compatibility
-  region: import_zod10.z.string().optional(),
+  region: import_zod12.z.string().optional(),
   // optional - region filter for auto-selection
-  name: import_zod10.z.string(),
-  instance_type: import_zod10.z.string().default("tdx.small"),
-  // defaults to "tdx.small"
-  image: import_zod10.z.string().optional(),
-  vcpu: import_zod10.z.number().optional(),
-  memory: import_zod10.z.number().optional(),
-  disk_size: import_zod10.z.number().optional(),
-  compose_file: import_zod10.z.object({
-    allowed_envs: import_zod10.z.array(import_zod10.z.string()).optional(),
-    pre_launch_script: import_zod10.z.string().optional(),
-    docker_compose_file: import_zod10.z.string().optional(),
-    name: import_zod10.z.string().optional().default(""),
+  name: import_zod12.z.string().min(5, NAME_VALIDATION_MESSAGE).max(63, NAME_VALIDATION_MESSAGE).refine((val) => isValidHostname(val), NAME_VALIDATION_MESSAGE),
+  instance_type: import_zod12.z.string().optional(),
+  // optional, defaults to "tdx.small" when no resource params specified
+  image: import_zod12.z.string().optional(),
+  vcpu: import_zod12.z.number().optional(),
+  // deprecated, use instance_type instead
+  memory: import_zod12.z.number().optional(),
+  // deprecated, use instance_type instead
+  disk_size: import_zod12.z.number().optional(),
+  compose_file: import_zod12.z.object({
+    allowed_envs: import_zod12.z.array(import_zod12.z.string()).optional(),
+    pre_launch_script: import_zod12.z.string().optional(),
+    docker_compose_file: import_zod12.z.string().optional(),
+    name: import_zod12.z.string().optional().default(""),
     // optional with default empty string
-    kms_enabled: import_zod10.z.boolean().optional(),
-    public_logs: import_zod10.z.boolean().optional(),
-    public_sysinfo: import_zod10.z.boolean().optional(),
-    gateway_enabled: import_zod10.z.boolean().optional(),
+    kms_enabled: import_zod12.z.boolean().optional(),
+    public_logs: import_zod12.z.boolean().optional(),
+    public_sysinfo: import_zod12.z.boolean().optional(),
+    gateway_enabled: import_zod12.z.boolean().optional(),
     // recommended
-    tproxy_enabled: import_zod10.z.boolean().optional()
+    tproxy_enabled: import_zod12.z.boolean().optional()
     // deprecated, for compatibility
   }),
-  listed: import_zod10.z.boolean().optional(),
-  kms_id: import_zod10.z.string().optional(),
-  kms: import_zod10.z.enum(["PHALA", "ETHEREUM", "BASE"]).optional(),
+  listed: import_zod12.z.boolean().optional(),
+  kms_id: import_zod12.z.string().optional(),
+  kms: import_zod12.z.enum(["PHALA", "ETHEREUM", "BASE"]).optional(),
   // KMS type selection (defaults to PHALA)
-  kms_contract: import_zod10.z.string().optional(),
+  kms_contract: import_zod12.z.string().optional(),
   // KMS contract address for on-chain KMS
-  env_keys: import_zod10.z.array(import_zod10.z.string()).optional(),
+  env_keys: import_zod12.z.array(import_zod12.z.string()).optional(),
   // Manual nonce specification (Advanced - PHALA KMS only)
-  nonce: import_zod10.z.number().optional(),
+  nonce: import_zod12.z.number().optional(),
   // User-specified nonce for deterministic app_id generation
-  app_id: import_zod10.z.string().optional()
+  app_id: import_zod12.z.string().optional()
   // Expected app_id (must match calculated app_id from nonce)
-}).passthrough();
+}).passthrough().transform((data) => {
+  if (!data.instance_type && !data.vcpu && !data.memory) {
+    return { ...data, instance_type: "tdx.small" };
+  }
+  return data;
+});
 function handleGatewayCompatibility(appCompose) {
   if (!appCompose.compose_file) {
     return appCompose;
@@ -1456,63 +1874,64 @@ var { action: provisionCvm, safeAction: safeProvisionCvm } = defineAction(Provis
 });
 
 // src/actions/cvms/commit_cvm_provision.ts
-var import_zod11 = require("zod");
-var CommitCvmProvisionSchema = import_zod11.z.object({
-  id: import_zod11.z.number(),
-  name: import_zod11.z.string(),
-  status: import_zod11.z.string(),
-  teepod_id: import_zod11.z.number(),
-  teepod: import_zod11.z.object({
-    id: import_zod11.z.number(),
-    name: import_zod11.z.string()
+var import_zod13 = require("zod");
+var CommitCvmProvisionSchema = import_zod13.z.object({
+  id: import_zod13.z.number(),
+  name: import_zod13.z.string(),
+  status: import_zod13.z.string(),
+  teepod_id: import_zod13.z.number(),
+  teepod: import_zod13.z.object({
+    id: import_zod13.z.number(),
+    name: import_zod13.z.string()
   }).nullable(),
-  user_id: import_zod11.z.number().nullable(),
-  app_id: import_zod11.z.string().nullable(),
-  vm_uuid: import_zod11.z.string().nullable(),
-  instance_id: import_zod11.z.string().nullable(),
-  app_url: import_zod11.z.string().nullable(),
-  base_image: import_zod11.z.string().nullable(),
-  vcpu: import_zod11.z.number(),
-  memory: import_zod11.z.number(),
-  disk_size: import_zod11.z.number(),
-  manifest_version: import_zod11.z.number().nullable(),
-  version: import_zod11.z.string().nullable(),
-  runner: import_zod11.z.string().nullable(),
-  docker_compose_file: import_zod11.z.string().nullable(),
-  features: import_zod11.z.array(import_zod11.z.string()).nullable(),
-  created_at: import_zod11.z.string(),
-  encrypted_env_pubkey: import_zod11.z.string().nullable().optional(),
-  app_auth_contract_address: import_zod11.z.string().nullable().optional(),
-  deployer_address: import_zod11.z.string().nullable().optional()
+  user_id: import_zod13.z.number().nullable(),
+  app_id: import_zod13.z.string().nullable(),
+  vm_uuid: import_zod13.z.string().nullable(),
+  instance_id: import_zod13.z.string().nullable(),
+  // Deprecated fields - will be removed in next API version
+  app_url: import_zod13.z.string().nullable().default(null),
+  base_image: import_zod13.z.string().nullable(),
+  vcpu: import_zod13.z.number(),
+  memory: import_zod13.z.number(),
+  disk_size: import_zod13.z.number(),
+  manifest_version: import_zod13.z.number().nullable().default(2),
+  version: import_zod13.z.string().nullable().default("1.0.0"),
+  runner: import_zod13.z.string().nullable().default("docker-compose"),
+  docker_compose_file: import_zod13.z.string().nullable(),
+  features: import_zod13.z.array(import_zod13.z.string()).nullable().default(["kms", "tproxy-net"]),
+  created_at: import_zod13.z.string(),
+  encrypted_env_pubkey: import_zod13.z.string().nullable().optional(),
+  app_auth_contract_address: import_zod13.z.string().nullable().optional(),
+  deployer_address: import_zod13.z.string().nullable().optional()
 }).passthrough();
-var CommitCvmProvisionRequestSchema = import_zod11.z.object({
-  encrypted_env: import_zod11.z.string().optional().nullable(),
-  app_id: import_zod11.z.string(),
-  compose_hash: import_zod11.z.string(),
-  kms_id: import_zod11.z.string().optional(),
-  contract_address: import_zod11.z.string().optional(),
-  deployer_address: import_zod11.z.string().optional(),
-  env_keys: import_zod11.z.array(import_zod11.z.string()).optional().nullable()
+var CommitCvmProvisionRequestSchema = import_zod13.z.object({
+  encrypted_env: import_zod13.z.string().optional().nullable(),
+  app_id: import_zod13.z.string(),
+  compose_hash: import_zod13.z.string(),
+  kms_id: import_zod13.z.string().optional(),
+  contract_address: import_zod13.z.string().optional(),
+  deployer_address: import_zod13.z.string().optional(),
+  env_keys: import_zod13.z.array(import_zod13.z.string()).optional().nullable()
 }).passthrough();
 var { action: commitCvmProvision, safeAction: safeCommitCvmProvision } = defineAction(CommitCvmProvisionSchema, async (client, payload) => {
   return await client.post("/cvms", payload);
 });
 
 // src/types/app_compose.ts
-var import_zod12 = require("zod");
-var LooseAppComposeSchema = import_zod12.z.object({
-  allowed_envs: import_zod12.z.array(import_zod12.z.string()).optional(),
-  docker_compose_file: import_zod12.z.string(),
-  features: import_zod12.z.array(import_zod12.z.string()).optional(),
-  name: import_zod12.z.string().optional(),
-  manifest_version: import_zod12.z.number().optional(),
-  kms_enabled: import_zod12.z.boolean().optional(),
-  public_logs: import_zod12.z.boolean().optional(),
-  public_sysinfo: import_zod12.z.boolean().optional(),
-  tproxy_enabled: import_zod12.z.boolean().optional(),
-  pre_launch_script: import_zod12.z.string().optional(),
-  env_pubkey: import_zod12.z.string().optional(),
-  salt: import_zod12.z.string().optional().nullable()
+var import_zod14 = require("zod");
+var LooseAppComposeSchema = import_zod14.z.object({
+  allowed_envs: import_zod14.z.array(import_zod14.z.string()).optional(),
+  docker_compose_file: import_zod14.z.string(),
+  features: import_zod14.z.array(import_zod14.z.string()).optional(),
+  name: import_zod14.z.string().optional(),
+  manifest_version: import_zod14.z.number().optional(),
+  kms_enabled: import_zod14.z.boolean().optional(),
+  public_logs: import_zod14.z.boolean().optional(),
+  public_sysinfo: import_zod14.z.boolean().optional(),
+  tproxy_enabled: import_zod14.z.boolean().optional(),
+  pre_launch_script: import_zod14.z.string().optional(),
+  env_pubkey: import_zod14.z.string().optional(),
+  salt: import_zod14.z.string().optional().nullable()
 }).passthrough();
 
 // src/utils/get_compose_hash.ts
@@ -1575,20 +1994,20 @@ var { action: getCvmComposeFile, safeAction: safeGetCvmComposeFile } = defineAct
 });
 
 // src/actions/cvms/provision_cvm_compose_file_update.ts
-var import_zod13 = require("zod");
-var ProvisionCvmComposeFileUpdateRequestSchema = import_zod13.z.object({
-  id: import_zod13.z.string().optional(),
-  uuid: import_zod13.z.string().regex(/^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i).optional(),
-  app_id: import_zod13.z.string().refine(
+var import_zod15 = require("zod");
+var ProvisionCvmComposeFileUpdateRequestSchema = import_zod15.z.object({
+  id: import_zod15.z.string().optional(),
+  uuid: import_zod15.z.string().regex(/^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i).optional(),
+  app_id: import_zod15.z.string().refine(
     (val) => !val.startsWith("app_") && val.length === 40,
     "app_id should be 40 characters without prefix"
   ).transform((val) => val.startsWith("app_") ? val : `app_${val}`).optional(),
-  instance_id: import_zod13.z.string().refine(
+  instance_id: import_zod15.z.string().refine(
     (val) => !val.startsWith("instance_") && val.length === 40,
     "instance_id should be 40 characters without prefix"
   ).transform((val) => val.startsWith("instance_") ? val : `instance_${val}`).optional(),
   app_compose: LooseAppComposeSchema,
-  update_env_vars: import_zod13.z.boolean().optional().nullable()
+  update_env_vars: import_zod15.z.boolean().optional().nullable()
 }).refine(
   (data) => !!(data.id || data.uuid || data.app_id || data.instance_id),
   "One of id, uuid, app_id, or instance_id must be provided"
@@ -1599,10 +2018,10 @@ var ProvisionCvmComposeFileUpdateRequestSchema = import_zod13.z.object({
     _raw: data
   };
 });
-var ProvisionCvmComposeFileUpdateResultSchema = import_zod13.z.object({
-  app_id: import_zod13.z.string().nullable(),
-  device_id: import_zod13.z.string().nullable(),
-  compose_hash: import_zod13.z.string(),
+var ProvisionCvmComposeFileUpdateResultSchema = import_zod15.z.object({
+  app_id: import_zod15.z.string().nullable(),
+  device_id: import_zod15.z.string().nullable(),
+  compose_hash: import_zod15.z.string(),
   kms_info: KmsInfoSchema.nullable().optional()
 }).passthrough();
 var { action: provisionCvmComposeFileUpdate, safeAction: safeProvisionCvmComposeFileUpdate } = defineAction(ProvisionCvmComposeFileUpdateResultSchema, async (client, request) => {
@@ -1614,22 +2033,22 @@ var { action: provisionCvmComposeFileUpdate, safeAction: safeProvisionCvmCompose
 });
 
 // src/actions/cvms/commit_cvm_compose_file_update.ts
-var import_zod14 = require("zod");
-var CommitCvmComposeFileUpdateRequestSchema = import_zod14.z.object({
-  id: import_zod14.z.string().optional(),
-  uuid: import_zod14.z.string().regex(/^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i).optional(),
-  app_id: import_zod14.z.string().refine(
+var import_zod16 = require("zod");
+var CommitCvmComposeFileUpdateRequestSchema = import_zod16.z.object({
+  id: import_zod16.z.string().optional(),
+  uuid: import_zod16.z.string().regex(/^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i).optional(),
+  app_id: import_zod16.z.string().refine(
     (val) => !val.startsWith("app_") && val.length === 40,
     "app_id should be 40 characters without prefix"
   ).transform((val) => val.startsWith("app_") ? val : `app_${val}`).optional(),
-  instance_id: import_zod14.z.string().refine(
+  instance_id: import_zod16.z.string().refine(
     (val) => !val.startsWith("instance_") && val.length === 40,
     "instance_id should be 40 characters without prefix"
   ).transform((val) => val.startsWith("instance_") ? val : `instance_${val}`).optional(),
-  compose_hash: import_zod14.z.string().min(1, "Compose hash is required"),
-  encrypted_env: import_zod14.z.string().optional(),
-  env_keys: import_zod14.z.array(import_zod14.z.string()).optional(),
-  update_env_vars: import_zod14.z.boolean().optional().nullable()
+  compose_hash: import_zod16.z.string().min(1, "Compose hash is required"),
+  encrypted_env: import_zod16.z.string().optional(),
+  env_keys: import_zod16.z.array(import_zod16.z.string()).optional(),
+  update_env_vars: import_zod16.z.boolean().optional().nullable()
 }).refine(
   (data) => !!(data.id || data.uuid || data.app_id || data.instance_id),
   "One of id, uuid, app_id, or instance_id must be provided"
@@ -1638,10 +2057,10 @@ var CommitCvmComposeFileUpdateRequestSchema = import_zod14.z.object({
   compose_hash: data.compose_hash,
   encrypted_env: data.encrypted_env,
   env_keys: data.env_keys,
-  update_env_vars: !!data.update_env_vars,
+  update_env_vars: data.update_env_vars ?? void 0,
   _raw: data
 }));
-var CommitCvmComposeFileUpdateSchema = import_zod14.z.any().transform(() => void 0);
+var CommitCvmComposeFileUpdateSchema = import_zod16.z.any().transform(() => void 0);
 var { action: commitCvmComposeFileUpdate, safeAction: safeCommitCvmComposeFileUpdate } = defineAction(
   CommitCvmComposeFileUpdateSchema,
   async (client, request) => {
@@ -1649,15 +2068,241 @@ var { action: commitCvmComposeFileUpdate, safeAction: safeCommitCvmComposeFileUp
     return await client.patch(`/cvms/${validatedRequest.cvmId}/compose_file`, {
       compose_hash: validatedRequest.compose_hash,
       encrypted_env: validatedRequest.encrypted_env,
-      env_keys: validatedRequest.env_keys
+      env_keys: validatedRequest.env_keys,
+      update_env_vars: validatedRequest.update_env_vars
     });
   }
 );
 
+// src/actions/cvms/update_cvm_envs.ts
+var import_zod17 = require("zod");
+var UpdateCvmEnvsRequestSchema = refineCvmId(
+  CvmIdObjectSchema.extend({
+    encrypted_env: import_zod17.z.string().describe("Encrypted environment variables (hex string)"),
+    env_keys: import_zod17.z.array(import_zod17.z.string()).optional().describe("List of allowed environment variable keys"),
+    compose_hash: import_zod17.z.string().optional().describe("Compose hash for verification (Phase 2, required when env_keys changes)"),
+    transaction_hash: import_zod17.z.string().optional().describe(
+      "On-chain transaction hash for verification (Phase 2, required when env_keys changes)"
+    )
+  })
+).transform((data) => {
+  const { cvmId } = CvmIdSchema.parse(data);
+  return {
+    cvmId,
+    request: {
+      encrypted_env: data.encrypted_env,
+      env_keys: data.env_keys,
+      compose_hash: data.compose_hash,
+      transaction_hash: data.transaction_hash
+    },
+    _raw: data
+  };
+});
+var UpdateCvmEnvsInProgressSchema = import_zod17.z.object({
+  status: import_zod17.z.literal("in_progress"),
+  message: import_zod17.z.string(),
+  correlation_id: import_zod17.z.string(),
+  allowed_envs_changed: import_zod17.z.boolean()
+});
+var UpdateCvmEnvsPreconditionRequiredSchema = import_zod17.z.object({
+  status: import_zod17.z.literal("precondition_required"),
+  message: import_zod17.z.string(),
+  compose_hash: import_zod17.z.string(),
+  app_id: import_zod17.z.string(),
+  device_id: import_zod17.z.string(),
+  kms_info: KmsInfoSchema
+});
+var UpdateCvmEnvsResultSchema = import_zod17.z.union([
+  UpdateCvmEnvsInProgressSchema,
+  UpdateCvmEnvsPreconditionRequiredSchema
+]);
+var { action: updateCvmEnvs, safeAction: safeUpdateCvmEnvs } = defineAction(UpdateCvmEnvsResultSchema, async (client, request) => {
+  const validatedRequest = UpdateCvmEnvsRequestSchema.parse(request);
+  try {
+    const response = await client.patch(
+      `/cvms/${validatedRequest.cvmId}/envs`,
+      validatedRequest.request
+    );
+    return response;
+  } catch (error) {
+    if (error instanceof PhalaCloudError && error.status === 465) {
+      const detail = error.detail;
+      if (detail && typeof detail === "object") {
+        const detailObj = detail;
+        return {
+          status: "precondition_required",
+          message: detailObj.message || "Compose hash verification required",
+          compose_hash: detailObj.compose_hash,
+          app_id: detailObj.app_id,
+          device_id: detailObj.device_id,
+          kms_info: detailObj.kms_info
+        };
+      }
+    }
+    throw error;
+  }
+});
+
+// src/actions/cvms/update_docker_compose.ts
+var import_zod18 = require("zod");
+var UpdateDockerComposeRequestSchema = refineCvmId(
+  CvmIdObjectSchema.extend({
+    docker_compose_file: import_zod18.z.string().describe("Docker Compose YAML content"),
+    compose_hash: import_zod18.z.string().optional().describe("Compose hash for verification (Phase 2, contract-owned KMS only)"),
+    transaction_hash: import_zod18.z.string().optional().describe("On-chain transaction hash for verification (Phase 2, contract-owned KMS only)")
+  })
+).transform((data) => {
+  const { cvmId } = CvmIdSchema.parse(data);
+  return {
+    cvmId,
+    request: {
+      docker_compose_file: data.docker_compose_file,
+      compose_hash: data.compose_hash,
+      transaction_hash: data.transaction_hash
+    },
+    _raw: data
+  };
+});
+var UpdateDockerComposeInProgressSchema = import_zod18.z.object({
+  status: import_zod18.z.literal("in_progress"),
+  message: import_zod18.z.string(),
+  correlation_id: import_zod18.z.string()
+});
+var UpdateDockerComposePreconditionRequiredSchema = import_zod18.z.object({
+  status: import_zod18.z.literal("precondition_required"),
+  message: import_zod18.z.string(),
+  compose_hash: import_zod18.z.string(),
+  app_id: import_zod18.z.string(),
+  device_id: import_zod18.z.string(),
+  kms_info: KmsInfoSchema
+});
+var UpdateDockerComposeResultSchema = import_zod18.z.union([
+  UpdateDockerComposeInProgressSchema,
+  UpdateDockerComposePreconditionRequiredSchema
+]);
+var { action: updateDockerCompose, safeAction: safeUpdateDockerCompose } = defineAction(UpdateDockerComposeResultSchema, async (client, request) => {
+  const validatedRequest = UpdateDockerComposeRequestSchema.parse(request);
+  const headers = {
+    "Content-Type": "text/yaml"
+  };
+  if (validatedRequest.request.compose_hash) {
+    headers["X-Compose-Hash"] = validatedRequest.request.compose_hash;
+  }
+  if (validatedRequest.request.transaction_hash) {
+    headers["X-Transaction-Hash"] = validatedRequest.request.transaction_hash;
+  }
+  try {
+    const response = await client.patch(
+      `/cvms/${validatedRequest.cvmId}/docker-compose`,
+      validatedRequest.request.docker_compose_file,
+      { headers }
+    );
+    return response;
+  } catch (error) {
+    if (error instanceof PhalaCloudError && error.status === 465) {
+      const detail = error.detail;
+      if (detail && typeof detail === "object") {
+        const detailObj = detail;
+        return {
+          status: "precondition_required",
+          message: detailObj.message || "Compose hash verification required",
+          compose_hash: detailObj.compose_hash,
+          app_id: detailObj.app_id,
+          device_id: detailObj.device_id,
+          kms_info: detailObj.kms_info
+        };
+      }
+    }
+    throw error;
+  }
+});
+
+// src/actions/cvms/update_prelaunch_script.ts
+var import_zod19 = require("zod");
+var UpdatePreLaunchScriptRequestSchema = refineCvmId(
+  CvmIdObjectSchema.extend({
+    pre_launch_script: import_zod19.z.string().describe("Pre-launch script content (shell script)"),
+    compose_hash: import_zod19.z.string().optional().describe("Compose hash for verification (Phase 2, contract-owned KMS only)"),
+    transaction_hash: import_zod19.z.string().optional().describe("On-chain transaction hash for verification (Phase 2, contract-owned KMS only)")
+  })
+).transform((data) => {
+  const { cvmId } = CvmIdSchema.parse(data);
+  return {
+    cvmId,
+    request: {
+      pre_launch_script: data.pre_launch_script,
+      compose_hash: data.compose_hash,
+      transaction_hash: data.transaction_hash
+    },
+    _raw: data
+  };
+});
+var UpdatePreLaunchScriptInProgressSchema = import_zod19.z.object({
+  status: import_zod19.z.literal("in_progress"),
+  message: import_zod19.z.string(),
+  correlation_id: import_zod19.z.string()
+});
+var UpdatePreLaunchScriptPreconditionRequiredSchema = import_zod19.z.object({
+  status: import_zod19.z.literal("precondition_required"),
+  message: import_zod19.z.string(),
+  compose_hash: import_zod19.z.string(),
+  app_id: import_zod19.z.string(),
+  device_id: import_zod19.z.string(),
+  kms_info: KmsInfoSchema
+});
+var UpdatePreLaunchScriptResultSchema = import_zod19.z.union([
+  UpdatePreLaunchScriptInProgressSchema,
+  UpdatePreLaunchScriptPreconditionRequiredSchema
+]);
+var { action: updatePreLaunchScript, safeAction: safeUpdatePreLaunchScript } = defineAction(UpdatePreLaunchScriptResultSchema, async (client, request) => {
+  const validatedRequest = UpdatePreLaunchScriptRequestSchema.parse(request);
+  const headers = {
+    "Content-Type": "text/plain"
+  };
+  if (validatedRequest.request.compose_hash) {
+    headers["X-Compose-Hash"] = validatedRequest.request.compose_hash;
+  }
+  if (validatedRequest.request.transaction_hash) {
+    headers["X-Transaction-Hash"] = validatedRequest.request.transaction_hash;
+  }
+  try {
+    const response = await client.patch(
+      `/cvms/${validatedRequest.cvmId}/pre-launch-script`,
+      validatedRequest.request.pre_launch_script,
+      { headers }
+    );
+    return response;
+  } catch (error) {
+    if (error instanceof PhalaCloudError && error.status === 465) {
+      const detail = error.detail;
+      if (detail && typeof detail === "object") {
+        const detailObj = detail;
+        return {
+          status: "precondition_required",
+          message: detailObj.message || "Compose hash verification required",
+          compose_hash: detailObj.compose_hash,
+          app_id: detailObj.app_id,
+          device_id: detailObj.device_id,
+          kms_info: detailObj.kms_info
+        };
+      }
+    }
+    throw error;
+  }
+});
+
+// src/actions/cvms/get_cvm_prelaunch_script.ts
+var import_zod20 = require("zod");
+var GetCvmPreLaunchScriptRequestSchema = CvmIdSchema;
+var { action: getCvmPreLaunchScript, safeAction: safeGetCvmPreLaunchScript } = defineAction(import_zod20.z.string(), async (client, request) => {
+  const { cvmId } = GetCvmPreLaunchScriptRequestSchema.parse(request);
+  return await client.get(`/cvms/${cvmId}/pre-launch-script`);
+});
+
 // src/actions/kms/get_kms_info.ts
-var import_zod15 = require("zod");
-var GetKmsInfoRequestSchema = import_zod15.z.object({
-  kms_id: import_zod15.z.string().min(1, "KMS ID is required")
+var import_zod21 = require("zod");
+var GetKmsInfoRequestSchema = import_zod21.z.object({
+  kms_id: import_zod21.z.string().min(1, "KMS ID is required")
 });
 var { action: getKmsInfo, safeAction: safeGetKmsInfo } = defineAction(KmsInfoSchema, async (client, request) => {
   const validatedRequest = GetKmsInfoRequestSchema.parse(request);
@@ -1665,18 +2310,18 @@ var { action: getKmsInfo, safeAction: safeGetKmsInfo } = defineAction(KmsInfoSch
 });
 
 // src/actions/kms/get_kms_list.ts
-var import_zod16 = require("zod");
-var GetKmsListRequestSchema = import_zod16.z.object({
-  page: import_zod16.z.number().int().min(1).optional(),
-  page_size: import_zod16.z.number().int().min(1).optional(),
-  is_onchain: import_zod16.z.boolean().optional()
+var import_zod22 = require("zod");
+var GetKmsListRequestSchema = import_zod22.z.object({
+  page: import_zod22.z.number().int().min(1).optional(),
+  page_size: import_zod22.z.number().int().min(1).optional(),
+  is_onchain: import_zod22.z.boolean().optional()
 }).strict();
-var GetKmsListSchema = import_zod16.z.object({
-  items: import_zod16.z.array(KmsInfoSchema),
-  total: import_zod16.z.number(),
-  page: import_zod16.z.number(),
-  page_size: import_zod16.z.number(),
-  pages: import_zod16.z.number()
+var GetKmsListSchema = import_zod22.z.object({
+  items: import_zod22.z.array(KmsInfoSchema),
+  total: import_zod22.z.number(),
+  page: import_zod22.z.number(),
+  page_size: import_zod22.z.number(),
+  pages: import_zod22.z.number()
 }).strict();
 var { action: getKmsList, safeAction: safeGetKmsList } = defineAction(GetKmsListSchema, async (client, request) => {
   const validatedRequest = GetKmsListRequestSchema.parse(request ?? {});
@@ -1684,17 +2329,17 @@ var { action: getKmsList, safeAction: safeGetKmsList } = defineAction(GetKmsList
 });
 
 // src/actions/kms/get_app_env_encrypt_pubkey.ts
-var import_zod17 = require("zod");
-var GetAppEnvEncryptPubKeyRequestSchema = import_zod17.z.object({
-  kms: import_zod17.z.string().min(1, "KMS ID or slug is required"),
-  app_id: import_zod17.z.string().refine(
+var import_zod23 = require("zod");
+var GetAppEnvEncryptPubKeyRequestSchema = import_zod23.z.object({
+  kms: import_zod23.z.string().min(1, "KMS ID or slug is required"),
+  app_id: import_zod23.z.string().refine(
     (val) => val.length === 40 || val.startsWith("0x") && val.length === 42,
     "App ID must be exactly 40 characters or 42 characters with 0x prefix"
   )
 }).strict();
-var GetAppEnvEncryptPubKeySchema = import_zod17.z.object({
-  public_key: import_zod17.z.string(),
-  signature: import_zod17.z.string()
+var GetAppEnvEncryptPubKeySchema = import_zod23.z.object({
+  public_key: import_zod23.z.string(),
+  signature: import_zod23.z.string()
 }).strict();
 var { action: getAppEnvEncryptPubKey, safeAction: safeGetAppEnvEncryptPubKey } = defineAction(GetAppEnvEncryptPubKeySchema, async (client, payload) => {
   const validatedRequest = GetAppEnvEncryptPubKeyRequestSchema.parse(payload);
@@ -1702,15 +2347,15 @@ var { action: getAppEnvEncryptPubKey, safeAction: safeGetAppEnvEncryptPubKey } =
 });
 
 // src/actions/kms/next_app_ids.ts
-var import_zod18 = require("zod");
-var NextAppIdsRequestSchema = import_zod18.z.object({
-  counts: import_zod18.z.number().int().min(1).max(20).optional().default(1)
+var import_zod24 = require("zod");
+var NextAppIdsRequestSchema = import_zod24.z.object({
+  counts: import_zod24.z.number().int().min(1).max(20).optional().default(1)
 }).strict();
-var NextAppIdsSchema = import_zod18.z.object({
-  app_ids: import_zod18.z.array(
-    import_zod18.z.object({
-      app_id: import_zod18.z.string(),
-      nonce: import_zod18.z.number().int().min(0)
+var NextAppIdsSchema = import_zod24.z.object({
+  app_ids: import_zod24.z.array(
+    import_zod24.z.object({
+      app_id: import_zod24.z.string(),
+      nonce: import_zod24.z.number().int().min(0)
     })
   )
 }).strict();
@@ -1721,6 +2366,36 @@ var { action: nextAppIds, safeAction: safeNextAppIds } = defineAction(NextAppIds
   return await client.get(`/kms/phala/next_app_id?${params.toString()}`);
 });
 
+// src/types/cvm_info.ts
+var import_zod25 = require("zod");
+var VMSchema = import_zod25.z.object({
+  id: import_zod25.z.number(),
+  name: import_zod25.z.string(),
+  status: import_zod25.z.string(),
+  teepod_id: import_zod25.z.number(),
+  teepod: import_zod25.z.object({
+    id: import_zod25.z.number(),
+    name: import_zod25.z.string(),
+    region_identifier: import_zod25.z.string().nullable().optional()
+  }).optional().nullable(),
+  user_id: import_zod25.z.number().optional().nullable(),
+  app_id: import_zod25.z.string(),
+  vm_uuid: import_zod25.z.string().nullable(),
+  instance_id: import_zod25.z.string().nullable(),
+  app_url: import_zod25.z.string().optional().nullable(),
+  base_image: import_zod25.z.string().nullable(),
+  vcpu: import_zod25.z.number(),
+  memory: import_zod25.z.number(),
+  disk_size: import_zod25.z.number(),
+  manifest_version: import_zod25.z.number().optional().nullable(),
+  version: import_zod25.z.string().optional().nullable(),
+  runner: import_zod25.z.string().optional().nullable(),
+  docker_compose_file: import_zod25.z.string().optional().nullable(),
+  features: import_zod25.z.array(import_zod25.z.string()).optional().nullable(),
+  created_at: import_zod25.z.string(),
+  encrypted_env_pubkey: import_zod25.z.string().nullable()
+});
+
 // src/actions/cvms/start_cvm.ts
 var StartCvmRequestSchema = CvmIdSchema;
 var { action: startCvm, safeAction: safeStartCvm } = defineAction(VMSchema, async (client, request) => {
@@ -1746,10 +2421,10 @@ var { action: shutdownCvm, safeAction: safeShutdownCvm } = defineAction(VMSchema
 });
 
 // src/actions/cvms/restart_cvm.ts
-var import_zod19 = require("zod");
+var import_zod26 = require("zod");
 var RestartCvmRequestSchema = refineCvmId(
   CvmIdObjectSchema.extend({
-    force: import_zod19.z.boolean().optional()
+    force: import_zod26.z.boolean().optional()
   })
 );
 var { action: restartCvm, safeAction: safeRestartCvm } = defineAction(VMSchema, async (client, request) => {
@@ -1760,10 +2435,10 @@ var { action: restartCvm, safeAction: safeRestartCvm } = defineAction(VMSchema,
 });
 
 // src/actions/cvms/delete_cvm.ts
-var import_zod20 = require("zod");
+var import_zod27 = require("zod");
 var DeleteCvmRequestSchema = CvmIdSchema;
 var { action: deleteCvm, safeAction: safeDeleteCvm } = defineAction(
-  import_zod20.z.void(),
+  import_zod27.z.void(),
   async (client, request) => {
     const { cvmId } = DeleteCvmRequestSchema.parse(request);
     await client.delete(`/cvms/${cvmId}`);
@@ -1772,41 +2447,41 @@ var { action: deleteCvm, safeAction: safeDeleteCvm } = defineAction(
 );
 
 // src/actions/cvms/get_cvm_stats.ts
-var import_zod21 = require("zod");
-var DiskInfoSchema = import_zod21.z.object({
-  name: import_zod21.z.string(),
-  mount_point: import_zod21.z.string(),
-  total_size: import_zod21.z.number(),
-  free_size: import_zod21.z.number()
-});
-var SystemInfoSchema = import_zod21.z.object({
-  os_name: import_zod21.z.string(),
-  os_version: import_zod21.z.string(),
-  kernel_version: import_zod21.z.string(),
-  cpu_model: import_zod21.z.string(),
-  num_cpus: import_zod21.z.number(),
-  total_memory: import_zod21.z.number(),
-  available_memory: import_zod21.z.number(),
-  used_memory: import_zod21.z.number(),
-  free_memory: import_zod21.z.number(),
-  total_swap: import_zod21.z.number(),
-  used_swap: import_zod21.z.number(),
-  free_swap: import_zod21.z.number(),
-  uptime: import_zod21.z.number(),
-  loadavg_one: import_zod21.z.number(),
-  loadavg_five: import_zod21.z.number(),
-  loadavg_fifteen: import_zod21.z.number(),
-  disks: import_zod21.z.array(DiskInfoSchema)
-});
-var CvmSystemInfoSchema = import_zod21.z.object({
-  is_online: import_zod21.z.boolean(),
-  is_public: import_zod21.z.boolean().default(false),
-  error: import_zod21.z.string().nullable(),
+var import_zod28 = require("zod");
+var DiskInfoSchema = import_zod28.z.object({
+  name: import_zod28.z.string(),
+  mount_point: import_zod28.z.string(),
+  total_size: import_zod28.z.number(),
+  free_size: import_zod28.z.number()
+});
+var SystemInfoSchema = import_zod28.z.object({
+  os_name: import_zod28.z.string(),
+  os_version: import_zod28.z.string(),
+  kernel_version: import_zod28.z.string(),
+  cpu_model: import_zod28.z.string(),
+  num_cpus: import_zod28.z.number(),
+  total_memory: import_zod28.z.number(),
+  available_memory: import_zod28.z.number(),
+  used_memory: import_zod28.z.number(),
+  free_memory: import_zod28.z.number(),
+  total_swap: import_zod28.z.number(),
+  used_swap: import_zod28.z.number(),
+  free_swap: import_zod28.z.number(),
+  uptime: import_zod28.z.number(),
+  loadavg_one: import_zod28.z.number(),
+  loadavg_five: import_zod28.z.number(),
+  loadavg_fifteen: import_zod28.z.number(),
+  disks: import_zod28.z.array(DiskInfoSchema)
+});
+var CvmSystemInfoSchema = import_zod28.z.object({
+  is_online: import_zod28.z.boolean(),
+  is_public: import_zod28.z.boolean().default(false),
+  error: import_zod28.z.string().nullable(),
   sysinfo: SystemInfoSchema.nullable(),
-  status: import_zod21.z.string().nullable(),
-  in_progress: import_zod21.z.boolean().default(false),
-  boot_progress: import_zod21.z.string().nullable(),
-  boot_error: import_zod21.z.string().nullable()
+  status: import_zod28.z.string().nullable(),
+  in_progress: import_zod28.z.boolean().default(false),
+  boot_progress: import_zod28.z.string().nullable(),
+  boot_error: import_zod28.z.string().nullable()
 });
 var GetCvmStatsRequestSchema = CvmIdSchema;
 var { action: getCvmStats, safeAction: safeGetCvmStats } = defineAction(CvmSystemInfoSchema, async (client, request) => {
@@ -1815,18 +2490,18 @@ var { action: getCvmStats, safeAction: safeGetCvmStats } = defineAction(CvmSyste
 });
 
 // src/actions/cvms/get_cvm_network.ts
-var import_zod22 = require("zod");
-var CvmNetworkUrlsSchema2 = import_zod22.z.object({
-  app: import_zod22.z.string(),
-  instance: import_zod22.z.string()
-});
-var CvmNetworkSchema = import_zod22.z.object({
-  is_online: import_zod22.z.boolean(),
-  is_public: import_zod22.z.boolean().default(true),
-  error: import_zod22.z.string().nullable(),
-  internal_ip: import_zod22.z.string().nullable(),
-  latest_handshake: import_zod22.z.string().nullable(),
-  public_urls: import_zod22.z.array(CvmNetworkUrlsSchema2).nullable()
+var import_zod29 = require("zod");
+var CvmNetworkUrlsSchema = import_zod29.z.object({
+  app: import_zod29.z.string(),
+  instance: import_zod29.z.string()
+});
+var CvmNetworkSchema = import_zod29.z.object({
+  is_online: import_zod29.z.boolean(),
+  is_public: import_zod29.z.boolean().default(true),
+  error: import_zod29.z.string().nullable(),
+  internal_ip: import_zod29.z.string().nullable(),
+  latest_handshake: import_zod29.z.string().nullable(),
+  public_urls: import_zod29.z.array(CvmNetworkUrlsSchema).nullable()
 });
 var GetCvmNetworkRequestSchema = CvmIdSchema;
 var { action: getCvmNetwork, safeAction: safeGetCvmNetwork } = defineAction(CvmNetworkSchema, async (client, request) => {
@@ -1835,36 +2510,36 @@ var { action: getCvmNetwork, safeAction: safeGetCvmNetwork } = defineAction(CvmN
 });
 
 // src/actions/cvms/get_cvm_docker_compose.ts
-var import_zod23 = require("zod");
+var import_zod30 = require("zod");
 var GetCvmDockerComposeRequestSchema = CvmIdSchema;
-var { action: getCvmDockerCompose, safeAction: safeGetCvmDockerCompose } = defineAction(import_zod23.z.string(), async (client, request) => {
+var { action: getCvmDockerCompose, safeAction: safeGetCvmDockerCompose } = defineAction(import_zod30.z.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
-var import_zod24 = require("zod");
-var ContainerInfoSchema = import_zod24.z.object({
-  id: import_zod24.z.string(),
-  names: import_zod24.z.array(import_zod24.z.string()),
-  image: import_zod24.z.string(),
-  image_id: import_zod24.z.string(),
-  command: import_zod24.z.string().nullable().optional(),
-  created: import_zod24.z.number(),
-  state: import_zod24.z.string(),
-  status: import_zod24.z.string(),
-  log_endpoint: import_zod24.z.string().nullable()
-});
-var CvmContainersStatsSchema = import_zod24.z.object({
-  is_online: import_zod24.z.boolean(),
-  is_public: import_zod24.z.boolean().default(true),
-  error: import_zod24.z.string().nullable(),
-  docker_compose_file: import_zod24.z.string().nullable(),
-  manifest_version: import_zod24.z.number().nullable(),
-  version: import_zod24.z.string().nullable(),
-  runner: import_zod24.z.string().nullable(),
-  features: import_zod24.z.array(import_zod24.z.string()).nullable(),
-  containers: import_zod24.z.array(ContainerInfoSchema).nullable()
+var import_zod31 = require("zod");
+var ContainerInfoSchema = import_zod31.z.object({
+  id: import_zod31.z.string(),
+  names: import_zod31.z.array(import_zod31.z.string()),
+  image: import_zod31.z.string(),
+  image_id: import_zod31.z.string(),
+  command: import_zod31.z.string().nullable().optional(),
+  created: import_zod31.z.number(),
+  state: import_zod31.z.string(),
+  status: import_zod31.z.string(),
+  log_endpoint: import_zod31.z.string().nullable()
+});
+var CvmContainersStatsSchema = import_zod31.z.object({
+  is_online: import_zod31.z.boolean(),
+  is_public: import_zod31.z.boolean().default(true),
+  error: import_zod31.z.string().nullable(),
+  docker_compose_file: import_zod31.z.string().nullable(),
+  manifest_version: import_zod31.z.number().nullable(),
+  version: import_zod31.z.string().nullable(),
+  runner: import_zod31.z.string().nullable(),
+  features: import_zod31.z.array(import_zod31.z.string()).nullable(),
+  containers: import_zod31.z.array(ContainerInfoSchema).nullable()
 });
 var GetCvmContainersStatsRequestSchema = CvmIdSchema;
 var { action: getCvmContainersStats, safeAction: safeGetCvmContainersStats } = defineAction(CvmContainersStatsSchema, async (client, request) => {
@@ -1873,62 +2548,62 @@ var { action: getCvmContainersStats, safeAction: safeGetCvmContainersStats } = d
 });
 
 // src/actions/cvms/get_cvm_attestation.ts
-var import_zod25 = require("zod");
-var CertificateSubjectSchema = import_zod25.z.object({
-  common_name: import_zod25.z.string().nullable(),
-  organization: import_zod25.z.string().nullable(),
-  country: import_zod25.z.string().nullable(),
-  state: import_zod25.z.string().nullable(),
-  locality: import_zod25.z.string().nullable()
-});
-var CertificateIssuerSchema = import_zod25.z.object({
-  common_name: import_zod25.z.string().nullable(),
-  organization: import_zod25.z.string().nullable(),
-  country: import_zod25.z.string().nullable()
-});
-var CertificateSchema = import_zod25.z.object({
+var import_zod32 = require("zod");
+var CertificateSubjectSchema = import_zod32.z.object({
+  common_name: import_zod32.z.string().nullable(),
+  organization: import_zod32.z.string().nullable(),
+  country: import_zod32.z.string().nullable(),
+  state: import_zod32.z.string().nullable(),
+  locality: import_zod32.z.string().nullable()
+});
+var CertificateIssuerSchema = import_zod32.z.object({
+  common_name: import_zod32.z.string().nullable(),
+  organization: import_zod32.z.string().nullable(),
+  country: import_zod32.z.string().nullable()
+});
+var CertificateSchema = import_zod32.z.object({
   subject: CertificateSubjectSchema,
   issuer: CertificateIssuerSchema,
-  serial_number: import_zod25.z.string(),
-  not_before: import_zod25.z.string(),
+  serial_number: import_zod32.z.string(),
+  not_before: import_zod32.z.string(),
   // datetime serialized as ISO string
-  not_after: import_zod25.z.string(),
+  not_after: import_zod32.z.string(),
   // datetime serialized as ISO string
-  version: import_zod25.z.string(),
-  fingerprint: import_zod25.z.string(),
-  signature_algorithm: import_zod25.z.string(),
-  sans: import_zod25.z.array(import_zod25.z.string()).nullable(),
-  is_ca: import_zod25.z.boolean(),
-  position_in_chain: import_zod25.z.number().nullable(),
-  quote: import_zod25.z.string().nullable(),
-  app_id: import_zod25.z.string().nullable().optional(),
-  cert_usage: import_zod25.z.string().nullable().optional()
-});
-var EventLogSchema = import_zod25.z.object({
-  imr: import_zod25.z.number(),
-  event_type: import_zod25.z.number(),
-  digest: import_zod25.z.string(),
-  event: import_zod25.z.string(),
-  event_payload: import_zod25.z.string()
-});
-var TcbInfoSchema = import_zod25.z.object({
-  mrtd: import_zod25.z.string(),
-  rootfs_hash: import_zod25.z.string().nullable().optional(),
-  rtmr0: import_zod25.z.string(),
-  rtmr1: import_zod25.z.string(),
-  rtmr2: import_zod25.z.string(),
-  rtmr3: import_zod25.z.string(),
-  event_log: import_zod25.z.array(EventLogSchema),
-  app_compose: import_zod25.z.string()
-});
-var CvmAttestationSchema = import_zod25.z.object({
-  name: import_zod25.z.string().nullable(),
-  is_online: import_zod25.z.boolean(),
-  is_public: import_zod25.z.boolean().default(true),
-  error: import_zod25.z.string().nullable(),
-  app_certificates: import_zod25.z.array(CertificateSchema).nullable(),
+  version: import_zod32.z.string(),
+  fingerprint: import_zod32.z.string(),
+  signature_algorithm: import_zod32.z.string(),
+  sans: import_zod32.z.array(import_zod32.z.string()).nullable(),
+  is_ca: import_zod32.z.boolean(),
+  position_in_chain: import_zod32.z.number().nullable(),
+  quote: import_zod32.z.string().nullable(),
+  app_id: import_zod32.z.string().nullable().optional(),
+  cert_usage: import_zod32.z.string().nullable().optional()
+});
+var EventLogSchema = import_zod32.z.object({
+  imr: import_zod32.z.number(),
+  event_type: import_zod32.z.number(),
+  digest: import_zod32.z.string(),
+  event: import_zod32.z.string(),
+  event_payload: import_zod32.z.string()
+});
+var TcbInfoSchema = import_zod32.z.object({
+  mrtd: import_zod32.z.string(),
+  rootfs_hash: import_zod32.z.string().nullable().optional(),
+  rtmr0: import_zod32.z.string(),
+  rtmr1: import_zod32.z.string(),
+  rtmr2: import_zod32.z.string(),
+  rtmr3: import_zod32.z.string(),
+  event_log: import_zod32.z.array(EventLogSchema),
+  app_compose: import_zod32.z.string()
+});
+var CvmAttestationSchema = import_zod32.z.object({
+  name: import_zod32.z.string().nullable(),
+  is_online: import_zod32.z.boolean(),
+  is_public: import_zod32.z.boolean().default(true),
+  error: import_zod32.z.string().nullable(),
+  app_certificates: import_zod32.z.array(CertificateSchema).nullable(),
   tcb_info: TcbInfoSchema.nullable(),
-  compose_file: import_zod25.z.string().nullable()
+  compose_file: import_zod32.z.string().nullable()
 });
 var GetCvmAttestationRequestSchema = CvmIdSchema;
 var { action: getCvmAttestation, safeAction: safeGetCvmAttestation } = defineAction(CvmAttestationSchema, async (client, request) => {
@@ -1937,17 +2612,17 @@ var { action: getCvmAttestation, safeAction: safeGetCvmAttestation } = defineAct
 });
 
 // src/actions/cvms/update_cvm_resources.ts
-var import_zod26 = require("zod");
+var import_zod33 = require("zod");
 var UpdateCvmResourcesRequestSchema = refineCvmId(
   CvmIdObjectSchema.extend({
-    vcpu: import_zod26.z.number().optional(),
-    memory: import_zod26.z.number().optional(),
-    disk_size: import_zod26.z.number().optional(),
-    instance_type: import_zod26.z.string().optional(),
-    allow_restart: import_zod26.z.boolean().optional()
+    vcpu: import_zod33.z.number().optional(),
+    memory: import_zod33.z.number().optional(),
+    disk_size: import_zod33.z.number().optional(),
+    instance_type: import_zod33.z.string().optional(),
+    allow_restart: import_zod33.z.boolean().optional()
   })
 );
-var { action: updateCvmResources, safeAction: safeUpdateCvmResources } = defineAction(import_zod26.z.void(), async (client, request) => {
+var { action: updateCvmResources, safeAction: safeUpdateCvmResources } = defineAction(import_zod33.z.void(), async (client, request) => {
   const parsed = UpdateCvmResourcesRequestSchema.parse(request);
   const { cvmId } = CvmIdSchema.parse(parsed);
   const { ...body } = parsed;
@@ -1956,14 +2631,14 @@ var { action: updateCvmResources, safeAction: safeUpdateCvmResources } = defineA
 });
 
 // src/actions/cvms/update_cvm_visibility.ts
-var import_zod27 = require("zod");
+var import_zod34 = require("zod");
 var UpdateCvmVisibilityRequestSchema = refineCvmId(
   CvmIdObjectSchema.extend({
-    public_sysinfo: import_zod27.z.boolean(),
-    public_logs: import_zod27.z.boolean()
+    public_sysinfo: import_zod34.z.boolean(),
+    public_logs: import_zod34.z.boolean()
   })
 );
-var { action: updateCvmVisibility, safeAction: safeUpdateCvmVisibility } = defineAction(CvmLegacyDetailSchema, async (client, request) => {
+var { action: updateCvmVisibility, safeAction: safeUpdateCvmVisibility } = defineAction(CvmDetailV20251028Schema, async (client, request) => {
   const parsed = UpdateCvmVisibilityRequestSchema.parse(request);
   const { cvmId } = CvmIdSchema.parse(parsed);
   const { public_sysinfo, public_logs } = parsed;
@@ -1971,21 +2646,21 @@ var { action: updateCvmVisibility, safeAction: safeUpdateCvmVisibility } = defin
 });
 
 // src/actions/cvms/get_available_os_images.ts
-var import_zod28 = require("zod");
-var OSImageVariantSchema = import_zod28.z.object({
-  name: import_zod28.z.string(),
-  os_image_hash: import_zod28.z.string().nullable(),
-  is_current: import_zod28.z.boolean()
+var import_zod35 = require("zod");
+var OSImageVariantSchema = import_zod35.z.object({
+  name: import_zod35.z.string(),
+  os_image_hash: import_zod35.z.string().nullable(),
+  is_current: import_zod35.z.boolean()
 });
-var AvailableOSImageSchema2 = import_zod28.z.object({
-  version: import_zod28.z.union([
-    import_zod28.z.tuple([import_zod28.z.number(), import_zod28.z.number(), import_zod28.z.number(), import_zod28.z.number()]),
-    import_zod28.z.tuple([import_zod28.z.number(), import_zod28.z.number(), import_zod28.z.number()])
+var AvailableOSImageSchema2 = import_zod35.z.object({
+  version: import_zod35.z.union([
+    import_zod35.z.tuple([import_zod35.z.number(), import_zod35.z.number(), import_zod35.z.number(), import_zod35.z.number()]),
+    import_zod35.z.tuple([import_zod35.z.number(), import_zod35.z.number(), import_zod35.z.number()])
   ]),
   prod: OSImageVariantSchema.nullable(),
   dev: OSImageVariantSchema.nullable()
 });
-var GetAvailableOSImagesResponseSchema = import_zod28.z.array(AvailableOSImageSchema2);
+var GetAvailableOSImagesResponseSchema = import_zod35.z.array(AvailableOSImageSchema2);
 var GetAvailableOSImagesRequestSchema = CvmIdSchema;
 var { action: getAvailableOsImages, safeAction: safeGetAvailableOsImages } = defineAction(GetAvailableOSImagesResponseSchema, async (client, request) => {
   const { cvmId } = GetAvailableOSImagesRequestSchema.parse(request);
@@ -1993,13 +2668,13 @@ var { action: getAvailableOsImages, safeAction: safeGetAvailableOsImages } = def
 });
 
 // src/actions/cvms/update_os_image.ts
-var import_zod29 = require("zod");
+var import_zod36 = require("zod");
 var UpdateOsImageRequestSchema = refineCvmId(
   CvmIdObjectSchema.extend({
-    os_image_name: import_zod29.z.string().min(1, "OS image name is required")
+    os_image_name: import_zod36.z.string().min(1, "OS image name is required")
   })
 );
-var { action: updateOsImage, safeAction: safeUpdateOsImage } = defineAction(import_zod29.z.void(), async (client, request) => {
+var { action: updateOsImage, safeAction: safeUpdateOsImage } = defineAction(import_zod36.z.void(), async (client, request) => {
   const parsed = UpdateOsImageRequestSchema.parse(request);
   const { cvmId } = CvmIdSchema.parse(parsed);
   const { os_image_name } = parsed;
@@ -2008,17 +2683,17 @@ var { action: updateOsImage, safeAction: safeUpdateOsImage } = defineAction(impo
 });
 
 // src/actions/cvms/get_cvm_state.ts
-var import_zod30 = require("zod");
-var CvmStateSchema = import_zod30.z.object({
-  id: import_zod30.z.string().optional(),
-  instance_id: import_zod30.z.string().optional(),
-  name: import_zod30.z.string(),
-  status: import_zod30.z.string(),
-  uptime: import_zod30.z.string().optional(),
-  exited_at: import_zod30.z.string().optional(),
-  boot_progress: import_zod30.z.string().optional(),
-  boot_error: import_zod30.z.string().optional(),
-  shutdown_progress: import_zod30.z.string().optional()
+var import_zod37 = require("zod");
+var CvmStateSchema = import_zod37.z.object({
+  id: import_zod37.z.string().optional(),
+  instance_id: import_zod37.z.string().optional(),
+  name: import_zod37.z.string(),
+  status: import_zod37.z.string(),
+  uptime: import_zod37.z.string().optional(),
+  exited_at: import_zod37.z.string().optional(),
+  boot_progress: import_zod37.z.string().optional(),
+  boot_error: import_zod37.z.string().optional(),
+  shutdown_progress: import_zod37.z.string().optional()
 });
 var GetCvmStateRequestSchema = CvmIdSchema;
 var { action: getCvmState, safeAction: safeGetCvmState } = defineAction(CvmStateSchema, async (client, request) => {
@@ -2056,6 +2731,14 @@ function createClient2(config = {}) {
     safeProvisionCvmComposeFileUpdate,
     commitCvmComposeFileUpdate,
     safeCommitCvmComposeFileUpdate,
+    updateCvmEnvs,
+    safeUpdateCvmEnvs,
+    updateDockerCompose,
+    safeUpdateDockerCompose,
+    updatePreLaunchScript,
+    safeUpdatePreLaunchScript,
+    getCvmPreLaunchScript,
+    safeGetCvmPreLaunchScript,
     startCvm,
     safeStartCvm,
     stopCvm,
@@ -2098,8 +2781,147 @@ function createClient2(config = {}) {
   return client.extend(allActions);
 }
 
+// src/types/app_info_v20251028.ts
+var import_zod38 = require("zod");
+var CvmBasicInfoV20251028Schema = import_zod38.z.object({
+  vm_uuid: import_zod38.z.string().nullable(),
+  app_id: import_zod38.z.string(),
+  name: import_zod38.z.string().default(""),
+  status: import_zod38.z.string(),
+  vcpu: import_zod38.z.number().int(),
+  memory: import_zod38.z.number().int(),
+  disk_size: import_zod38.z.number().int(),
+  teepod_id: import_zod38.z.number().int(),
+  teepod_name: import_zod38.z.string(),
+  region_identifier: import_zod38.z.string().nullable().optional(),
+  kms_type: import_zod38.z.string().nullable().optional(),
+  instance_type: import_zod38.z.string().nullable().optional(),
+  listed: import_zod38.z.boolean().nullable().optional(),
+  base_image: import_zod38.z.string().nullable().optional(),
+  kms_slug: import_zod38.z.string().nullable().optional(),
+  kms_id: import_zod38.z.string().nullable().optional(),
+  instance_id: import_zod38.z.string().nullable().optional(),
+  machine_info: MachineInfoV20251028Schema.nullable().optional(),
+  updated_at: import_zod38.z.string().nullable().optional()
+});
+var DstackAppFullResponseV20251028Schema = import_zod38.z.object({
+  id: import_zod38.z.string(),
+  name: import_zod38.z.string(),
+  app_id: import_zod38.z.string(),
+  app_provision_type: import_zod38.z.string().nullable().optional(),
+  app_icon_url: import_zod38.z.string().nullable().optional(),
+  created_at: import_zod38.z.string(),
+  kms_type: import_zod38.z.string(),
+  current_cvm: CvmBasicInfoV20251028Schema.nullable().optional(),
+  cvms: import_zod38.z.array(CvmBasicInfoV20251028Schema).default([]),
+  cvm_count: import_zod38.z.number().int().default(0)
+});
+var DstackAppMinimalResponseV20251028Schema = import_zod38.z.object({
+  id: import_zod38.z.null().optional(),
+  app_id: import_zod38.z.string(),
+  name: import_zod38.z.null().optional(),
+  app_provision_type: import_zod38.z.null().optional(),
+  app_icon_url: import_zod38.z.null().optional(),
+  created_at: import_zod38.z.null().optional(),
+  kms_type: import_zod38.z.null().optional(),
+  current_cvm: import_zod38.z.null().optional(),
+  cvms: import_zod38.z.null().optional(),
+  cvm_count: import_zod38.z.null().optional()
+});
+var DstackAppWithCvmResponseV20251028Schema = import_zod38.z.union([
+  DstackAppFullResponseV20251028Schema,
+  DstackAppMinimalResponseV20251028Schema
+]);
+var DstackAppListResponseV20251028Schema = import_zod38.z.object({
+  dstack_apps: import_zod38.z.array(DstackAppWithCvmResponseV20251028Schema),
+  page: import_zod38.z.number().int(),
+  page_size: import_zod38.z.number().int(),
+  total: import_zod38.z.number().int(),
+  total_pages: import_zod38.z.number().int()
+});
+
+// src/types/app_info_v20260121.ts
+var import_zod39 = require("zod");
+var DstackAppFullResponseV20260121Schema = import_zod39.z.object({
+  id: import_zod39.z.string(),
+  name: import_zod39.z.string(),
+  app_id: import_zod39.z.string(),
+  app_provision_type: import_zod39.z.string().nullable().optional(),
+  app_icon_url: import_zod39.z.string().nullable().optional(),
+  created_at: import_zod39.z.string(),
+  kms_type: import_zod39.z.string(),
+  current_cvm: CvmInfoV20260121Schema.nullable().optional(),
+  cvms: import_zod39.z.array(CvmInfoV20260121Schema).default([]),
+  cvm_count: import_zod39.z.number().int().default(0)
+});
+var DstackAppMinimalResponseV20260121Schema = import_zod39.z.object({
+  id: import_zod39.z.null().optional(),
+  app_id: import_zod39.z.string(),
+  name: import_zod39.z.null().optional(),
+  app_provision_type: import_zod39.z.null().optional(),
+  app_icon_url: import_zod39.z.null().optional(),
+  created_at: import_zod39.z.null().optional(),
+  kms_type: import_zod39.z.null().optional(),
+  current_cvm: import_zod39.z.null().optional(),
+  cvms: import_zod39.z.null().optional(),
+  cvm_count: import_zod39.z.null().optional()
+});
+var DstackAppWithCvmResponseV20260121Schema = import_zod39.z.union([
+  DstackAppFullResponseV20260121Schema,
+  DstackAppMinimalResponseV20260121Schema
+]);
+var DstackAppListResponseV20260121Schema = import_zod39.z.object({
+  dstack_apps: import_zod39.z.array(DstackAppWithCvmResponseV20260121Schema),
+  page: import_zod39.z.number().int(),
+  page_size: import_zod39.z.number().int(),
+  total: import_zod39.z.number().int(),
+  total_pages: import_zod39.z.number().int()
+});
+
+// src/types/app_revision.ts
+var import_zod40 = require("zod");
+var CvmRefSchema = import_zod40.z.object({
+  object_type: import_zod40.z.literal("cvm"),
+  id: import_zod40.z.string().nullable().optional(),
+  name: import_zod40.z.string().nullable().optional(),
+  app_id: import_zod40.z.string().nullable().optional(),
+  vm_uuid: import_zod40.z.string().nullable().optional()
+});
+var AppRevisionResponseSchema = import_zod40.z.object({
+  app_id: import_zod40.z.string(),
+  vm_uuid: import_zod40.z.string(),
+  compose_hash: import_zod40.z.string(),
+  created_at: import_zod40.z.string(),
+  trace_id: import_zod40.z.string().nullable().optional(),
+  operation_type: import_zod40.z.string(),
+  triggered_by: UserRefSchema.nullable().optional(),
+  cvm: CvmRefSchema.nullable().optional(),
+  workspace: WorkspaceRefSchema.nullable().optional()
+});
+var AppRevisionDetailResponseSchema = import_zod40.z.object({
+  app_id: import_zod40.z.string(),
+  vm_uuid: import_zod40.z.string(),
+  compose_hash: import_zod40.z.string(),
+  compose_file: import_zod40.z.union([import_zod40.z.record(import_zod40.z.any()), import_zod40.z.string()]).nullable().optional(),
+  encrypted_env: import_zod40.z.string(),
+  user_config: import_zod40.z.string(),
+  created_at: import_zod40.z.string(),
+  trace_id: import_zod40.z.string().nullable().optional(),
+  operation_type: import_zod40.z.string(),
+  triggered_by: UserRefSchema.nullable().optional(),
+  cvm: CvmRefSchema.nullable().optional(),
+  workspace: WorkspaceRefSchema.nullable().optional()
+});
+var AppRevisionsResponseSchema = import_zod40.z.object({
+  revisions: import_zod40.z.array(AppRevisionResponseSchema),
+  total: import_zod40.z.number().int(),
+  page: import_zod40.z.number().int(),
+  page_size: import_zod40.z.number().int(),
+  total_pages: import_zod40.z.number().int()
+});
+
 // src/actions/blockchains/deploy_app_auth.ts
-var import_zod31 = require("zod");
+var import_zod41 = require("zod");
 var import_viem3 = require("viem");
 var import_accounts2 = require("viem/accounts");
 
@@ -2749,25 +3571,25 @@ var kmsAuthAbi = [
     anonymous: false
   }
 ];
-var DeployAppAuthRequestBaseSchema = import_zod31.z.object({
+var DeployAppAuthRequestBaseSchema = import_zod41.z.object({
   // Chain configuration (conditionally required)
-  chain: import_zod31.z.unknown().optional(),
-  rpcUrl: import_zod31.z.string().optional(),
+  chain: import_zod41.z.unknown().optional(),
+  rpcUrl: import_zod41.z.string().optional(),
   // Contract configuration (required)
-  kmsContractAddress: import_zod31.z.string(),
+  kmsContractAddress: import_zod41.z.string(),
   // Authentication mode: either privateKey OR walletClient (required, mutually exclusive)
-  privateKey: import_zod31.z.string().optional(),
-  walletClient: import_zod31.z.unknown().optional(),
+  privateKey: import_zod41.z.string().optional(),
+  walletClient: import_zod41.z.unknown().optional(),
   // Public client (optional, will create default if not provided)
-  publicClient: import_zod31.z.unknown().optional(),
+  publicClient: import_zod41.z.unknown().optional(),
   // App configuration (optional)
-  allowAnyDevice: import_zod31.z.boolean().optional().default(false),
-  deviceId: import_zod31.z.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
-  composeHash: import_zod31.z.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
-  disableUpgrades: import_zod31.z.boolean().optional().default(false),
+  allowAnyDevice: import_zod41.z.boolean().optional().default(false),
+  deviceId: import_zod41.z.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
+  composeHash: import_zod41.z.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
+  disableUpgrades: import_zod41.z.boolean().optional().default(false),
   // Validation configuration (optional)
-  skipPrerequisiteChecks: import_zod31.z.boolean().optional().default(false),
-  minBalance: import_zod31.z.string().optional()
+  skipPrerequisiteChecks: import_zod41.z.boolean().optional().default(false),
+  minBalance: import_zod41.z.string().optional()
   // ETH amount as string, e.g., "0.01"
 }).passthrough();
 var DeployAppAuthRequestSchema = DeployAppAuthRequestBaseSchema.refine(
@@ -2795,13 +3617,13 @@ var DeployAppAuthRequestSchema = DeployAppAuthRequestBaseSchema.refine(
     path: ["chain"]
   }
 );
-var DeployAppAuthSchema = import_zod31.z.object({
-  appId: import_zod31.z.string(),
-  appAuthAddress: import_zod31.z.string(),
-  deployer: import_zod31.z.string(),
-  transactionHash: import_zod31.z.string(),
-  blockNumber: import_zod31.z.bigint().optional(),
-  gasUsed: import_zod31.z.bigint().optional()
+var DeployAppAuthSchema = import_zod41.z.object({
+  appId: import_zod41.z.string(),
+  appAuthAddress: import_zod41.z.string(),
+  deployer: import_zod41.z.string(),
+  transactionHash: import_zod41.z.string(),
+  blockNumber: import_zod41.z.bigint().optional(),
+  gasUsed: import_zod41.z.bigint().optional()
 }).passthrough();
 function parseDeploymentResult(receipt, deployer, kmsContractAddress) {
   try {
@@ -3047,7 +3869,7 @@ async function safeDeployAppAuth(request, parameters) {
 }
 
 // src/actions/blockchains/add_compose_hash.ts
-var import_zod32 = require("zod");
+var import_zod42 = require("zod");
 var import_viem4 = require("viem");
 var import_accounts3 = require("viem/accounts");
 var appAuthAbi = [
@@ -3065,29 +3887,29 @@ var appAuthAbi = [
     anonymous: false
   }
 ];
-var AddComposeHashRequestSchema = import_zod32.z.object({
+var AddComposeHashRequestSchema = import_zod42.z.object({
   // Chain configuration (conditionally required)
-  chain: import_zod32.z.unknown().optional(),
-  rpcUrl: import_zod32.z.string().optional(),
-  appId: import_zod32.z.string(),
-  composeHash: import_zod32.z.string(),
+  chain: import_zod42.z.unknown().optional(),
+  rpcUrl: import_zod42.z.string().optional(),
+  appId: import_zod42.z.string(),
+  composeHash: import_zod42.z.string(),
   // Authentication mode: either privateKey OR walletClient (required, mutually exclusive)
-  privateKey: import_zod32.z.string().optional(),
-  walletClient: import_zod32.z.unknown().optional(),
+  privateKey: import_zod42.z.string().optional(),
+  walletClient: import_zod42.z.unknown().optional(),
   // Public client (optional, will create default if not provided)
-  publicClient: import_zod32.z.unknown().optional(),
+  publicClient: import_zod42.z.unknown().optional(),
   // Validation configuration (optional)
-  skipPrerequisiteChecks: import_zod32.z.boolean().optional().default(false),
-  minBalance: import_zod32.z.string().optional(),
+  skipPrerequisiteChecks: import_zod42.z.boolean().optional().default(false),
+  minBalance: import_zod42.z.string().optional(),
   // ETH amount as string, e.g., "0.01"
   // Transaction control options
-  timeout: import_zod32.z.number().optional().default(12e4),
-  retryOptions: import_zod32.z.unknown().optional(),
-  signal: import_zod32.z.unknown().optional(),
+  timeout: import_zod42.z.number().optional().default(12e4),
+  retryOptions: import_zod42.z.unknown().optional(),
+  signal: import_zod42.z.unknown().optional(),
   // Progress callbacks
-  onTransactionStateChange: import_zod32.z.function().optional(),
-  onTransactionSubmitted: import_zod32.z.function().optional(),
-  onTransactionConfirmed: import_zod32.z.function().optional()
+  onTransactionStateChange: import_zod42.z.function().optional(),
+  onTransactionSubmitted: import_zod42.z.function().optional(),
+  onTransactionConfirmed: import_zod42.z.function().optional()
 }).passthrough().refine(
   (data) => {
     const hasPrivateKey = !!data.privateKey;
@@ -3111,12 +3933,12 @@ var AddComposeHashRequestSchema = import_zod32.z.object({
     path: ["chain"]
   }
 );
-var AddComposeHashSchema = import_zod32.z.object({
-  composeHash: import_zod32.z.string(),
-  appId: import_zod32.z.string(),
-  transactionHash: import_zod32.z.string(),
-  blockNumber: import_zod32.z.bigint().optional(),
-  gasUsed: import_zod32.z.bigint().optional()
+var AddComposeHashSchema = import_zod42.z.object({
+  composeHash: import_zod42.z.string(),
+  appId: import_zod42.z.string(),
+  transactionHash: import_zod42.z.string(),
+  blockNumber: import_zod42.z.bigint().optional(),
+  gasUsed: import_zod42.z.bigint().optional()
 }).passthrough();
 function parseComposeHashResult(receipt, composeHash, appAuthAddress, appId) {
   console.log(receipt.logs);
@@ -3307,14 +4129,70 @@ async function safeAddComposeHash(request, parameters) {
   }
 }
 
+// src/actions/workspaces/get_workspace_nodes.ts
+var import_zod43 = require("zod");
+var NodeInfoSchema = import_zod43.z.object({
+  id: import_zod43.z.number().nullable(),
+  name: import_zod43.z.string().nullable(),
+  region: import_zod43.z.string().nullable(),
+  device_id: import_zod43.z.string().nullable(),
+  ppid: import_zod43.z.string().nullable(),
+  status: import_zod43.z.string().nullable(),
+  version: import_zod43.z.string().nullable()
+}).passthrough();
+var GetWorkspaceNodesSchema = import_zod43.z.object({
+  items: import_zod43.z.array(NodeInfoSchema),
+  total: import_zod43.z.number(),
+  page: import_zod43.z.number(),
+  page_size: import_zod43.z.number(),
+  pages: import_zod43.z.number()
+}).passthrough();
+var { action: getWorkspaceNodes, safeAction: safeGetWorkspaceNodes } = defineAction(GetWorkspaceNodesSchema, async (client, request) => {
+  const { teamSlug, page, pageSize } = request;
+  const queryParams = new URLSearchParams();
+  if (page !== void 0) queryParams.append("page", page.toString());
+  if (pageSize !== void 0) queryParams.append("page_size", pageSize.toString());
+  const url = queryParams.toString() ? `/workspaces/${teamSlug}/nodes?${queryParams.toString()}` : `/workspaces/${teamSlug}/nodes`;
+  return await client.get(url);
+});
+
+// src/actions/workspaces/get_workspace_quotas.ts
+var import_zod44 = require("zod");
+var QuotaMetricSchema = import_zod44.z.object({
+  limit: import_zod44.z.number(),
+  remaining: import_zod44.z.number()
+}).passthrough();
+var WorkspaceQuotasSchema = import_zod44.z.object({
+  vm_slots: QuotaMetricSchema,
+  vcpu: QuotaMetricSchema,
+  memory_mb: QuotaMetricSchema,
+  disk_gb: QuotaMetricSchema
+}).passthrough();
+var WorkspaceReservedGpuQuotaSchema = import_zod44.z.object({
+  gpus: QuotaMetricSchema,
+  in_use: import_zod44.z.number(),
+  misconfigured: import_zod44.z.number()
+}).passthrough();
+var GetWorkspaceQuotasSchema = import_zod44.z.object({
+  team_slug: import_zod44.z.string(),
+  tier: import_zod44.z.string(),
+  quotas: WorkspaceQuotasSchema,
+  reserved_nodes: QuotaMetricSchema,
+  reserved_gpu: WorkspaceReservedGpuQuotaSchema,
+  as_of: import_zod44.z.string()
+}).passthrough();
+var { action: getWorkspaceQuotas, safeAction: safeGetWorkspaceQuotas } = defineAction(GetWorkspaceQuotasSchema, async (client, request) => {
+  return await client.get(`/workspaces/${request.teamSlug}/quotas`);
+});
+
 // src/actions/cvms/watch_cvm_state.ts
-var import_zod33 = require("zod");
-var WatchCvmStateParamsSchema = import_zod33.z.object({
-  target: import_zod33.z.string().describe("Target status to wait for (e.g., 'running', 'stopped')"),
-  interval: import_zod33.z.number().min(5).max(30).default(5).describe("Polling interval in seconds"),
-  timeout: import_zod33.z.number().min(10).max(600).default(300).describe("Timeout per attempt in seconds"),
-  maxRetries: import_zod33.z.number().min(0).default(Number.POSITIVE_INFINITY).describe("Maximum number of retry attempts (Infinity for unlimited)"),
-  retryDelay: import_zod33.z.number().min(0).default(5e3).describe("Delay between retries in milliseconds")
+var import_zod45 = require("zod");
+var WatchCvmStateParamsSchema = import_zod45.z.object({
+  target: import_zod45.z.string().describe("Target status to wait for (e.g., 'running', 'stopped')"),
+  interval: import_zod45.z.number().min(5).max(30).default(5).describe("Polling interval in seconds"),
+  timeout: import_zod45.z.number().min(10).max(600).default(300).describe("Timeout per attempt in seconds"),
+  maxRetries: import_zod45.z.number().min(0).default(Number.POSITIVE_INFINITY).describe("Maximum number of retry attempts (Infinity for unlimited)"),
+  retryDelay: import_zod45.z.number().min(0).default(5e3).describe("Delay between retries in milliseconds")
 });
 var WatchCvmStateRequestSchema = WatchCvmStateParamsSchema;
 var WatchAbortedError = class extends Error {
@@ -3501,6 +4379,195 @@ function sleep(ms, signal) {
   });
 }
 
+// src/actions/cvms/get_cvm_status_batch.ts
+var import_zod46 = require("zod");
+var CvmStatusSchema = import_zod46.z.object({
+  vm_uuid: import_zod46.z.string(),
+  status: import_zod46.z.string(),
+  uptime: import_zod46.z.string().nullable().optional(),
+  in_progress: import_zod46.z.boolean(),
+  boot_progress: import_zod46.z.string().nullable().optional(),
+  boot_error: import_zod46.z.string().nullable().optional(),
+  operation_type: import_zod46.z.string().nullable().optional(),
+  operation_started_at: import_zod46.z.string().nullable().optional(),
+  correlation_id: import_zod46.z.string().nullable().optional()
+});
+var GetCvmStatusBatchResponseSchema = import_zod46.z.record(import_zod46.z.string(), CvmStatusSchema);
+var GetCvmStatusBatchRequestSchema = import_zod46.z.object({
+  vmUuids: import_zod46.z.array(import_zod46.z.string())
+});
+var { action: getCvmStatusBatch, safeAction: safeGetCvmStatusBatch } = defineAction(GetCvmStatusBatchResponseSchema, async (client, request) => {
+  const { vmUuids } = GetCvmStatusBatchRequestSchema.parse(request);
+  return await client.post("/status/batch", { vm_uuids: vmUuids });
+});
+
+// src/actions/apps/get_app_list.ts
+var import_zod47 = require("zod");
+var GetAppListRequestSchema = import_zod47.z.object({
+  page: import_zod47.z.number().int().min(1).optional(),
+  page_size: import_zod47.z.number().int().min(1).max(100).optional(),
+  search: import_zod47.z.string().optional(),
+  status: import_zod47.z.array(import_zod47.z.string()).optional(),
+  listed: import_zod47.z.boolean().optional(),
+  base_image: import_zod47.z.string().optional(),
+  instance_type: import_zod47.z.string().optional(),
+  kms_slug: import_zod47.z.string().optional(),
+  kms_type: import_zod47.z.string().optional(),
+  teepod_name: import_zod47.z.string().optional(),
+  region: import_zod47.z.string().optional()
+}).strict();
+function getSchemaForVersion4(version) {
+  return version === "2025-10-28" ? DstackAppListResponseV20251028Schema : DstackAppListResponseV20260121Schema;
+}
+async function getAppList(client, request) {
+  const validatedRequest = GetAppListRequestSchema.parse(request ?? {});
+  const response = await client.get("/apps", { params: validatedRequest });
+  const schema = getSchemaForVersion4(client.config.version);
+  return schema.parse(response);
+}
+async function safeGetAppList(client, request) {
+  try {
+    const data = await getAppList(client, request);
+    return { success: true, data };
+  } catch (error) {
+    if (error && typeof error === "object" && ("status" in error || "issues" in error)) {
+      return { success: false, error };
+    }
+    return {
+      success: false,
+      error: {
+        name: "Error",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
+
+// src/actions/apps/get_app_info.ts
+var import_zod48 = require("zod");
+var GetAppInfoRequestSchema = import_zod48.z.object({
+  appId: import_zod48.z.string().min(1)
+}).strict();
+function getSchemaForVersion5(version) {
+  return version === "2025-10-28" ? DstackAppWithCvmResponseV20251028Schema : DstackAppWithCvmResponseV20260121Schema;
+}
+async function getAppInfo(client, request) {
+  const { appId } = GetAppInfoRequestSchema.parse(request);
+  const response = await client.get(`/apps/${appId}`);
+  const schema = getSchemaForVersion5(client.config.version);
+  return schema.parse(response);
+}
+async function safeGetAppInfo(client, request) {
+  try {
+    const data = await getAppInfo(client, request);
+    return { success: true, data };
+  } catch (error) {
+    if (error && typeof error === "object" && ("status" in error || "issues" in error)) {
+      return { success: false, error };
+    }
+    return {
+      success: false,
+      error: {
+        name: "Error",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
+
+// src/actions/apps/get_app_cvms.ts
+var import_zod49 = require("zod");
+var GetAppCvmsRequestSchema = import_zod49.z.object({
+  appId: import_zod49.z.string().min(1)
+}).strict();
+function getSchemaForVersion6(version) {
+  return version === "2025-10-28" ? import_zod49.z.array(CvmInfoV20251028Schema) : import_zod49.z.array(CvmInfoV20260121Schema);
+}
+async function getAppCvms(client, request) {
+  const { appId } = GetAppCvmsRequestSchema.parse(request);
+  const response = await client.get(`/apps/${appId}/cvms`);
+  const schema = getSchemaForVersion6(client.config.version);
+  return schema.parse(response);
+}
+async function safeGetAppCvms(client, request) {
+  try {
+    const data = await getAppCvms(client, request);
+    return { success: true, data };
+  } catch (error) {
+    if (error && typeof error === "object" && ("status" in error || "issues" in error)) {
+      return { success: false, error };
+    }
+    return {
+      success: false,
+      error: {
+        name: "Error",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
+
+// src/actions/apps/get_app_revisions.ts
+var import_zod50 = require("zod");
+var GetAppRevisionsRequestSchema = import_zod50.z.object({
+  appId: import_zod50.z.string().min(1),
+  page: import_zod50.z.number().int().min(1).optional(),
+  page_size: import_zod50.z.number().int().min(1).max(1e3).optional()
+}).strict();
+async function getAppRevisions(client, request) {
+  const { appId, ...params } = GetAppRevisionsRequestSchema.parse(request);
+  const response = await client.get(`/apps/${appId}/revisions`, { params });
+  return AppRevisionsResponseSchema.parse(response);
+}
+async function safeGetAppRevisions(client, request) {
+  try {
+    const data = await getAppRevisions(client, request);
+    return { success: true, data };
+  } catch (error) {
+    if (error && typeof error === "object" && ("status" in error || "issues" in error)) {
+      return { success: false, error };
+    }
+    return {
+      success: false,
+      error: {
+        name: "Error",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
+
+// src/actions/apps/get_app_revision_detail.ts
+var import_zod51 = require("zod");
+var GetAppRevisionDetailRequestSchema = import_zod51.z.object({
+  appId: import_zod51.z.string().min(1),
+  composeHash: import_zod51.z.string().min(1),
+  rawComposeFile: import_zod51.z.boolean().optional()
+}).strict();
+async function getAppRevisionDetail(client, request) {
+  const { appId, composeHash, rawComposeFile } = GetAppRevisionDetailRequestSchema.parse(request);
+  const params = rawComposeFile !== void 0 ? { raw_compose_file: rawComposeFile } : void 0;
+  const response = await client.get(`/apps/${appId}/revisions/${composeHash}`, { params });
+  return AppRevisionDetailResponseSchema.parse(response);
+}
+async function safeGetAppRevisionDetail(client, request) {
+  try {
+    const data = await getAppRevisionDetail(client, request);
+    return { success: true, data };
+  } catch (error) {
+    if (error && typeof error === "object" && ("status" in error || "issues" in error)) {
+      return { success: false, error };
+    }
+    return {
+      success: false,
+      error: {
+        name: "Error",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
+
 // src/parse_dotenv.ts
 var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
 function parseEnv(input) {
@@ -3541,33 +4608,65 @@ var import_verify_env_encrypt_public_key = require("@phala/dstack-sdk/verify-env
   AddComposeHashSchema,
   AllFamiliesResponseSchema,
   ApiErrorSchema,
+  AppRevisionDetailResponseSchema,
+  AppRevisionResponseSchema,
+  AppRevisionsResponseSchema,
   AuthError,
+  AuthResponseSchema,
   AvailableNodesSchema,
+  BillingPeriodSchema,
   BusinessError,
   CommitCvmComposeFileUpdateRequestSchema,
   CommitCvmComposeFileUpdateSchema,
   CommitCvmProvisionRequestSchema,
   CommitCvmProvisionSchema,
+  CreditsInfoSchema,
   CurrentUserSchema,
+  CurrentUserV20251028Schema,
+  CurrentUserV20260121Schema,
   CvmAttestationSchema,
+  CvmBasicInfoV20251028Schema,
   CvmContainersStatsSchema,
+  CvmDetailV20251028Schema,
+  CvmGatewayInfoV20260121Schema,
   CvmIdBaseSchema,
   CvmIdObjectSchema,
   CvmIdSchema,
-  CvmInfoSchema,
-  CvmLegacyDetailSchema,
+  CvmInfoDetailV20260121Schema,
+  CvmInfoV20251028Schema,
+  CvmInfoV20260121Schema,
+  CvmKmsInfoV20260121Schema,
   CvmNetworkSchema,
-  CvmNetworkUrlsSchema,
-  CvmNodeSchema,
+  CvmNetworkUrlsV20251028Schema,
+  CvmNodeInfoV20260121Schema,
+  CvmNodeV20251028Schema,
+  CvmOsInfoV20260121Schema,
+  CvmProgressInfoV20260121Schema,
+  CvmRefSchema,
+  CvmResourceInfoV20260121Schema,
   CvmStateSchema,
+  CvmStatusSchema,
   CvmSystemInfoSchema,
   DeleteCvmRequestSchema,
   DeployAppAuthRequestSchema,
   DeployAppAuthSchema,
+  DstackAppFullResponseV20251028Schema,
+  DstackAppFullResponseV20260121Schema,
+  DstackAppListResponseV20251028Schema,
+  DstackAppListResponseV20260121Schema,
+  DstackAppMinimalResponseV20251028Schema,
+  DstackAppMinimalResponseV20260121Schema,
+  DstackAppWithCvmResponseV20251028Schema,
+  DstackAppWithCvmResponseV20260121Schema,
   FamilyGroupSchema,
   FamilyInstanceTypesResponseSchema,
+  GetAppCvmsRequestSchema,
   GetAppEnvEncryptPubKeyRequestSchema,
   GetAppEnvEncryptPubKeySchema,
+  GetAppInfoRequestSchema,
+  GetAppListRequestSchema,
+  GetAppRevisionDetailRequestSchema,
+  GetAppRevisionsRequestSchema,
   GetAvailableOSImagesRequestSchema,
   GetAvailableOSImagesResponseSchema,
   GetCvmAttestationRequestSchema,
@@ -3576,29 +4675,39 @@ var import_verify_env_encrypt_public_key = require("@phala/dstack-sdk/verify-env
   GetCvmDockerComposeRequestSchema,
   GetCvmInfoRequestSchema,
   GetCvmListRequestSchema,
-  GetCvmListSchema,
   GetCvmNetworkRequestSchema,
+  GetCvmPreLaunchScriptRequestSchema,
   GetCvmStateRequestSchema,
   GetCvmStatsRequestSchema,
+  GetCvmStatusBatchRequestSchema,
+  GetCvmStatusBatchResponseSchema,
   GetKmsInfoRequestSchema,
   GetKmsListRequestSchema,
   GetKmsListSchema,
+  GetWorkspaceNodesSchema,
+  GetWorkspaceQuotasSchema,
   InstanceTypeSchema,
   KmsInfoSchema,
+  KmsTypeSchema,
   ListFamilyInstanceTypesRequestSchema,
   ListWorkspacesSchema,
-  ManagedUserSchema,
+  MachineInfoV20251028Schema,
+  ManagedUserV20251028Schema,
   MaxRetriesExceededError,
   NetworkError,
   NextAppIdsRequestSchema,
   NextAppIdsSchema,
+  NodeInfoSchema,
   OSImageVariantSchema,
+  PaginatedCvmInfosV20251028Schema,
+  PaginatedCvmInfosV20260121Schema,
   PaginationMetadataSchema,
   PhalaCloudError,
   ProvisionCvmComposeFileUpdateRequestSchema,
   ProvisionCvmComposeFileUpdateResultSchema,
   ProvisionCvmRequestSchema,
   ProvisionCvmSchema,
+  QuotaMetricSchema,
   RequestError,
   ResourceError,
   RestartCvmRequestSchema,
@@ -3610,15 +4719,27 @@ var import_verify_env_encrypt_public_key = require("@phala/dstack-sdk/verify-env
   StopCvmRequestSchema,
   TransactionError,
   UnknownError,
+  UpdateCvmEnvsRequestSchema,
+  UpdateCvmEnvsResultSchema,
   UpdateCvmResourcesRequestSchema,
   UpdateCvmVisibilityRequestSchema,
+  UpdateDockerComposeRequestSchema,
+  UpdateDockerComposeResultSchema,
   UpdateOsImageRequestSchema,
+  UpdatePreLaunchScriptRequestSchema,
+  UpdatePreLaunchScriptResultSchema,
+  UserInfoSchema,
+  UserRefSchema,
   VMSchema,
   ValidationError,
-  VmInfoSchema,
+  VmInfoV20251028Schema,
   WalletError,
   WatchAbortedError,
   WatchCvmStateRequestSchema,
+  WorkspaceInfoSchema,
+  WorkspaceQuotasSchema,
+  WorkspaceRefSchema,
+  WorkspaceReservedGpuQuotaSchema,
   WorkspaceResponseSchema,
   addComposeHash,
   addNetwork,
@@ -3628,6 +4749,7 @@ var import_verify_env_encrypt_public_key = require("@phala/dstack-sdk/verify-env
   checkNetworkStatus,
   commitCvmComposeFileUpdate,
   commitCvmProvision,
+  convertToHostname,
   createBaseClient,
   createClient,
   createClientsFromBrowser,
@@ -3648,7 +4770,14 @@ var import_verify_env_encrypt_public_key = require("@phala/dstack-sdk/verify-env
   formatErrorMessage,
   formatStructuredError,
   formatValidationErrors,
+  generateDefaultCvmName,
+  generateFallbackHostname,
+  getAppCvms,
   getAppEnvEncryptPubKey,
+  getAppInfo,
+  getAppList,
+  getAppRevisionDetail,
+  getAppRevisions,
   getAvailableNodes,
   getAvailableOsImages,
   getComposeHash,
@@ -3660,13 +4789,18 @@ var import_verify_env_encrypt_public_key = require("@phala/dstack-sdk/verify-env
   getCvmInfo,
   getCvmList,
   getCvmNetwork,
+  getCvmPreLaunchScript,
   getCvmState,
   getCvmStats,
+  getCvmStatusBatch,
   getErrorMessage,
   getKmsInfo,
   getKmsList,
   getValidationFields,
   getWorkspace,
+  getWorkspaceNodes,
+  getWorkspaceQuotas,
+  isValidHostname,
   listAllInstanceTypeFamilies,
   listFamilyInstanceTypes,
   listWorkspaces,
@@ -3684,7 +4818,12 @@ var import_verify_env_encrypt_public_key = require("@phala/dstack-sdk/verify-env
   safeCommitCvmProvision,
   safeDeleteCvm,
   safeDeployAppAuth,
+  safeGetAppCvms,
   safeGetAppEnvEncryptPubKey,
+  safeGetAppInfo,
+  safeGetAppList,
+  safeGetAppRevisionDetail,
+  safeGetAppRevisions,
   safeGetAvailableNodes,
   safeGetAvailableOsImages,
   safeGetCurrentUser,
@@ -3695,11 +4834,15 @@ var import_verify_env_encrypt_public_key = require("@phala/dstack-sdk/verify-env
   safeGetCvmInfo,
   safeGetCvmList,
   safeGetCvmNetwork,
+  safeGetCvmPreLaunchScript,
   safeGetCvmState,
   safeGetCvmStats,
+  safeGetCvmStatusBatch,
   safeGetKmsInfo,
   safeGetKmsList,
   safeGetWorkspace,
+  safeGetWorkspaceNodes,
+  safeGetWorkspaceQuotas,
   safeListAllInstanceTypeFamilies,
   safeListFamilyInstanceTypes,
   safeListWorkspaces,
@@ -3710,18 +4853,24 @@ var import_verify_env_encrypt_public_key = require("@phala/dstack-sdk/verify-env
   safeShutdownCvm,
   safeStartCvm,
   safeStopCvm,
+  safeUpdateCvmEnvs,
   safeUpdateCvmResources,
   safeUpdateCvmVisibility,
+  safeUpdateDockerCompose,
   safeUpdateOsImage,
+  safeUpdatePreLaunchScript,
   safeValidateActionParameters,
   shutdownCvm,
   sortObject,
   startCvm,
   stopCvm,
   switchToNetwork,
+  updateCvmEnvs,
   updateCvmResources,
   updateCvmVisibility,
+  updateDockerCompose,
   updateOsImage,
+  updatePreLaunchScript,
   validateActionParameters,
   validateNetworkPrerequisites,
   verifyEnvEncryptPublicKey,