@phala/cloud 0.0.12 → 0.1.1-beta.1

package/dist/index.mjs

@@ -1,420 +1,86 @@
-// src/client.ts
-import { ofetch } from "ofetch";
-import debug from "debug";
+import {
+  ApiErrorSchema,
+  AvailableNodesSchema,
+  CommitCvmComposeFileUpdateRequestSchema,
+  CommitCvmComposeFileUpdateSchema,
+  CommitCvmProvisionRequestSchema,
+  CommitCvmProvisionSchema,
+  CurrentUserSchema,
+  CvmInfoSchema,
+  CvmLegacyDetailSchema,
+  CvmNetworkUrlsSchema,
+  CvmNodeSchema,
+  GetAppEnvEncryptPubKeyRequestSchema,
+  GetAppEnvEncryptPubKeySchema,
+  GetCvmComposeFileRequestSchema,
+  GetCvmInfoRequestSchema,
+  GetCvmListRequestSchema,
+  GetCvmListSchema,
+  GetKmsInfoRequestSchema,
+  GetKmsListRequestSchema,
+  GetKmsListSchema,
+  InstanceTypeSchema,
+  KmsInfoSchema,
+  ListInstanceTypesRequestSchema,
+  ListWorkspacesSchema,
+  ManagedUserSchema,
+  PaginatedInstanceTypesSchema,
+  PaginationMetadataSchema,
+  ProvisionCvmComposeFileUpdateRequestSchema,
+  ProvisionCvmComposeFileUpdateResultSchema,
+  ProvisionCvmRequestSchema,
+  ProvisionCvmSchema,
+  RequestError,
+  SUPPORTED_CHAINS,
+  VmInfoSchema,
+  WorkspaceResponseSchema,
+  commitCvmComposeFileUpdate,
+  commitCvmProvision,
+  createClient,
+  defineAction,
+  defineSimpleAction,
+  getAppEnvEncryptPubKey,
+  getAvailableNodes,
+  getCurrentUser,
+  getCvmComposeFile,
+  getCvmInfo,
+  getCvmList,
+  getKmsInfo,
+  getKmsList,
+  getWorkspace,
+  listInstanceTypes,
+  listWorkspaces,
+  provisionCvm,
+  provisionCvmComposeFileUpdate,
+  safeCommitCvmComposeFileUpdate,
+  safeCommitCvmProvision,
+  safeGetAppEnvEncryptPubKey,
+  safeGetAvailableNodes,
+  safeGetCurrentUser,
+  safeGetCvmComposeFile,
+  safeGetCvmInfo,
+  safeGetCvmList,
+  safeGetKmsInfo,
+  safeGetKmsList,
+  safeGetWorkspace,
+  safeListInstanceTypes,
+  safeListWorkspaces,
+  safeProvisionCvm,
+  safeProvisionCvmComposeFileUpdate,
+  safeValidateActionParameters,
+  validateActionParameters
+} from "./chunk-O5QBIXBA.mjs";
 
-// src/types/client.ts
+// src/actions/blockchains/deploy_app_auth.ts
 import { z } from "zod";
