@phala/cloud 0.0.12 → 0.1.1-beta.1

package/dist/index.js

@@ -44,11 +44,18 @@ __export(index_exports, {
   CvmNodeSchema: () => CvmNodeSchema,
   DeployAppAuthRequestSchema: () => DeployAppAuthRequestSchema,
   DeployAppAuthSchema: () => DeployAppAuthSchema,
+  GetAppEnvEncryptPubKeyRequestSchema: () => GetAppEnvEncryptPubKeyRequestSchema,
   GetAppEnvEncryptPubKeySchema: () => GetAppEnvEncryptPubKeySchema,
+  GetCvmComposeFileRequestSchema: () => GetCvmComposeFileRequestSchema,
+  GetCvmInfoRequestSchema: () => GetCvmInfoRequestSchema,
+  GetCvmListRequestSchema: () => GetCvmListRequestSchema,
   GetCvmListSchema: () => GetCvmListSchema,
+  GetKmsInfoRequestSchema: () => GetKmsInfoRequestSchema,
+  GetKmsListRequestSchema: () => GetKmsListRequestSchema,
   GetKmsListSchema: () => GetKmsListSchema,
   InstanceTypeSchema: () => InstanceTypeSchema,
   KmsInfoSchema: () => KmsInfoSchema,
+  ListInstanceTypesRequestSchema: () => ListInstanceTypesRequestSchema,
   ListWorkspacesSchema: () => ListWorkspacesSchema,
   ManagedUserSchema: () => ManagedUserSchema,
   NetworkError: () => NetworkError,
@@ -77,6 +84,8 @@ __export(index_exports, {
   createClientsFromPrivateKey: () => createClientsFromPrivateKey,
   createNetworkClients: () => createNetworkClients,
   createTransactionTracker: () => createTransactionTracker,
+  defineAction: () => defineAction,
+  defineSimpleAction: () => defineSimpleAction,
   deployAppAuth: () => deployAppAuth,
   encryptEnvVars: () => import_encrypt_env_vars2.encryptEnvVars,
   estimateTransactionGas: () => estimateTransactionGas,
@@ -423,6 +432,28 @@ var Client = class {
   async safeDelete(request, options) {
     return this.safeRequest(() => this.delete(request, options));
   }
+  /**
+   * Extend client with additional actions
+   *
+   * @example
+   * ```typescript
+   * const client = createClient({ apiKey: 'xxx' })
+   *   .extend(publicActions)
+   *   .extend(cvmActions)
+   *
+   * await client.getCurrentUser() // Method call instead of function call
+   * ```
+   */
+  extend(actions) {
+    const actionsObj = typeof actions === "function" ? actions(this) : actions;
+    const extended = Object.create(this);
+    for (const [key, action] of Object.entries(actionsObj)) {
+      if (typeof action === "function") {
+        extended[key] = (...args) => action(this, ...args);
+      }
+    }
+    return extended;
+  }
 };
 function createClient(config = {}) {
   return new Client(config);
@@ -545,6 +576,357 @@ var CvmLegacyDetailSchema = import_zod3.z.object({
 // src/actions/get_current_user.ts
 var import_zod4 = require("zod");
 
+// src/utils/validate-parameters.ts
+function validateActionParameters(parameters) {
+  if (parameters?.schema !== void 0 && parameters?.schema !== false) {
+    if (typeof parameters.schema !== "object" || parameters.schema === null || !("parse" in parameters.schema) || typeof parameters.schema.parse !== "function") {
+      throw new Error("Invalid schema: must be a Zod schema object, false, or undefined");
+    }
+  }
+}
+function safeValidateActionParameters(parameters) {
+  if (parameters?.schema !== void 0 && parameters?.schema !== false) {
+    if (typeof parameters.schema !== "object" || parameters.schema === null || !("parse" in parameters.schema) || typeof parameters.schema.parse !== "function") {
+      return {
+        success: false,
+        error: {
+          name: "ZodError",
+          message: "Invalid schema: must be a Zod schema object, false, or undefined",
+          issues: [
+            {
+              code: "invalid_type",
+              expected: "object",
+              received: typeof parameters.schema,
+              path: ["schema"],
+              message: "Invalid schema: must be a Zod schema object, false, or undefined"
+            }
+          ]
+        }
+      };
+    }
+  }
+  return void 0;
+}
+
+// src/utils/define-action.ts
+function defineSimpleAction(schema, fn) {
+  function action(client, parameters) {
+    return _actionImpl(client, parameters);
+  }
+  async function _actionImpl(client, parameters) {
+    validateActionParameters(parameters);
+    const response = await fn(client);
+    if (parameters?.schema === false) {
+      return response;
+    }
+    const actualSchema = parameters?.schema || schema;
+    return actualSchema.parse(response);
+  }
+  function safeAction(client, parameters) {
+    return _safeActionImpl(client, parameters);
+  }
+  async function _safeActionImpl(client, parameters) {
+    const parameterValidationError = safeValidateActionParameters(parameters);
+    if (parameterValidationError) {
+      return parameterValidationError;
+    }
+    const httpResult = await (async () => {
+      try {
+        const data = await fn(client);
+        return { success: true, data };
+      } catch (error) {
+        if (error && typeof error === "object" && "isRequestError" in error) {
+          return { success: false, error };
+        }
+        if (error && typeof error === "object" && "issues" in error) {
+          return { success: false, error };
+        }
+        return {
+          success: false,
+          error: {
+            name: "Error",
+            message: error instanceof Error ? error.message : String(error)
+          }
+        };
+      }
+    })();
+    if (!httpResult.success) {
+      return httpResult;
+    }
+    if (parameters?.schema === false) {
+      return { success: true, data: httpResult.data };
+    }
+    const actualSchema = parameters?.schema || schema;
+    return actualSchema.safeParse(httpResult.data);
+  }
+  return {
+    action,
+    safeAction
+  };
+}
+function defineAction(schema, fn) {
+  function action(client, ...args) {
+    const [params, parameters] = args;
+    return _actionImpl(client, params, parameters);
+  }
+  async function _actionImpl(client, params, parameters) {
+    validateActionParameters(parameters);
+    const response = await fn(client, params);
+    if (parameters?.schema === false) {
+      return response;
+    }
+    const actualSchema = parameters?.schema || schema;
+    return actualSchema.parse(response);
+  }
+  function safeAction(client, ...args) {
+    const [params, parameters] = args;
+    return _safeActionImpl(client, params, parameters);
+  }
+  async function _safeActionImpl(client, params, parameters) {
+    const parameterValidationError = safeValidateActionParameters(parameters);
+    if (parameterValidationError) {
+      return parameterValidationError;
+    }
+    const httpResult = await (async () => {
+      try {
+        const data = await fn(client, params);
+        return { success: true, data };
+      } catch (error) {
+        if (error && typeof error === "object" && "isRequestError" in error) {
+          return { success: false, error };
+        }
+        if (error && typeof error === "object" && "issues" in error) {
+          return { success: false, error };
+        }
+        return {
+          success: false,
+          error: {
+            name: "Error",
+            message: error instanceof Error ? error.message : String(error)
+          }
+        };
+      }
+    })();
+    if (!httpResult.success) {
+      return httpResult;
+    }
+    if (parameters?.schema === false) {
+      return { success: true, data: httpResult.data };
+    }
+    const actualSchema = parameters?.schema || schema;
+    return actualSchema.safeParse(httpResult.data);
+  }
+  return {
+    action,
+    safeAction
+  };
+}
+
+// src/actions/get_current_user.ts
+var CurrentUserSchema = import_zod4.z.object({
+  username: import_zod4.z.string(),
+  email: import_zod4.z.string(),
+  credits: import_zod4.z.number(),
+  granted_credits: import_zod4.z.number(),
+  avatar: import_zod4.z.string(),
+  team_name: import_zod4.z.string(),
+  team_tier: import_zod4.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_zod5 = require("zod");
+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_zod5.z.string().nullable().optional()
+}).passthrough();
+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_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_zod5.z.object({
+  tier: import_zod5.z.string(),
+  // TeamTier is string enum
+  capacity: ResourceThresholdSchema,
+  nodes: import_zod5.z.array(TeepodCapacitySchema),
+  kms_list: import_zod5.z.array(KmsInfoSchema)
+}).passthrough();
+var { action: getAvailableNodes, safeAction: safeGetAvailableNodes } = defineSimpleAction(
+  AvailableNodesSchema,
+  async (client) => {
+    return await client.get("/teepods/available");
+  }
+);
+
+// src/actions/cvms/provision_cvm.ts
+var import_zod6 = require("zod");
+var ProvisionCvmSchema = import_zod6.z.object({
+  app_id: import_zod6.z.string().nullable().optional(),
+  app_env_encrypt_pubkey: import_zod6.z.string().nullable().optional(),
+  compose_hash: import_zod6.z.string(),
+  fmspc: import_zod6.z.string().nullable().optional(),
+  device_id: import_zod6.z.string().nullable().optional(),
+  os_image_hash: import_zod6.z.string().nullable().optional(),
+  teepod_id: import_zod6.z.number().nullable().optional(),
+  // Will be transformed to node_id
+  node_id: import_zod6.z.number().nullable().optional(),
+  kms_id: import_zod6.z.string().nullable().optional()
+}).passthrough().transform((data) => {
+  if ("teepod_id" in data && data.teepod_id !== void 0) {
+    const { teepod_id, ...rest } = data;
+    return { ...rest, node_id: teepod_id };
+  }
+  return data;
+});
+var ProvisionCvmRequestSchema = import_zod6.z.object({
+  node_id: import_zod6.z.number().optional(),
+  // recommended
+  teepod_id: import_zod6.z.number().optional(),
+  // deprecated, for compatibility
+  name: import_zod6.z.string(),
+  image: import_zod6.z.string(),
+  vcpu: import_zod6.z.number(),
+  memory: import_zod6.z.number(),
+  disk_size: import_zod6.z.number(),
+  compose_file: import_zod6.z.object({
+    allowed_envs: import_zod6.z.array(import_zod6.z.string()).optional(),
+    pre_launch_script: import_zod6.z.string().optional(),
+    docker_compose_file: import_zod6.z.string().optional(),
+    name: import_zod6.z.string().optional(),
+    kms_enabled: import_zod6.z.boolean().optional(),
+    public_logs: import_zod6.z.boolean().optional(),
+    public_sysinfo: import_zod6.z.boolean().optional(),
+    gateway_enabled: import_zod6.z.boolean().optional(),
+    // recommended
+    tproxy_enabled: import_zod6.z.boolean().optional()
+    // deprecated, for compatibility
+  }),
+  listed: import_zod6.z.boolean().optional(),
+  instance_type: import_zod6.z.string().nullable().optional(),
+  kms_id: import_zod6.z.string().optional(),
+  env_keys: import_zod6.z.array(import_zod6.z.string()).optional()
+}).passthrough();
+function autofillComposeFileName(appCompose) {
+  if (appCompose.compose_file && !appCompose.compose_file.name) {
+    return {
+      ...appCompose,
+      compose_file: {
+        ...appCompose.compose_file,
+        name: appCompose.name
+      }
+    };
+  }
+  return appCompose;
+}
+function handleGatewayCompatibility(appCompose) {
+  if (!appCompose.compose_file) {
+    return appCompose;
+  }
+  const composeFile = { ...appCompose.compose_file };
+  if (typeof composeFile.gateway_enabled === "boolean" && typeof composeFile.tproxy_enabled === "boolean") {
+    delete composeFile.tproxy_enabled;
+  } else if (typeof composeFile.tproxy_enabled === "boolean" && typeof composeFile.gateway_enabled === "undefined") {
+    composeFile.gateway_enabled = composeFile.tproxy_enabled;
+    delete composeFile.tproxy_enabled;
+    if (typeof window !== "undefined" ? window.console : globalThis.console) {
+      console.warn(
+        "[phala/cloud] tproxy_enabled is deprecated, please use gateway_enabled instead. See docs for migration."
+      );
+    }
+  }
+  return {
+    ...appCompose,
+    compose_file: composeFile
+  };
+}
+var { action: provisionCvm, safeAction: safeProvisionCvm } = defineAction(ProvisionCvmSchema, async (client, appCompose) => {
+  const body = handleGatewayCompatibility(autofillComposeFileName(appCompose));
+  let requestBody = { ...body };
+  if (typeof body.node_id === "number") {
+    requestBody = { ...body, teepod_id: body.node_id };
+    delete requestBody.node_id;
+  } else if (typeof body.teepod_id === "number") {
+    console.warn("[phala/cloud] teepod_id is deprecated, please use node_id instead.");
+  }
+  return await client.post("/cvms/provision", requestBody);
+});
+
+// src/actions/cvms/commit_cvm_provision.ts
+var import_zod7 = require("zod");
+var CommitCvmProvisionSchema = 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: import_zod7.z.object({
+    id: import_zod7.z.number(),
+    name: import_zod7.z.string()
+  }).nullable(),
+  user_id: import_zod7.z.number().nullable(),
+  app_id: import_zod7.z.string().nullable(),
+  vm_uuid: import_zod7.z.string().nullable(),
+  instance_id: import_zod7.z.string().nullable(),
+  app_url: import_zod7.z.string().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().nullable(),
+  version: import_zod7.z.string().nullable(),
+  runner: import_zod7.z.string().nullable(),
+  docker_compose_file: import_zod7.z.string().nullable(),
+  features: import_zod7.z.array(import_zod7.z.string()).nullable(),
+  created_at: import_zod7.z.string(),
+  encrypted_env_pubkey: import_zod7.z.string().nullable().optional(),
+  app_auth_contract_address: import_zod7.z.string().nullable().optional(),
+  deployer_address: import_zod7.z.string().nullable().optional()
+}).passthrough();
+var CommitCvmProvisionRequestSchema = import_zod7.z.object({
+  encrypted_env: import_zod7.z.string().optional().nullable(),
+  app_id: import_zod7.z.string(),
+  compose_hash: import_zod7.z.string().optional(),
+  kms_id: import_zod7.z.string().optional(),
+  contract_address: import_zod7.z.string().optional(),
+  deployer_address: import_zod7.z.string().optional(),
+  env_keys: import_zod7.z.array(import_zod7.z.string()).optional().nullable()
+}).passthrough();
+var { action: commitCvmProvision, safeAction: safeCommitCvmProvision } = defineAction(CommitCvmProvisionSchema, async (client, payload) => {
+  return await client.post("/cvms", payload);
+});
+
+// src/actions/blockchains/deploy_app_auth.ts
+var import_zod8 = require("zod");
+var import_viem3 = require("viem");
+var import_accounts2 = require("viem/accounts");
+
 // src/utils/index.ts
 var import_encrypt_env_vars = require("@phala/dstack-sdk/encrypt-env-vars");
 
@@ -578,38 +960,6 @@ function asHex(value) {
   throw new Error(`Invalid hex value: ${value}`);
 }
 
-// src/utils/validate-parameters.ts
-function validateActionParameters(parameters) {
-  if (parameters?.schema !== void 0 && parameters?.schema !== false) {
-    if (typeof parameters.schema !== "object" || parameters.schema === null || !("parse" in parameters.schema) || typeof parameters.schema.parse !== "function") {
-      throw new Error("Invalid schema: must be a Zod schema object, false, or undefined");
-    }
-  }
-}
-function safeValidateActionParameters(parameters) {
-  if (parameters?.schema !== void 0 && parameters?.schema !== false) {
-    if (typeof parameters.schema !== "object" || parameters.schema === null || !("parse" in parameters.schema) || typeof parameters.schema.parse !== "function") {
-      return {
-        success: false,
-        error: {
-          name: "ZodError",
-          message: "Invalid schema: must be a Zod schema object, false, or undefined",
-          issues: [
-            {
-              code: "invalid_type",
-              expected: "object",
-              received: typeof parameters.schema,
-              path: ["schema"],
-              message: "Invalid schema: must be a Zod schema object, false, or undefined"
-            }
-          ]
-        }
-      };
-    }
-  }
-  return void 0;
-}
-
 // src/utils/network.ts
 var NetworkError = class extends Error {
   constructor(message, code, details) {
@@ -1139,370 +1489,77 @@ async function createClientsFromBrowser(chain, rpcUrl) {
     if (error instanceof WalletError || error instanceof NetworkError) {
       throw error;
     }
-    throw new WalletError(
-      `Failed to connect browser wallet: ${error instanceof Error ? error.message : "Unknown error"}`,
-      "BROWSER_CONNECTION_FAILED",
-      error
-    );
-  }
-}
-async function switchToNetwork(provider, chainId) {
-  try {
-    await provider.request({
-      method: "wallet_switchEthereumChain",
-      params: [{ chainId: `0x${chainId.toString(16)}` }]
-    });
-  } catch (error) {
-    const errorObj = error;
-    if (errorObj.code === 4902) {
-      throw new NetworkError(
-        `Network ${chainId} not found in wallet. Please add it manually.`,
-        "NETWORK_NOT_FOUND",
-        error
-      );
-    }
-    throw new NetworkError(
-      `Failed to switch network: ${errorObj.message || "Unknown error"}`,
-      "NETWORK_SWITCH_FAILED",
-      error
-    );
-  }
-}
-async function addNetwork(provider, config) {
-  try {
-    await provider.request({
-      method: "wallet_addEthereumChain",
-      params: [
-        {
-          chainId: `0x${config.chainId.toString(16)}`,
-          chainName: config.name,
-          rpcUrls: [config.rpcUrl],
-          blockExplorerUrls: config.blockExplorer ? [config.blockExplorer] : void 0,
-          nativeCurrency: {
-            name: "ETH",
-            symbol: "ETH",
-            decimals: 18
-          }
-        }
-      ]
-    });
-  } catch (error) {
-    const errorObj = error;
-    throw new NetworkError(
-      `Failed to add network: ${errorObj.message || "Unknown error"}`,
-      "NETWORK_ADD_FAILED",
-      error
-    );
-  }
-}
-async function autoCreateClients(chain, options = {}) {
-  const { privateKey, rpcUrl, preferBrowser = false } = options;
-  if (privateKey) {
-    return createClientsFromPrivateKey(chain, privateKey, rpcUrl);
-  }
-  if (isBrowser() && (preferBrowser || !privateKey)) {
-    return createClientsFromBrowser(chain, rpcUrl);
-  }
-  throw new WalletError(
-    "No wallet connection method available. Provide a private key for server-side usage or use in browser environment.",
-    "NO_CONNECTION_METHOD"
-  );
-}
-
-// src/actions/get_current_user.ts
-var CurrentUserSchema = import_zod4.z.object({
-  username: import_zod4.z.string(),
-  email: import_zod4.z.string(),
-  credits: import_zod4.z.number(),
-  granted_credits: import_zod4.z.number(),
-  avatar: import_zod4.z.string(),
-  team_name: import_zod4.z.string(),
-  team_tier: import_zod4.z.string()
-}).passthrough();
-async function getCurrentUser(client, parameters) {
-  validateActionParameters(parameters);
-  const response = await client.get("/auth/me");
-  if (parameters?.schema === false) {
-    return response;
-  }
-  const schema = parameters?.schema || CurrentUserSchema;
-  return schema.parse(response);
-}
-async function safeGetCurrentUser(client, parameters) {
-  const parameterValidationError = safeValidateActionParameters(parameters);
-  if (parameterValidationError) {
-    return parameterValidationError;
-  }
-  const httpResult = await client.safeGet("/auth/me");
-  if (!httpResult.success) {
-    return httpResult;
-  }
-  if (parameters?.schema === false) {
-    return { success: true, data: httpResult.data };
-  }
-  const schema = parameters?.schema || CurrentUserSchema;
-  return schema.safeParse(httpResult.data);
-}
-
-// src/actions/get_available_nodes.ts
-var import_zod5 = require("zod");
-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_zod5.z.string().nullable().optional()
-}).passthrough();
-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_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_zod5.z.object({
-  tier: import_zod5.z.string(),
-  // TeamTier is string enum
-  capacity: ResourceThresholdSchema,
-  nodes: import_zod5.z.array(TeepodCapacitySchema),
-  kms_list: import_zod5.z.array(KmsInfoSchema)
-}).passthrough();
-async function getAvailableNodes(client, parameters) {
-  const response = await client.get("/teepods/available");
-  if (parameters?.schema === false) {
-    return response;
-  }
-  const schema = parameters?.schema || AvailableNodesSchema;
-  return schema.parse(response);
-}
-async function safeGetAvailableNodes(client, parameters) {
-  const httpResult = await client.safeGet("/teepods/available");
-  if (!httpResult.success) {
-    return httpResult;
-  }
-  if (parameters?.schema === false) {
-    return { success: true, data: httpResult.data };
-  }
-  const schema = parameters?.schema || AvailableNodesSchema;
-  return schema.safeParse(httpResult.data);
-}
-
-// src/actions/provision_cvm.ts
-var import_zod6 = require("zod");
-var ProvisionCvmSchema = import_zod6.z.object({
-  app_id: import_zod6.z.string().nullable().optional(),
-  app_env_encrypt_pubkey: import_zod6.z.string().nullable().optional(),
-  compose_hash: import_zod6.z.string(),
-  fmspc: import_zod6.z.string().nullable().optional(),
-  device_id: import_zod6.z.string().nullable().optional(),
-  os_image_hash: import_zod6.z.string().nullable().optional(),
-  node_id: import_zod6.z.number().nullable().optional(),
-  // Transformed from teepod_id in response
-  kms_id: import_zod6.z.string().nullable().optional()
-}).passthrough();
-var ProvisionCvmRequestSchema = import_zod6.z.object({
-  node_id: import_zod6.z.number().optional(),
-  // recommended
-  teepod_id: import_zod6.z.number().optional(),
-  // deprecated, for compatibility
-  name: import_zod6.z.string(),
-  image: import_zod6.z.string(),
-  vcpu: import_zod6.z.number(),
-  memory: import_zod6.z.number(),
-  disk_size: import_zod6.z.number(),
-  compose_file: import_zod6.z.object({
-    allowed_envs: import_zod6.z.array(import_zod6.z.string()).optional(),
-    pre_launch_script: import_zod6.z.string().optional(),
-    docker_compose_file: import_zod6.z.string().optional(),
-    name: import_zod6.z.string().optional(),
-    kms_enabled: import_zod6.z.boolean().optional(),
-    public_logs: import_zod6.z.boolean().optional(),
-    public_sysinfo: import_zod6.z.boolean().optional(),
-    gateway_enabled: import_zod6.z.boolean().optional(),
-    // recommended
-    tproxy_enabled: import_zod6.z.boolean().optional()
-    // deprecated, for compatibility
-  }),
-  listed: import_zod6.z.boolean().optional(),
-  instance_type: import_zod6.z.string().nullable().optional(),
-  kms_id: import_zod6.z.string().optional(),
-  env_keys: import_zod6.z.array(import_zod6.z.string()).optional()
-}).passthrough();
-function autofillComposeFileName(appCompose) {
-  if (appCompose.compose_file && !appCompose.compose_file.name) {
-    return {
-      ...appCompose,
-      compose_file: {
-        ...appCompose.compose_file,
-        name: appCompose.name
-      }
-    };
-  }
-  return appCompose;
-}
-function handleGatewayCompatibility(appCompose) {
-  if (!appCompose.compose_file) {
-    return appCompose;
-  }
-  const composeFile = { ...appCompose.compose_file };
-  if (typeof composeFile.gateway_enabled === "boolean" && typeof composeFile.tproxy_enabled === "boolean") {
-    delete composeFile.tproxy_enabled;
-  } else if (typeof composeFile.tproxy_enabled === "boolean" && typeof composeFile.gateway_enabled === "undefined") {
-    composeFile.gateway_enabled = composeFile.tproxy_enabled;
-    delete composeFile.tproxy_enabled;
-    if (typeof window !== "undefined" ? window.console : globalThis.console) {
-      console.warn(
-        "[phala/cloud] tproxy_enabled is deprecated, please use gateway_enabled instead. See docs for migration."
-      );
-    }
-  }
-  return {
-    ...appCompose,
-    compose_file: composeFile
-  };
-}
-function transformResponse(data, isDefaultSchema) {
-  if (!isDefaultSchema || !data || typeof data !== "object") {
-    return data;
-  }
-  if (data && typeof data === "object" && "teepod_id" in data) {
-    const { teepod_id, ...rest } = data;
-    return { ...rest, node_id: teepod_id };
-  }
-  return data;
-}
-async function provisionCvm(client, appCompose, parameters) {
-  validateActionParameters(parameters);
-  const body = handleGatewayCompatibility(autofillComposeFileName(appCompose));
-  let requestBody = { ...body };
-  if (typeof body.node_id === "number") {
-    requestBody = { ...body, teepod_id: body.node_id };
-    delete requestBody.node_id;
-  } else if (typeof body.teepod_id === "number") {
-    console.warn("[phala/cloud] teepod_id is deprecated, please use node_id instead.");
-  }
-  const response = await client.post("/cvms/provision", requestBody);
-  const isDefaultSchema = parameters?.schema === void 0;
-  const transformedData = transformResponse(response, isDefaultSchema);
-  if (parameters?.schema === false) {
-    return transformedData;
+    throw new WalletError(
+      `Failed to connect browser wallet: ${error instanceof Error ? error.message : "Unknown error"}`,
+      "BROWSER_CONNECTION_FAILED",
+      error
+    );
   }
-  const usedSchema = parameters?.schema || ProvisionCvmSchema;
-  return usedSchema.parse(transformedData);
 }
-async function safeProvisionCvm(client, appCompose, parameters) {
-  const parameterValidationError = safeValidateActionParameters(parameters);
-  if (parameterValidationError) {
-    return parameterValidationError;
-  }
-  const schema = parameters?.schema;
-  const body = handleGatewayCompatibility(autofillComposeFileName(appCompose));
-  let requestBody = { ...body };
-  if (typeof body.node_id === "number") {
-    requestBody = { ...body, teepod_id: body.node_id };
-    delete requestBody.node_id;
-  } else if (typeof body.teepod_id === "number") {
-    console.warn("[phala/cloud] teepod_id is deprecated, please use node_id instead.");
-  }
-  const httpResult = await client.safePost("/cvms/provision", requestBody);
-  if (!httpResult.success) {
-    return httpResult;
-  }
-  if (schema === false) {
-    return { success: true, data: httpResult.data };
+async function switchToNetwork(provider, chainId) {
+  try {
+    await provider.request({
+      method: "wallet_switchEthereumChain",
+      params: [{ chainId: `0x${chainId.toString(16)}` }]
+    });
+  } catch (error) {
+    const errorObj = error;
+    if (errorObj.code === 4902) {
+      throw new NetworkError(
+        `Network ${chainId} not found in wallet. Please add it manually.`,
+        "NETWORK_NOT_FOUND",
+        error
+      );
+    }
+    throw new NetworkError(
+      `Failed to switch network: ${errorObj.message || "Unknown error"}`,
+      "NETWORK_SWITCH_FAILED",
+      error
+    );
   }
-  const isDefaultSchema = !schema;
-  const usedSchema = schema || ProvisionCvmSchema;
-  const transformResult = usedSchema.safeParse(transformResponse(httpResult.data, isDefaultSchema));
-  return transformResult;
 }
-
-// src/actions/commit_cvm_provision.ts
-var import_zod7 = require("zod");
-var CommitCvmProvisionSchema = 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: import_zod7.z.object({
-    id: import_zod7.z.number(),
-    name: import_zod7.z.string()
-  }).nullable(),
-  user_id: import_zod7.z.number().nullable(),
-  app_id: import_zod7.z.string().nullable(),
-  vm_uuid: import_zod7.z.string().nullable(),
-  instance_id: import_zod7.z.string().nullable(),
-  app_url: import_zod7.z.string().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().nullable(),
-  version: import_zod7.z.string().nullable(),
-  runner: import_zod7.z.string().nullable(),
-  docker_compose_file: import_zod7.z.string().nullable(),
-  features: import_zod7.z.array(import_zod7.z.string()).nullable(),
-  created_at: import_zod7.z.string(),
-  encrypted_env_pubkey: import_zod7.z.string().nullable().optional(),
-  app_auth_contract_address: import_zod7.z.string().nullable().optional(),
-  deployer_address: import_zod7.z.string().nullable().optional()
-}).passthrough();
-var CommitCvmProvisionRequestSchema = import_zod7.z.object({
-  encrypted_env: import_zod7.z.string().optional().nullable(),
-  app_id: import_zod7.z.string(),
-  compose_hash: import_zod7.z.string().optional(),
-  kms_id: import_zod7.z.string().optional(),
-  contract_address: import_zod7.z.string().optional(),
-  deployer_address: import_zod7.z.string().optional(),
-  env_keys: import_zod7.z.array(import_zod7.z.string()).optional().nullable()
-}).passthrough();
-async function commitCvmProvision(client, payload, parameters) {
-  validateActionParameters(parameters);
-  const response = await client.post("/cvms", payload);
-  if (parameters?.schema === false) {
-    return response;
+async function addNetwork(provider, config) {
+  try {
+    await provider.request({
+      method: "wallet_addEthereumChain",
+      params: [
+        {
+          chainId: `0x${config.chainId.toString(16)}`,
+          chainName: config.name,
+          rpcUrls: [config.rpcUrl],
+          blockExplorerUrls: config.blockExplorer ? [config.blockExplorer] : void 0,
+          nativeCurrency: {
+            name: "ETH",
+            symbol: "ETH",
+            decimals: 18
+          }
+        }
+      ]
+    });
+  } catch (error) {
+    const errorObj = error;
+    throw new NetworkError(
+      `Failed to add network: ${errorObj.message || "Unknown error"}`,
+      "NETWORK_ADD_FAILED",
+      error
+    );
   }
-  const schema = parameters?.schema || CommitCvmProvisionSchema;
-  return schema.parse(response);
 }
-async function safeCommitCvmProvision(client, payload, parameters) {
-  const parameterValidationError = safeValidateActionParameters(parameters);
-  if (parameterValidationError) {
-    return parameterValidationError;
-  }
-  const httpResult = await client.safePost("/cvms", payload);
-  if (!httpResult.success) {
-    return httpResult;
+async function autoCreateClients(chain, options = {}) {
+  const { privateKey, rpcUrl, preferBrowser = false } = options;
+  if (privateKey) {
+    return createClientsFromPrivateKey(chain, privateKey, rpcUrl);
   }
-  if (parameters?.schema === false) {
-    return { success: true, data: httpResult.data };
+  if (isBrowser() && (preferBrowser || !privateKey)) {
+    return createClientsFromBrowser(chain, rpcUrl);
   }
-  const schema = parameters?.schema || CommitCvmProvisionSchema;
-  const validationResult = schema.safeParse(httpResult.data);
-  return validationResult;
+  throw new WalletError(
+    "No wallet connection method available. Provide a private key for server-side usage or use in browser environment.",
+    "NO_CONNECTION_METHOD"
+  );
 }
 
-// src/actions/deploy_app_auth.ts
-var import_zod8 = require("zod");
-var import_viem3 = require("viem");
-var import_accounts2 = require("viem/accounts");
+// src/actions/blockchains/deploy_app_auth.ts
 var kmsAuthAbi = [
   {
     inputs: [
@@ -1830,7 +1887,7 @@ async function safeDeployAppAuth(request, parameters) {
   }
 }
 
-// src/actions/add_compose_hash.ts
+// src/actions/blockchains/add_compose_hash.ts
 var import_zod9 = require("zod");
 var import_viem4 = require("viem");
 var import_accounts3 = require("viem/accounts");
@@ -2091,7 +2148,7 @@ async function safeAddComposeHash(request, parameters) {
   }
 }
 
-// src/actions/get_cvm_compose_file.ts
+// src/actions/cvms/get_cvm_compose_file.ts
 var import_zod11 = require("zod");
 
 // src/types/app_compose.ts
@@ -2109,7 +2166,7 @@ var LooseAppComposeSchema = import_zod10.z.object({
   pre_launch_script: import_zod10.z.string().optional()
 }).passthrough();
 
-// src/actions/get_cvm_compose_file.ts
+// src/actions/cvms/get_cvm_compose_file.ts
 var GetCvmComposeFileRequestSchema = import_zod11.z.object({
   id: import_zod11.z.string().optional(),
   uuid: import_zod11.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(),
@@ -2128,32 +2185,12 @@ var GetCvmComposeFileRequestSchema = import_zod11.z.object({
   cvmId: data.id || data.uuid || data.app_id || data.instance_id,
   _raw: data
 }));
-async function getCvmComposeFile(client, request, parameters) {
+var { action: getCvmComposeFile, safeAction: safeGetCvmComposeFile } = defineAction(LooseAppComposeSchema, async (client, request) => {
   const validatedRequest = GetCvmComposeFileRequestSchema.parse(request);
-  const response = await client.get(`/cvms/${validatedRequest.cvmId}/compose_file`);
-  if (parameters?.schema === false) {
-    return response;
-  }
-  const schema = parameters?.schema || LooseAppComposeSchema;
-  return schema.parse(response);
-}
-async function safeGetCvmComposeFile(client, request, parameters) {
-  const requestValidation = GetCvmComposeFileRequestSchema.safeParse(request);
-  if (!requestValidation.success) {
-    return requestValidation;
-  }
-  const httpResult = await client.safeGet(`/cvms/${requestValidation.data.cvmId}/compose_file`);
-  if (!httpResult.success) {
-    return httpResult;
-  }
-  if (parameters?.schema === false) {
-    return { success: true, data: httpResult.data };
-  }
-  const schema = parameters?.schema || LooseAppComposeSchema;
-  return schema.safeParse(httpResult.data);
-}
+  return await client.get(`/cvms/${validatedRequest.cvmId}/compose_file`);
+});
 
-// src/actions/provision_cvm_compose_file_update.ts
+// src/actions/cvms/provision_cvm_compose_file_update.ts
 var import_zod12 = require("zod");
 var ProvisionCvmComposeFileUpdateRequestSchema = import_zod12.z.object({
   id: import_zod12.z.string().optional(),
@@ -2183,38 +2220,15 @@ var ProvisionCvmComposeFileUpdateResultSchema = import_zod12.z.object({
   compose_hash: import_zod12.z.string(),
   kms_info: KmsInfoSchema.nullable().optional()
 }).passthrough();
-async function provisionCvmComposeFileUpdate(client, request, parameters) {
+var { action: provisionCvmComposeFileUpdate, safeAction: safeProvisionCvmComposeFileUpdate } = defineAction(ProvisionCvmComposeFileUpdateResultSchema, async (client, request) => {
   const validatedRequest = ProvisionCvmComposeFileUpdateRequestSchema.parse(request);
-  const response = await client.post(
+  return await client.post(
     `/cvms/${validatedRequest.cvmId}/compose_file/provision`,
     validatedRequest.request
   );
-  if (parameters?.schema === false) {
-    return response;
-  }
-  const schema = parameters?.schema || ProvisionCvmComposeFileUpdateResultSchema;
-  return schema.parse(response);
-}
-async function safeProvisionCvmComposeFileUpdate(client, request, parameters) {
-  const requestValidation = ProvisionCvmComposeFileUpdateRequestSchema.safeParse(request);
-  if (!requestValidation.success) {
-    return requestValidation;
-  }
-  const httpResult = await client.safePost(
-    `/cvms/${requestValidation.data.cvmId}/compose_file/provision`,
-    requestValidation.data.request
-  );
-  if (!httpResult.success) {
-    return httpResult;
-  }
-  if (parameters?.schema === false) {
-    return { success: true, data: httpResult.data };
-  }
-  const schema = parameters?.schema || ProvisionCvmComposeFileUpdateResultSchema;
-  return schema.safeParse(httpResult.data);
-}
+});
 
-// src/actions/commit_cvm_compose_file_update.ts
+// src/actions/cvms/commit_cvm_compose_file_update.ts
 var import_zod13 = require("zod");
 var CommitCvmComposeFileUpdateRequestSchema = import_zod13.z.object({
   id: import_zod13.z.string().optional(),
@@ -2243,40 +2257,19 @@ var CommitCvmComposeFileUpdateRequestSchema = import_zod13.z.object({
   _raw: data
 }));
 var CommitCvmComposeFileUpdateSchema = import_zod13.z.any().transform(() => void 0);
-async function commitCvmComposeFileUpdate(client, request, parameters) {
-  const validatedRequest = CommitCvmComposeFileUpdateRequestSchema.parse(request);
-  const response = await client.patch(`/cvms/${validatedRequest.cvmId}/compose_file`, {
-    compose_hash: validatedRequest.compose_hash,
-    encrypted_env: validatedRequest.encrypted_env,
-    env_keys: validatedRequest.env_keys
-  });
-  if (parameters?.schema === false) {
-    return response;
-  }
-  const schema = parameters?.schema || CommitCvmComposeFileUpdateSchema;
-  return schema.parse(response);
-}
-async function safeCommitCvmComposeFileUpdate(client, request, parameters) {
-  const requestValidation = CommitCvmComposeFileUpdateRequestSchema.safeParse(request);
-  if (!requestValidation.success) {
-    return requestValidation;
-  }
-  const httpResult = await client.safePatch(`/cvms/${requestValidation.data.cvmId}/compose_file`, {
-    compose_hash: requestValidation.data.compose_hash,
-    encrypted_env: requestValidation.data.encrypted_env,
-    env_keys: requestValidation.data.env_keys
-  });
-  if (!httpResult.success) {
-    return httpResult;
-  }
-  if (parameters?.schema === false) {
-    return { success: true, data: httpResult.data };
+var { action: commitCvmComposeFileUpdate, safeAction: safeCommitCvmComposeFileUpdate } = defineAction(
+  CommitCvmComposeFileUpdateSchema,
+  async (client, request) => {
+    const validatedRequest = CommitCvmComposeFileUpdateRequestSchema.parse(request);
+    return await client.patch(`/cvms/${validatedRequest.cvmId}/compose_file`, {
+      compose_hash: validatedRequest.compose_hash,
+      encrypted_env: validatedRequest.encrypted_env,
+      env_keys: validatedRequest.env_keys
+    });
   }
-  const schema = parameters?.schema || CommitCvmComposeFileUpdateSchema;
-  return schema.safeParse(httpResult.data);
-}
+);
 
-// src/actions/get_app_env_encrypt_pubkey.ts
+// src/actions/kms/get_app_env_encrypt_pubkey.ts
 var import_zod14 = require("zod");
 var GetAppEnvEncryptPubKeyRequestSchema = import_zod14.z.object({
   kms: import_zod14.z.string().min(1, "KMS ID or slug is required"),
@@ -2289,41 +2282,12 @@ var GetAppEnvEncryptPubKeySchema = import_zod14.z.object({
   public_key: import_zod14.z.string(),
   signature: import_zod14.z.string()
 }).strict();
-var getAppEnvEncryptPubKey = async (client, payload, parameters) => {
+var { action: getAppEnvEncryptPubKey, safeAction: safeGetAppEnvEncryptPubKey } = defineAction(GetAppEnvEncryptPubKeySchema, async (client, payload) => {
   const validatedRequest = GetAppEnvEncryptPubKeyRequestSchema.parse(payload);
-  validateActionParameters(parameters);
-  const response = await client.get(
-    `/kms/${validatedRequest.kms}/pubkey/${validatedRequest.app_id}`
-  );
-  if (parameters?.schema === false) {
-    return response;
-  }
-  const schema = parameters?.schema || GetAppEnvEncryptPubKeySchema;
-  return schema.parse(response);
-};
-var safeGetAppEnvEncryptPubKey = async (client, payload, parameters) => {
-  const requestValidation = GetAppEnvEncryptPubKeyRequestSchema.safeParse(payload);
-  if (!requestValidation.success) {
-    return requestValidation;
-  }
-  const parameterValidationError = safeValidateActionParameters(parameters);
-  if (parameterValidationError) {
-    return parameterValidationError;
-  }
-  const httpResult = await client.safeGet(
-    `/kms/${requestValidation.data.kms}/pubkey/${requestValidation.data.app_id}`
-  );
-  if (!httpResult.success) {
-    return httpResult;
-  }
-  if (parameters?.schema === false) {
-    return { success: true, data: httpResult.data };
-  }
-  const schema = parameters?.schema || GetAppEnvEncryptPubKeySchema;
-  return schema.safeParse(httpResult.data);
-};
+  return await client.get(`/kms/${validatedRequest.kms}/pubkey/${validatedRequest.app_id}`);
+});
 
-// src/actions/get_cvm_info.ts
+// src/actions/cvms/get_cvm_info.ts
 var import_zod15 = require("zod");
 var GetCvmInfoRequestSchema = import_zod15.z.object({
   id: import_zod15.z.string().optional(),
@@ -2343,41 +2307,12 @@ var GetCvmInfoRequestSchema = import_zod15.z.object({
   cvmId: data.id || data.uuid || data.app_id || data.instance_id,
   _raw: data
 }));
-async function getCvmInfo(client, request, parameters) {
+var { action: getCvmInfo, safeAction: safeGetCvmInfo } = defineAction(CvmLegacyDetailSchema, async (client, request) => {
   const validatedRequest = GetCvmInfoRequestSchema.parse(request);
-  validateActionParameters(parameters);
-  const response = await client.get(`/cvms/${validatedRequest.cvmId}`);
-  if (parameters?.schema === false) {
-    return response;
-  }
-  const schema = parameters?.schema || CvmLegacyDetailSchema;
-  return schema.parse(response);
-}
-async function safeGetCvmInfo(client, request, parameters) {
-  const requestValidation = GetCvmInfoRequestSchema.safeParse(request);
-  if (!requestValidation.success) {
-    return requestValidation;
-  }
-  const parameterValidationError = safeValidateActionParameters(parameters);
-  if (parameterValidationError) {
-    return parameterValidationError;
-  }
-  const httpResult = await client.safeGet(`/cvms/${requestValidation.data.cvmId}`);
-  if (!httpResult.success) {
-    return httpResult;
-  }
-  if (parameters?.schema === false) {
-    return {
-      success: true,
-      data: httpResult.data
-    };
-  }
-  const schema = parameters?.schema || CvmLegacyDetailSchema;
-  const validationResult = schema.safeParse(httpResult.data);
-  return validationResult;
-}
+  return await client.get(`/cvms/${validatedRequest.cvmId}`);
+});
 
-// src/actions/get_cvm_list.ts
+// src/actions/cvms/get_cvm_list.ts
 var import_zod16 = require("zod");
 var GetCvmListRequestSchema = import_zod16.z.object({
   page: import_zod16.z.number().int().min(1).optional(),
@@ -2391,77 +2326,22 @@ var GetCvmListSchema = import_zod16.z.object({
   page_size: import_zod16.z.number(),
   pages: import_zod16.z.number()
 }).strict();
-async function getCvmList(client, request, parameters) {
+var { action: getCvmList, safeAction: safeGetCvmList } = defineAction(GetCvmListSchema, async (client, request) => {
   const validatedRequest = GetCvmListRequestSchema.parse(request ?? {});
-  validateActionParameters(parameters);
-  const response = await client.get("/cvms/paginated", { params: validatedRequest });
-  if (parameters?.schema === false) {
-    return response;
-  }
-  const schema = parameters?.schema || GetCvmListSchema;
-  return schema.parse(response);
-}
-async function safeGetCvmList(client, request, parameters) {
-  const requestValidation = GetCvmListRequestSchema.safeParse(request ?? {});
-  if (!requestValidation.success) {
-    return requestValidation;
-  }
-  const parameterValidationError = safeValidateActionParameters(parameters);
-  if (parameterValidationError) {
-    return parameterValidationError;
-  }
-  const httpResult = await client.safeGet("/cvms/paginated", { params: requestValidation.data });
-  if (!httpResult.success) {
-    return httpResult;
-  }
-  if (parameters?.schema === false) {
-    return {
-      success: true,
-      data: httpResult.data
-    };
-  }
-  const schema = parameters?.schema || GetCvmListSchema;
-  const validationResult = schema.safeParse(httpResult.data);
-  return validationResult;
-}
+  return await client.get("/cvms/paginated", { params: validatedRequest });
+});
 
-// src/actions/get_kms_info.ts
+// src/actions/kms/get_kms_info.ts
 var import_zod17 = require("zod");
 var GetKmsInfoRequestSchema = import_zod17.z.object({
   kms_id: import_zod17.z.string().min(1, "KMS ID is required")
 });
-async function getKmsInfo(client, request, parameters) {
+var { action: getKmsInfo, safeAction: safeGetKmsInfo } = defineAction(KmsInfoSchema, async (client, request) => {
   const validatedRequest = GetKmsInfoRequestSchema.parse(request);
-  validateActionParameters(parameters);
-  const response = await client.get(`/kms/${validatedRequest.kms_id}`);
-  if (parameters?.schema === false) {
-    return response;
-  }
-  const schema = parameters?.schema || KmsInfoSchema;
-  return schema.parse(response);
-}
-async function safeGetKmsInfo(client, request, parameters) {
-  const requestValidation = GetKmsInfoRequestSchema.safeParse(request);
-  if (!requestValidation.success) {
-    return requestValidation;
-  }
-  const parameterValidationError = safeValidateActionParameters(parameters);
-  if (parameterValidationError) {
-    return parameterValidationError;
-  }
-  const httpResult = await client.safeGet(`/kms/${requestValidation.data.kms_id}`);
-  if (!httpResult.success) {
-    return httpResult;
-  }
-  if (parameters?.schema === false) {
-    return { success: true, data: httpResult.data };
-  }
-  const schema = parameters?.schema || KmsInfoSchema;
-  const validationResult = schema.safeParse(httpResult.data);
-  return validationResult;
-}
+  return await client.get(`/kms/${validatedRequest.kms_id}`);
+});
 
-// src/actions/get_kms_list.ts
+// src/actions/kms/get_kms_list.ts
 var import_zod18 = require("zod");
 var GetKmsListRequestSchema = import_zod18.z.object({
   page: import_zod18.z.number().int().min(1).optional(),
@@ -2475,39 +2355,10 @@ var GetKmsListSchema = import_zod18.z.object({
   page_size: import_zod18.z.number(),
   pages: import_zod18.z.number()
 }).strict();
-async function getKmsList(client, request, parameters) {
+var { action: getKmsList, safeAction: safeGetKmsList } = defineAction(GetKmsListSchema, async (client, request) => {
   const validatedRequest = GetKmsListRequestSchema.parse(request ?? {});
-  validateActionParameters(parameters);
-  const response = await client.get("/kms", { params: validatedRequest });
-  if (parameters?.schema === false) {
-    return response;
-  }
-  const schema = parameters?.schema || GetKmsListSchema;
-  return schema.parse(response);
-}
-async function safeGetKmsList(client, request, parameters) {
-  const requestValidation = GetKmsListRequestSchema.safeParse(request ?? {});
-  if (!requestValidation.success) {
-    return requestValidation;
-  }
-  const parameterValidationError = safeValidateActionParameters(parameters);
-  if (parameterValidationError) {
-    return parameterValidationError;
-  }
-  const httpResult = await client.safeGet("/kms", { params: requestValidation.data });
-  if (!httpResult.success) {
-    return httpResult;
-  }
-  if (parameters?.schema === false) {
-    return {
-      success: true,
-      data: httpResult.data
-    };
-  }
-  const schema = parameters?.schema || GetKmsListSchema;
-  const validationResult = schema.safeParse(httpResult.data);
-  return validationResult;
-}
+  return await client.get("/kms", { params: validatedRequest });
+});
 
 // src/actions/workspaces/list_workspaces.ts
 var import_zod19 = require("zod");
@@ -2528,64 +2379,18 @@ var ListWorkspacesSchema = import_zod19.z.object({
   data: import_zod19.z.array(WorkspaceResponseSchema),
   pagination: PaginationMetadataSchema
 }).passthrough();
-async function listWorkspaces(client, parameters) {
-  validateActionParameters(parameters);
-  const queryParams = new URLSearchParams();
-  if (parameters?.cursor) queryParams.append("cursor", parameters.cursor);
-  if (parameters?.limit) queryParams.append("limit", parameters.limit.toString());
-  const url = queryParams.toString() ? `/workspaces?${queryParams.toString()}` : "/workspaces";
-  const response = await client.get(url);
-  if (parameters?.schema === false) {
-    return response;
-  }
-  const schema = parameters?.schema || ListWorkspacesSchema;
-  return schema.parse(response);
-}
-async function safeListWorkspaces(client, parameters) {
-  const parameterValidationError = safeValidateActionParameters(parameters);
-  if (parameterValidationError) {
-    return parameterValidationError;
-  }
+var { action: listWorkspaces, safeAction: safeListWorkspaces } = defineAction(ListWorkspacesSchema, async (client, request) => {
   const queryParams = new URLSearchParams();
-  if (parameters?.cursor) queryParams.append("cursor", parameters.cursor);
-  if (parameters?.limit) queryParams.append("limit", parameters.limit.toString());
+  if (request?.cursor) queryParams.append("cursor", request.cursor);
+  if (request?.limit) queryParams.append("limit", request.limit.toString());
   const url = queryParams.toString() ? `/workspaces?${queryParams.toString()}` : "/workspaces";
-  const httpResult = await client.safeGet(url);
-  if (!httpResult.success) {
-    return httpResult;
-  }
-  if (parameters?.schema === false) {
-    return { success: true, data: httpResult.data };
-  }
-  const schema = parameters?.schema || ListWorkspacesSchema;
-  return schema.safeParse(httpResult.data);
-}
+  return await client.get(url);
+});
 
 // src/actions/workspaces/get_workspace.ts
-async function getWorkspace(client, teamSlug, parameters) {
-  validateActionParameters(parameters);
-  const response = await client.get(`/workspaces/${teamSlug}`);
-  if (parameters?.schema === false) {
-    return response;
-  }
-  const schema = parameters?.schema || WorkspaceResponseSchema;
-  return schema.parse(response);
-}
-async function safeGetWorkspace(client, teamSlug, parameters) {
-  const parameterValidationError = safeValidateActionParameters(parameters);
-  if (parameterValidationError) {
-    return parameterValidationError;
-  }
-  const httpResult = await client.safeGet(`/workspaces/${teamSlug}`);
-  if (!httpResult.success) {
-    return httpResult;
-  }
-  if (parameters?.schema === false) {
-    return { success: true, data: httpResult.data };
-  }
-  const schema = parameters?.schema || WorkspaceResponseSchema;
-  return schema.safeParse(httpResult.data);
-}
+var { action: getWorkspace, safeAction: safeGetWorkspace } = defineAction(WorkspaceResponseSchema, async (client, teamSlug) => {
+  return await client.get(`/workspaces/${teamSlug}`);
+});
 
 // src/actions/list-instance-types.ts
 var import_zod20 = require("zod");
@@ -2611,45 +2416,13 @@ var PaginatedInstanceTypesSchema = import_zod20.z.object({
   page_size: import_zod20.z.number(),
   pages: import_zod20.z.number()
 }).strict();
-async function listInstanceTypes(client, request, parameters) {
+var { action: listInstanceTypes, safeAction: safeListInstanceTypes } = defineAction(PaginatedInstanceTypesSchema, async (client, request) => {
   const validatedRequest = ListInstanceTypesRequestSchema.parse(request ?? {});
-  validateActionParameters(parameters);
   const queryParams = new URLSearchParams();
   queryParams.append("page", validatedRequest.page.toString());
   queryParams.append("page_size", validatedRequest.page_size.toString());
-  const response = await client.get(`/api/instance-types?${queryParams.toString()}`);
-  if (parameters?.schema === false) {
-    return response;
-  }
-  const schema = parameters?.schema || PaginatedInstanceTypesSchema;
-  return schema.parse(response);
-}
-async function safeListInstanceTypes(client, request, parameters) {
-  const requestValidation = ListInstanceTypesRequestSchema.safeParse(request ?? {});
-  if (!requestValidation.success) {
-    return requestValidation;
-  }
-  const parameterValidationError = safeValidateActionParameters(parameters);
-  if (parameterValidationError) {
-    return parameterValidationError;
-  }
-  const queryParams = new URLSearchParams();
-  queryParams.append("page", requestValidation.data.page.toString());
-  queryParams.append("page_size", requestValidation.data.page_size.toString());
-  const httpResult = await client.safeGet(`/api/instance-types?${queryParams.toString()}`);
-  if (!httpResult.success) {
-    return httpResult;
-  }
-  if (parameters?.schema === false) {
-    return {
-      success: true,
-      data: httpResult.data
-    };
-  }
-  const schema = parameters?.schema || PaginatedInstanceTypesSchema;
-  const validationResult = schema.safeParse(httpResult.data);
-  return validationResult;
-}
+  return await client.get(`/api/instance-types?${queryParams.toString()}`);
+});
 
 // src/parse_dotenv.ts
 var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
@@ -2702,11 +2475,18 @@ var import_verify_env_encrypt_public_key = require("@phala/dstack-sdk/verify-env
   CvmNodeSchema,
   DeployAppAuthRequestSchema,
   DeployAppAuthSchema,
+  GetAppEnvEncryptPubKeyRequestSchema,
   GetAppEnvEncryptPubKeySchema,
+  GetCvmComposeFileRequestSchema,
+  GetCvmInfoRequestSchema,
+  GetCvmListRequestSchema,
   GetCvmListSchema,
+  GetKmsInfoRequestSchema,
+  GetKmsListRequestSchema,
   GetKmsListSchema,
   InstanceTypeSchema,
   KmsInfoSchema,
+  ListInstanceTypesRequestSchema,
   ListWorkspacesSchema,
   ManagedUserSchema,
   NetworkError,
@@ -2735,6 +2515,8 @@ var import_verify_env_encrypt_public_key = require("@phala/dstack-sdk/verify-env
   createClientsFromPrivateKey,
   createNetworkClients,
   createTransactionTracker,
+  defineAction,
+  defineSimpleAction,
   deployAppAuth,
   encryptEnvVars,
   estimateTransactionGas,