-var ApiErrorSchema = z.object({
-  detail: z.union([
-    z.string(),
-    z.array(
-      z.object({
-        msg: z.string(),
-        type: z.string().optional(),
-        ctx: z.record(z.unknown()).optional()
-      })
-    ),
-    z.record(z.unknown())
-  ]),
-  type: z.string().optional(),
-  code: z.string().optional()
-});
-var RequestError = class _RequestError extends Error {
-  constructor(message, options) {
-    super(message);
-    this.name = "RequestError";
-    this.isRequestError = true;
-    this.status = options?.status;
-    this.statusText = options?.statusText;
-    this.data = options?.data;
-    this.request = options?.request;
-    this.response = options?.response;
-    this.detail = options?.detail || message;
-    this.code = options?.code;
-    this.type = options?.type;
-  }
-  /**
-   * Create RequestError from FetchError
-   */
-  static fromFetchError(error) {
-    const parseResult = ApiErrorSchema.safeParse(error.data);
-    if (parseResult.success) {
-      return new _RequestError(error.message, {
-        status: error.status ?? void 0,
-        statusText: error.statusText ?? void 0,
-        data: error.data,
-        request: error.request ?? void 0,
-        response: error.response ?? void 0,
-        detail: parseResult.data.detail,
-        code: parseResult.data.code ?? void 0,
-        type: parseResult.data.type ?? void 0
-      });
-    }
-    return new _RequestError(error.message, {
-      status: error.status ?? void 0,
-      statusText: error.statusText ?? void 0,
-      data: error.data,
-      request: error.request ?? void 0,
-      response: error.response ?? void 0,
-      detail: error.data?.detail || "Unknown API error",
-      code: error.status?.toString() ?? void 0
-    });
-  }
-  /**
-   * Create RequestError from generic Error
-   */
-  static fromError(error, request) {
-    return new _RequestError(error.message, {
-      request: request ?? void 0,
-      detail: error.message
-    });
-  }
-};
-
-// src/client.ts
-var SUPPORTED_API_VERSIONS = ["2025-05-31"];
-var logger = debug("phala::api-client");
-function formatHeaders(headers) {
-  return Object.entries(headers).map(([key, value]) => `    -H "${key}: ${value}"`).join("\n");
-}
-function formatBody(body) {
-  if (!body) return "";
-  const bodyStr = typeof body === "string" ? body : JSON.stringify(body, null, 2);
-  return `    -d '${bodyStr.replace(/'/g, "\\'")}'`;
-}
-function formatResponse(status, statusText, headers, body) {
-  const headerEntries = [];
-  headers.forEach((value, key) => {
-    headerEntries.push(`${key}: ${value}`);
-  });
-  const headerStr = headerEntries.join("\n");
-  const bodyStr = typeof body === "string" ? body : JSON.stringify(body, null, 2);
-  return [
-    `< HTTP/1.1 ${status} ${statusText}`,
-    headerStr ? `< ${headerStr.replace(/\n/g, "\n< ")}` : "",
-    "",
-    bodyStr
-  ].filter(Boolean).join("\n");
-}
-var Client = class {
-  constructor(config = {}) {
-    const resolvedConfig = {
-      ...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"
-    };
-    const version = resolvedConfig.version && SUPPORTED_API_VERSIONS.includes(resolvedConfig.version) ? resolvedConfig.version : SUPPORTED_API_VERSIONS[0];
-    this.config = resolvedConfig;
-    if (!resolvedConfig.useCookieAuth && !resolvedConfig.apiKey) {
-      throw new Error(
-        "API key is required. Provide it via config.apiKey or set PHALA_CLOUD_API_KEY environment variable."
-      );
-    }
-    const { apiKey, baseURL, timeout, headers, useCookieAuth, onResponseError, ...fetchOptions } = resolvedConfig;
-    const requestHeaders = {
-      "X-Phala-Version": version,
-      "Content-Type": "application/json"
-    };
-    if (headers && typeof headers === "object") {
-      Object.entries(headers).forEach(([key, value]) => {
-        if (typeof value === "string") {
-          requestHeaders[key] = value;
-        }
-      });
-    }
-    if (!useCookieAuth && apiKey) {
-      requestHeaders["X-API-Key"] = apiKey;
-    }
-    this.fetchInstance = ofetch.create({
-      baseURL,
-      timeout: timeout || 3e4,
-      headers: requestHeaders,
-      ...useCookieAuth ? { credentials: "include" } : {},
-      ...fetchOptions,
-      // Log request in cURL format
-      onRequest({ request, options }) {
-        if (logger.enabled) {
-          const method = options.method || "GET";
-          const url = typeof request === "string" ? request : request.url;
-          const fullUrl = url.startsWith("http") ? url : `${baseURL}${url}`;
-          const headerObj = {};
-          if (options.headers && typeof options.headers === "object") {
-            Object.entries(options.headers).forEach(([key, value]) => {
-              if (typeof value === "string") {
-                headerObj[key] = value;
-              }
-            });
-          }
-          const curlCommand = [
-            `> curl -X ${method} "${fullUrl}"`,
-            formatHeaders(headerObj),
-            options.body ? formatBody(options.body) : ""
-          ].filter(Boolean).join("\n");
-          logger("\n=== REQUEST ===\n%s\n", curlCommand);
-        }
-      },
-      // Log response in cURL format
-      onResponse({ request, response, options }) {
-        if (logger.enabled) {
-          const method = options.method || "GET";
-          const url = typeof request === "string" ? request : request.url;
-          logger(
-            "\n=== RESPONSE [%s %s] (%dms) ===\n%s\n",
-            method,
-            url,
-            response.headers.get("x-response-time") || "?",
-            formatResponse(response.status, response.statusText, response.headers, response._data)
-          );
-        }
-      },
-      // Generic handlers for response error (similar to request.ts)
-      onResponseError: ({ request, response, options }) => {
-        console.warn(`HTTP ${response.status}: ${response.url}`);
-        if (logger.enabled) {
-          const method = options.method || "GET";
-          const url = typeof request === "string" ? request : request.url;
-          logger(
-            "\n=== ERROR RESPONSE [%s %s] ===\n%s\n",
-            method,
-            url,
-            formatResponse(response.status, response.statusText, response.headers, response._data)
-          );
-        }
-        if (onResponseError) {
-          onResponseError({ request, response, options });
-        }
-      }
-    });
-  }
-  /**
-   * Get the underlying ofetch instance for advanced usage
-   */
-  get raw() {
-    return this.fetchInstance;
-  }
-  // ===== Direct methods (throw on error) =====
-  /**
-   * Perform GET request (throws on error)
-   */
-  async get(request, options) {
-    return this.fetchInstance(request, {
-      ...options,
-      method: "GET"
-    });
-  }
-  /**
-   * Perform POST request (throws on error)
-   */
-  async post(request, body, options) {
-    return this.fetchInstance(request, {
-      ...options,
-      method: "POST",
-      body
-    });
-  }
-  /**
-   * Perform PUT request (throws on error)
-   */
-  async put(request, body, options) {
-    return this.fetchInstance(request, {
-      ...options,
-      method: "PUT",
-      body
-    });
-  }
-  /**
-   * Perform PATCH request (throws on error)
-   */
-  async patch(request, body, options) {
-    return this.fetchInstance(request, {
-      ...options,
-      method: "PATCH",
-      body
-    });
-  }
-  /**
-   * Perform DELETE request (throws on error)
-   */
-  async delete(request, options) {
-    return this.fetchInstance(request, {
-      ...options,
-      method: "DELETE"
-    });
-  }
-  // ===== Safe methods (return SafeResult) =====
-  /**
-   * Safe wrapper for any request method (zod-style result)
-   */
-  async safeRequest(fn) {
-    try {
-      const data = await fn();
-      return { success: true, data };
-    } catch (error) {
-      if (error && typeof error === "object" && "data" in error) {
-        const requestError2 = RequestError.fromFetchError(error);
-        return { success: false, error: requestError2 };
-      }
-      if (error instanceof Error) {
-        const requestError2 = RequestError.fromError(error);
-        return { success: false, error: requestError2 };
-      }
-      const requestError = new RequestError("Unknown error occurred", {
-        detail: "Unknown error occurred"
-      });
-      return { success: false, error: requestError };
-    }
-  }
-  /**
-   * Safe GET request (returns SafeResult)
-   */
-  async safeGet(request, options) {
-    return this.safeRequest(() => this.get(request, options));
-  }
-  /**
-   * Safe POST request (returns SafeResult)
-   */
-  async safePost(request, body, options) {
-    return this.safeRequest(() => this.post(request, body, options));
-  }
-  /**
-   * Safe PUT request (returns SafeResult)
-   */
-  async safePut(request, body, options) {
-    return this.safeRequest(() => this.put(request, body, options));
-  }
-  /**
-   * Safe PATCH request (returns SafeResult)
-   */
-  async safePatch(request, body, options) {
-    return this.safeRequest(() => this.patch(request, body, options));
-  }
-  /**
-   * Safe DELETE request (returns SafeResult)
-   */
-  async safeDelete(request, options) {
-    return this.safeRequest(() => this.delete(request, options));
-  }
-};
-function createClient(config = {}) {
-  return new Client(config);
-}
-
-// src/types/kms_info.ts
-import { z as z2 } from "zod";
-
-// src/types/supported_chains.ts
-import { anvil, base, mainnet } from "viem/chains";
-var SUPPORTED_CHAINS = {
-  [mainnet.id]: mainnet,
-  [base.id]: base,
-  [anvil.id]: anvil
-};
-
-// src/types/kms_info.ts
-var KmsInfoBaseSchema = z2.object({
-  id: z2.string(),
-  slug: z2.string().nullable(),
-  url: z2.string(),
-  version: z2.string(),
-  chain_id: z2.number().nullable(),
-  kms_contract_address: z2.string().nullable().transform((val) => val),
-  gateway_app_id: z2.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/types/cvm_info.ts
-import { z as z3 } from "zod";
-var VmInfoSchema = z3.object({
-  id: z3.string(),
-  name: z3.string(),
-  status: z3.string(),
-  uptime: z3.string(),
-  app_url: z3.string().nullable(),
-  app_id: z3.string(),
-  instance_id: z3.string().nullable(),
-  configuration: z3.any().optional(),
-  // TODO: add VmConfiguration schema if needed
-  exited_at: z3.string().nullable(),
-  boot_progress: z3.string().nullable(),
-  boot_error: z3.string().nullable(),
-  shutdown_progress: z3.string().nullable(),
-  image_version: z3.string().nullable()
-});
-var ManagedUserSchema = z3.object({
-  id: z3.number(),
-  username: z3.string()
-});
-var CvmNodeSchema = z3.object({
-  id: z3.number(),
-  name: z3.string(),
-  region_identifier: z3.string().optional()
-});
-var CvmNetworkUrlsSchema = z3.object({
-  app: z3.string(),
-  instance: z3.string()
-});
-var CvmInfoSchema = z3.object({
-  hosted: VmInfoSchema,
-  name: z3.string(),
-  managed_user: ManagedUserSchema.optional().nullable(),
-  node: CvmNodeSchema.optional().nullable(),
-  listed: z3.boolean().default(false),
-  status: z3.string(),
-  in_progress: z3.boolean().default(false),
-  dapp_dashboard_url: z3.string().nullable(),
-  syslog_endpoint: z3.string().nullable(),
-  allow_upgrade: z3.boolean().default(false),
-  project_id: z3.string().nullable(),
-  // HashedId is represented as string in JS
-  project_type: z3.string().nullable(),
-  billing_period: z3.string().nullable(),
-  kms_info: KmsInfoSchema.nullable(),
-  vcpu: z3.number().nullable(),
-  memory: z3.number().nullable(),
-  disk_size: z3.number().nullable(),
-  gateway_domain: z3.string().nullable(),
-  public_urls: z3.array(CvmNetworkUrlsSchema)
-}).partial();
-var CvmLegacyDetailSchema = z3.object({
-  id: z3.number(),
-  name: z3.string(),
-  status: z3.string(),
-  in_progress: z3.boolean(),
-  teepod_id: z3.number().nullable(),
-  teepod: CvmNodeSchema,
-  app_id: z3.string(),
-  vm_uuid: z3.string().nullable(),
-  instance_id: z3.string().nullable(),
-  vcpu: z3.number().nullable(),
-  memory: z3.number().nullable(),
-  disk_size: z3.number().nullable(),
-  base_image: z3.string(),
-  encrypted_env_pubkey: z3.string().nullable(),
-  listed: z3.boolean(),
-  project_id: z3.string().nullable(),
-  project_type: z3.string().nullable(),
-  public_sysinfo: z3.boolean(),
-  public_logs: z3.boolean(),
-  dapp_dashboard_url: z3.string().nullable(),
-  syslog_endpoint: z3.string().nullable(),
-  kms_info: KmsInfoSchema.nullable(),
-  contract_address: z3.string().nullable(),
-  deployer_address: z3.string().nullable(),
-  scheduled_delete_at: z3.string().nullable(),
-  public_urls: z3.array(CvmNetworkUrlsSchema),
-  gateway_domain: z3.string().nullable()
-});
-
-// src/actions/get_current_user.ts
-import { z as z4 } from "zod";
+import {
+  createPublicClient as createPublicClient2,
+  createWalletClient as createWalletClient2,
+  http as http2,
+  parseEventLogs,
+  parseEther
+} from "viem";
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
 
 // src/utils/index.ts
 import { encryptEnvVars } from "@phala/dstack-sdk/encrypt-env-vars";
@@ -449,38 +115,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) {
@@ -1085,306 +719,7 @@ async function autoCreateClients(chain, options = {}) {
   );
 }
 
-// src/actions/get_current_user.ts
-var CurrentUserSchema = z4.object({
-  username: z4.string(),
-  email: z4.string(),
-  credits: z4.number(),
-  granted_credits: z4.number(),
-  avatar: z4.string(),
-  team_name: z4.string(),
-  team_tier: z4.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
-import { z as z5 } from "zod";
-var AvailableOSImageSchema = z5.object({
-  name: z5.string(),
-  is_dev: z5.boolean(),
-  version: z5.union([
-    z5.tuple([z5.number(), z5.number(), z5.number()]),
-    z5.tuple([z5.number(), z5.number(), z5.number(), z5.number()])
-  ]),
-  os_image_hash: z5.string().nullable().optional()
-}).passthrough();
-var TeepodCapacitySchema = z5.object({
-  teepod_id: z5.number(),
-  name: z5.string(),
-  listed: z5.boolean(),
-  resource_score: z5.number(),
-  remaining_vcpu: z5.number(),
-  remaining_memory: z5.number(),
-  remaining_cvm_slots: z5.number(),
-  images: z5.array(AvailableOSImageSchema),
-  support_onchain_kms: z5.boolean().optional(),
-  fmspc: z5.string().nullable().optional(),
-  device_id: z5.string().nullable().optional(),
-  region_identifier: z5.string().nullable().optional(),
-  default_kms: z5.string().nullable().optional(),
-  kms_list: z5.array(z5.string()).default([])
-}).passthrough();
-var ResourceThresholdSchema = z5.object({
-  max_instances: z5.number().nullable().optional(),
-  max_vcpu: z5.number().nullable().optional(),
-  max_memory: z5.number().nullable().optional(),
-  max_disk: z5.number().nullable().optional()
-}).passthrough();
-var AvailableNodesSchema = z5.object({
-  tier: z5.string(),
-  // TeamTier is string enum
-  capacity: ResourceThresholdSchema,
-  nodes: z5.array(TeepodCapacitySchema),
-  kms_list: z5.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
-import { z as z6 } from "zod";
-var ProvisionCvmSchema = z6.object({
-  app_id: z6.string().nullable().optional(),
-  app_env_encrypt_pubkey: z6.string().nullable().optional(),
-  compose_hash: z6.string(),
-  fmspc: z6.string().nullable().optional(),
-  device_id: z6.string().nullable().optional(),
-  os_image_hash: z6.string().nullable().optional(),
-  node_id: z6.number().nullable().optional(),
-  // Transformed from teepod_id in response
-  kms_id: z6.string().nullable().optional()
-}).passthrough();
-var ProvisionCvmRequestSchema = z6.object({
-  node_id: z6.number().optional(),
-  // recommended
-  teepod_id: z6.number().optional(),
-  // deprecated, for compatibility
-  name: z6.string(),
-  image: z6.string(),
-  vcpu: z6.number(),
-  memory: z6.number(),
-  disk_size: z6.number(),
-  compose_file: z6.object({
-    allowed_envs: z6.array(z6.string()).optional(),
-    pre_launch_script: z6.string().optional(),
-    docker_compose_file: z6.string().optional(),
-    name: z6.string().optional(),
-    kms_enabled: z6.boolean().optional(),
-    public_logs: z6.boolean().optional(),
-    public_sysinfo: z6.boolean().optional(),
-    gateway_enabled: z6.boolean().optional(),
-    // recommended
-    tproxy_enabled: z6.boolean().optional()
-    // deprecated, for compatibility
-  }),
-  listed: z6.boolean().optional(),
-  instance_type: z6.string().nullable().optional(),
-  kms_id: z6.string().optional(),
-  env_keys: z6.array(z6.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;
-  }
-  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 };
-  }
-  const isDefaultSchema = !schema;
-  const usedSchema = schema || ProvisionCvmSchema;
-  const transformResult = usedSchema.safeParse(transformResponse(httpResult.data, isDefaultSchema));
-  return transformResult;
-}
-
-// src/actions/commit_cvm_provision.ts
-import { z as z7 } from "zod";
-var CommitCvmProvisionSchema = z7.object({
-  id: z7.number(),
-  name: z7.string(),
-  status: z7.string(),
-  teepod_id: z7.number(),
-  teepod: z7.object({
-    id: z7.number(),
-    name: z7.string()
-  }).nullable(),
-  user_id: z7.number().nullable(),
-  app_id: z7.string().nullable(),
-  vm_uuid: z7.string().nullable(),
-  instance_id: z7.string().nullable(),
-  app_url: z7.string().nullable(),
-  base_image: z7.string().nullable(),
-  vcpu: z7.number(),
-  memory: z7.number(),
-  disk_size: z7.number(),
-  manifest_version: z7.number().nullable(),
-  version: z7.string().nullable(),
-  runner: z7.string().nullable(),
-  docker_compose_file: z7.string().nullable(),
-  features: z7.array(z7.string()).nullable(),
-  created_at: z7.string(),
-  encrypted_env_pubkey: z7.string().nullable().optional(),
-  app_auth_contract_address: z7.string().nullable().optional(),
-  deployer_address: z7.string().nullable().optional()
-}).passthrough();
-var CommitCvmProvisionRequestSchema = z7.object({
-  encrypted_env: z7.string().optional().nullable(),
-  app_id: z7.string(),
-  compose_hash: z7.string().optional(),
-  kms_id: z7.string().optional(),
-  contract_address: z7.string().optional(),
-  deployer_address: z7.string().optional(),
-  env_keys: z7.array(z7.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;
-  }
-  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;
-  }
-  if (parameters?.schema === false) {
-    return { success: true, data: httpResult.data };
-  }
-  const schema = parameters?.schema || CommitCvmProvisionSchema;
-  const validationResult = schema.safeParse(httpResult.data);
-  return validationResult;
-}
-
-// src/actions/deploy_app_auth.ts
-import { z as z8 } from "zod";
-import {
-  createPublicClient as createPublicClient2,
-  createWalletClient as createWalletClient2,
-  http as http2,
-  parseEventLogs,
-  parseEther
-} from "viem";
-import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+// src/actions/blockchains/deploy_app_auth.ts
 var kmsAuthAbi = [
   {
     inputs: [
@@ -1415,25 +750,25 @@ var kmsAuthAbi = [
     anonymous: false
   }
 ];
-var DeployAppAuthRequestBaseSchema = z8.object({
+var DeployAppAuthRequestBaseSchema = z.object({
   // Chain configuration (conditionally required)
-  chain: z8.unknown().optional(),
-  rpcUrl: z8.string().optional(),
+  chain: z.unknown().optional(),
+  rpcUrl: z.string().optional(),
   // Contract configuration (required)
-  kmsContractAddress: z8.string(),
+  kmsContractAddress: z.string(),
   // Authentication mode: either privateKey OR walletClient (required, mutually exclusive)
-  privateKey: z8.string().optional(),
-  walletClient: z8.unknown().optional(),
+  privateKey: z.string().optional(),
+  walletClient: z.unknown().optional(),
   // Public client (optional, will create default if not provided)
-  publicClient: z8.unknown().optional(),
+  publicClient: z.unknown().optional(),
   // App configuration (optional)
-  allowAnyDevice: z8.boolean().optional().default(false),
-  deviceId: z8.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
-  composeHash: z8.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
-  disableUpgrades: z8.boolean().optional().default(false),
+  allowAnyDevice: z.boolean().optional().default(false),
+  deviceId: z.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
+  composeHash: z.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
+  disableUpgrades: z.boolean().optional().default(false),
   // Validation configuration (optional)
-  skipPrerequisiteChecks: z8.boolean().optional().default(false),
-  minBalance: z8.string().optional()
+  skipPrerequisiteChecks: z.boolean().optional().default(false),
+  minBalance: z.string().optional()
   // ETH amount as string, e.g., "0.01"
 }).passthrough();
 var DeployAppAuthRequestSchema = DeployAppAuthRequestBaseSchema.refine(
@@ -1461,13 +796,13 @@ var DeployAppAuthRequestSchema = DeployAppAuthRequestBaseSchema.refine(
     path: ["chain"]
   }
 );
-var DeployAppAuthSchema = z8.object({
-  appId: z8.string(),
-  appAuthAddress: z8.string(),
-  deployer: z8.string(),
-  transactionHash: z8.string(),
-  blockNumber: z8.bigint().optional(),
-  gasUsed: z8.bigint().optional()
+var DeployAppAuthSchema = z.object({
+  appId: z.string(),
+  appAuthAddress: z.string(),
+  deployer: z.string(),
+  transactionHash: z.string(),
+  blockNumber: z.bigint().optional(),
+  gasUsed: z.bigint().optional()
 }).passthrough();
 function parseDeploymentResult(receipt, deployer, kmsContractAddress) {
   try {
@@ -1712,8 +1047,8 @@ async function safeDeployAppAuth(request, parameters) {
   }
 }
 
-// src/actions/add_compose_hash.ts
-import { z as z9 } from "zod";
+// src/actions/blockchains/add_compose_hash.ts
+import { z as z2 } from "zod";
 import {
   createPublicClient as createPublicClient3,
   createWalletClient as createWalletClient3,
@@ -1737,29 +1072,29 @@ var appAuthAbi = [
     anonymous: false
   }
 ];
-var AddComposeHashRequestSchema = z9.object({
+var AddComposeHashRequestSchema = z2.object({
   // Chain configuration (conditionally required)
-  chain: z9.unknown().optional(),
-  rpcUrl: z9.string().optional(),
-  appId: z9.string(),
-  composeHash: z9.string(),
+  chain: z2.unknown().optional(),
+  rpcUrl: z2.string().optional(),
+  appId: z2.string(),
+  composeHash: z2.string(),
   // Authentication mode: either privateKey OR walletClient (required, mutually exclusive)
-  privateKey: z9.string().optional(),
-  walletClient: z9.unknown().optional(),
+  privateKey: z2.string().optional(),
+  walletClient: z2.unknown().optional(),
   // Public client (optional, will create default if not provided)
-  publicClient: z9.unknown().optional(),
+  publicClient: z2.unknown().optional(),
   // Validation configuration (optional)
-  skipPrerequisiteChecks: z9.boolean().optional().default(false),
-  minBalance: z9.string().optional(),
+  skipPrerequisiteChecks: z2.boolean().optional().default(false),
+  minBalance: z2.string().optional(),
   // ETH amount as string, e.g., "0.01"
   // Transaction control options
-  timeout: z9.number().optional().default(12e4),
-  retryOptions: z9.unknown().optional(),
-  signal: z9.unknown().optional(),
+  timeout: z2.number().optional().default(12e4),
+  retryOptions: z2.unknown().optional(),
+  signal: z2.unknown().optional(),
   // Progress callbacks
-  onTransactionStateChange: z9.function().optional(),
-  onTransactionSubmitted: z9.function().optional(),
-  onTransactionConfirmed: z9.function().optional()
+  onTransactionStateChange: z2.function().optional(),
+  onTransactionSubmitted: z2.function().optional(),
+  onTransactionConfirmed: z2.function().optional()
 }).passthrough().refine(
   (data) => {
     const hasPrivateKey = !!data.privateKey;
@@ -1783,12 +1118,12 @@ var AddComposeHashRequestSchema = z9.object({
     path: ["chain"]
   }
 );
-var AddComposeHashSchema = z9.object({
-  composeHash: z9.string(),
-  appId: z9.string(),
-  transactionHash: z9.string(),
-  blockNumber: z9.bigint().optional(),
-  gasUsed: z9.bigint().optional()
+var AddComposeHashSchema = z2.object({
+  composeHash: z2.string(),
+  appId: z2.string(),
+  transactionHash: z2.string(),
+  blockNumber: z2.bigint().optional(),
+  gasUsed: z2.bigint().optional()
 }).passthrough();
 function parseComposeHashResult(receipt, composeHash, appAuthAddress, appId) {
   console.log(receipt.logs);
@@ -1979,566 +1314,6 @@ async function safeAddComposeHash(request, parameters) {
   }
 }
 
-// src/actions/get_cvm_compose_file.ts
-import { z as z11 } from "zod";
-
-// src/types/app_compose.ts
-import { z as z10 } from "zod";
-var LooseAppComposeSchema = z10.object({
-  allowed_envs: z10.array(z10.string()).optional(),
-  docker_compose_file: z10.string(),
-  features: z10.array(z10.string()).optional(),
-  name: z10.string().optional(),
-  manifest_version: z10.number().optional(),
-  kms_enabled: z10.boolean().optional(),
-  public_logs: z10.boolean().optional(),
-  public_sysinfo: z10.boolean().optional(),
-  tproxy_enabled: z10.boolean().optional(),
-  pre_launch_script: z10.string().optional()
-}).passthrough();
-
-// src/actions/get_cvm_compose_file.ts
-var GetCvmComposeFileRequestSchema = z11.object({
-  id: z11.string().optional(),
-  uuid: z11.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: z11.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: z11.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()
-}).refine(
-  (data) => !!(data.id || data.uuid || data.app_id || data.instance_id),
-  "One of id, uuid, app_id, or instance_id must be provided"
-).transform((data) => ({
-  cvmId: data.id || data.uuid || data.app_id || data.instance_id,
-  _raw: data
-}));
-async function getCvmComposeFile(client, request, parameters) {
-  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);
-}
-
-// src/actions/provision_cvm_compose_file_update.ts
-import { z as z12 } from "zod";
-var ProvisionCvmComposeFileUpdateRequestSchema = z12.object({
-  id: z12.string().optional(),
-  uuid: z12.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: z12.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: z12.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: z12.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"
-).transform((data) => ({
-  cvmId: data.id || data.uuid || data.app_id || data.instance_id,
-  request: data.app_compose,
-  update_env_vars: data.update_env_vars,
-  _raw: data
-}));
-var ProvisionCvmComposeFileUpdateResultSchema = z12.object({
-  app_id: z12.string().nullable(),
-  device_id: z12.string().nullable(),
-  compose_hash: z12.string(),
-  kms_info: KmsInfoSchema.nullable().optional()
-}).passthrough();
-async function provisionCvmComposeFileUpdate(client, request, parameters) {
-  const validatedRequest = ProvisionCvmComposeFileUpdateRequestSchema.parse(request);
-  const response = 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
-import { z as z13 } from "zod";
-var CommitCvmComposeFileUpdateRequestSchema = z13.object({
-  id: z13.string().optional(),
-  uuid: z13.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: z13.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: z13.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: z13.string().min(1, "Compose hash is required"),
-  encrypted_env: z13.string().optional(),
-  env_keys: z13.array(z13.string()).optional(),
-  update_env_vars: z13.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"
-).transform((data) => ({
-  cvmId: data.id || data.uuid || data.app_id || data.instance_id,
-  compose_hash: data.compose_hash,
-  encrypted_env: data.encrypted_env,
-  env_keys: data.env_keys,
-  update_env_vars: !!data.update_env_vars,
-  _raw: data
-}));
-var CommitCvmComposeFileUpdateSchema = z13.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 };
-  }
-  const schema = parameters?.schema || CommitCvmComposeFileUpdateSchema;
-  return schema.safeParse(httpResult.data);
-}
-
-// src/actions/get_app_env_encrypt_pubkey.ts
-import { z as z14 } from "zod";
-var GetAppEnvEncryptPubKeyRequestSchema = z14.object({
-  kms: z14.string().min(1, "KMS ID or slug is required"),
-  app_id: z14.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 = z14.object({
-  public_key: z14.string(),
-  signature: z14.string()
-}).strict();
-var getAppEnvEncryptPubKey = async (client, payload, parameters) => {
-  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);
-};
-
-// src/actions/get_cvm_info.ts
-import { z as z15 } from "zod";
-var GetCvmInfoRequestSchema = z15.object({
-  id: z15.string().optional(),
-  uuid: z15.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: z15.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: z15.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()
-}).refine(
-  (data) => !!(data.id || data.uuid || data.app_id || data.instance_id),
-  "One of id, uuid, app_id, or instance_id must be provided"
-).transform((data) => ({
-  cvmId: data.id || data.uuid || data.app_id || data.instance_id,
-  _raw: data
-}));
-async function getCvmInfo(client, request, parameters) {
-  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;
-}
-
-// src/actions/get_cvm_list.ts
-import { z as z16 } from "zod";
-var GetCvmListRequestSchema = z16.object({
-  page: z16.number().int().min(1).optional(),
-  page_size: z16.number().int().min(1).optional(),
-  node_id: z16.number().int().min(1).optional()
-}).strict();
-var GetCvmListSchema = z16.object({
-  items: z16.array(CvmInfoSchema),
-  total: z16.number(),
-  page: z16.number(),
-  page_size: z16.number(),
-  pages: z16.number()
-}).strict();
-async function getCvmList(client, request, parameters) {
-  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;
-}
-
-// src/actions/get_kms_info.ts
-import { z as z17 } from "zod";
-var GetKmsInfoRequestSchema = z17.object({
-  kms_id: z17.string().min(1, "KMS ID is required")
-});
-async function getKmsInfo(client, request, parameters) {
-  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;
-}
-
-// src/actions/get_kms_list.ts
-import { z as z18 } from "zod";
-var GetKmsListRequestSchema = z18.object({
-  page: z18.number().int().min(1).optional(),
-  page_size: z18.number().int().min(1).optional(),
-  is_onchain: z18.boolean().optional()
-}).strict();
-var GetKmsListSchema = z18.object({
-  items: z18.array(KmsInfoSchema),
-  total: z18.number(),
-  page: z18.number(),
-  page_size: z18.number(),
-  pages: z18.number()
-}).strict();
-async function getKmsList(client, request, parameters) {
-  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;
-}
-
-// src/actions/workspaces/list_workspaces.ts
-import { z as z19 } from "zod";
-var WorkspaceResponseSchema = z19.object({
-  id: z19.string(),
-  name: z19.string(),
-  slug: z19.string().nullable(),
-  tier: z19.string(),
-  role: z19.string(),
-  created_at: z19.string()
-}).passthrough();
-var PaginationMetadataSchema = z19.object({
-  has_more: z19.boolean(),
-  next_cursor: z19.string().nullable(),
-  total: z19.number().nullable()
-}).passthrough();
-var ListWorkspacesSchema = z19.object({
-  data: z19.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;
-  }
-  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 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);
-}
-
-// 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);
-}
-
-// src/actions/list-instance-types.ts
-import { z as z20 } from "zod";
-var ListInstanceTypesRequestSchema = z20.object({
-  page: z20.number().int().min(1).optional().default(1),
-  page_size: z20.number().int().min(1).max(1e3).optional().default(100)
-}).strict();
-var InstanceTypeSchema = z20.object({
-  id: z20.string(),
-  name: z20.string(),
-  description: z20.string(),
-  vcpu: z20.number(),
-  memory_mb: z20.number(),
-  hourly_rate: z20.string(),
-  requires_gpu: z20.boolean(),
-  public: z20.boolean(),
-  enabled: z20.boolean()
-}).passthrough();
-var PaginatedInstanceTypesSchema = z20.object({
-  items: z20.array(InstanceTypeSchema),
-  total: z20.number(),
-  page: z20.number(),
-  page_size: z20.number(),
-  pages: z20.number()
-}).strict();
-async function listInstanceTypes(client, request, parameters) {
-  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;
-}
-
 // src/parse_dotenv.ts
 var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
 function parseEnv(input) {
@@ -2591,11 +1366,18 @@ export {
   CvmNodeSchema,
   DeployAppAuthRequestSchema,
   DeployAppAuthSchema,
+  GetAppEnvEncryptPubKeyRequestSchema,
   GetAppEnvEncryptPubKeySchema,
+  GetCvmComposeFileRequestSchema,
+  GetCvmInfoRequestSchema,
+  GetCvmListRequestSchema,
   GetCvmListSchema,
+  GetKmsInfoRequestSchema,
+  GetKmsListRequestSchema,
   GetKmsListSchema,
   InstanceTypeSchema,
   KmsInfoSchema,
+  ListInstanceTypesRequestSchema,
   ListWorkspacesSchema,
   ManagedUserSchema,
   NetworkError,
@@ -2624,6 +1406,8 @@ export {
   createClientsFromPrivateKey,
   createNetworkClients,
   createTransactionTracker,
+  defineAction,
+  defineSimpleAction,
   deployAppAuth,
   encryptEnvVars2 as encryptEnvVars,
   estimateTransactionGas,