@agentrun/sdk 0.0.3 → 0.0.4

package/dist/utils/index.js

@@ -0,0 +1,951 @@
+import * as dotenv from 'dotenv';
+import * as $AgentRun from '@alicloud/agentrun20250910';
+import * as $OpenApi from '@alicloud/openapi-client';
+import * as http from 'http';
+import * as https from 'https';
+import * as fs from 'fs';
+import * as nodePath from 'path';
+import { URL } from 'url';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+function getEnvWithDefault(defaultValue, ...keys) {
+  for (const key of keys) {
+    const value = process.env[key];
+    if (value !== void 0 && value !== "") {
+      return value;
+    }
+  }
+  return defaultValue;
+}
+var Config;
+var init_config = __esm({
+  "src/utils/config.ts"() {
+    dotenv.config();
+    Config = class _Config {
+      _accessKeyId;
+      _accessKeySecret;
+      _securityToken;
+      _accountId;
+      _token;
+      _regionId;
+      _timeout;
+      _readTimeout;
+      _controlEndpoint;
+      _dataEndpoint;
+      _devsEndpoint;
+      _headers;
+      constructor(options = {}) {
+        this._accessKeyId = options.accessKeyId ?? getEnvWithDefault("", "AGENTRUN_ACCESS_KEY_ID", "ALIBABA_CLOUD_ACCESS_KEY_ID");
+        this._accessKeySecret = options.accessKeySecret ?? getEnvWithDefault("", "AGENTRUN_ACCESS_KEY_SECRET", "ALIBABA_CLOUD_ACCESS_KEY_SECRET");
+        this._securityToken = options.securityToken ?? getEnvWithDefault("", "AGENTRUN_SECURITY_TOKEN", "ALIBABA_CLOUD_SECURITY_TOKEN");
+        this._accountId = options.accountId ?? getEnvWithDefault("", "AGENTRUN_ACCOUNT_ID", "FC_ACCOUNT_ID");
+        this._token = options.token;
+        this._regionId = options.regionId ?? getEnvWithDefault("cn-hangzhou", "AGENTRUN_REGION", "FC_REGION");
+        this._timeout = options.timeout ?? 6e5;
+        this._readTimeout = options.readTimeout ?? 1e8;
+        this._controlEndpoint = options.controlEndpoint ?? getEnvWithDefault("", "AGENTRUN_CONTROL_ENDPOINT");
+        this._dataEndpoint = options.dataEndpoint ?? getEnvWithDefault("", "AGENTRUN_DATA_ENDPOINT");
+        this._devsEndpoint = options.devsEndpoint ?? getEnvWithDefault("", "DEVS_ENDPOINT");
+        this._headers = options.headers ?? {};
+      }
+      /**
+       * Create a new Config by merging multiple configs.
+       * Later configs take precedence.
+       */
+      static withConfigs(...configs) {
+        return new _Config().update(...configs);
+      }
+      /**
+       * Update this config with values from other configs.
+       * Non-undefined values from later configs take precedence.
+       */
+      update(...configs) {
+        for (const config2 of configs) {
+          if (!config2) continue;
+          if (config2._accessKeyId) this._accessKeyId = config2._accessKeyId;
+          if (config2._accessKeySecret) this._accessKeySecret = config2._accessKeySecret;
+          if (config2._securityToken) this._securityToken = config2._securityToken;
+          if (config2._accountId) this._accountId = config2._accountId;
+          if (config2._token) this._token = config2._token;
+          if (config2._regionId) this._regionId = config2._regionId;
+          if (config2._timeout) this._timeout = config2._timeout;
+          if (config2._readTimeout) this._readTimeout = config2._readTimeout;
+          if (config2._controlEndpoint) this._controlEndpoint = config2._controlEndpoint;
+          if (config2._dataEndpoint) this._dataEndpoint = config2._dataEndpoint;
+          if (config2._devsEndpoint) this._devsEndpoint = config2._devsEndpoint;
+          if (config2._headers && Object.keys(config2._headers).length > 0) {
+            this._headers = { ...this._headers, ...config2._headers };
+          }
+        }
+        return this;
+      }
+      get accessKeyId() {
+        return this._accessKeyId;
+      }
+      get accessKeySecret() {
+        return this._accessKeySecret;
+      }
+      get securityToken() {
+        return this._securityToken;
+      }
+      get accountId() {
+        if (!this._accountId) {
+          throw new Error(
+            "Account ID is not set. Please add AGENTRUN_ACCOUNT_ID environment variable or set it in code."
+          );
+        }
+        return this._accountId;
+      }
+      get token() {
+        return this._token;
+      }
+      get regionId() {
+        return this._regionId || "cn-hangzhou";
+      }
+      get timeout() {
+        return this._timeout || 6e5;
+      }
+      get readTimeout() {
+        return this._readTimeout || 1e8;
+      }
+      get controlEndpoint() {
+        if (this._controlEndpoint) {
+          return this._controlEndpoint;
+        }
+        return `https://agentrun.${this.regionId}.aliyuncs.com`;
+      }
+      get dataEndpoint() {
+        if (this._dataEndpoint) {
+          return this._dataEndpoint;
+        }
+        return `https://${this.accountId}.agentrun-data.${this.regionId}.aliyuncs.com`;
+      }
+      get devsEndpoint() {
+        if (this._devsEndpoint) {
+          return this._devsEndpoint;
+        }
+        return `https://devs.${this.regionId}.aliyuncs.com`;
+      }
+      get headers() {
+        return this._headers;
+      }
+    };
+  }
+});
+
+// src/utils/control-api.ts
+var control_api_exports = {};
+__export(control_api_exports, {
+  $AgentRun: () => $AgentRun,
+  ControlAPI: () => ControlAPI
+});
+var $AgentRunClient, ControlAPI;
+var init_control_api = __esm({
+  "src/utils/control-api.ts"() {
+    init_config();
+    $AgentRunClient = // @ts-expect-error - ESM interop: default.default exists when imported as ESM namespace
+    $AgentRun.default?.default ?? $AgentRun.default ?? $AgentRun;
+    ControlAPI = class {
+      config;
+      constructor(config2) {
+        this.config = config2;
+      }
+      /**
+       * Get the underlying AgentRun client instance
+       */
+      getClient(config2) {
+        const cfg = Config.withConfigs(this.config, config2);
+        let endpoint = cfg.controlEndpoint;
+        if (endpoint.startsWith("http://") || endpoint.startsWith("https://")) {
+          endpoint = endpoint.split("://")[1];
+        }
+        const openApiConfig = new $OpenApi.Config({
+          accessKeyId: cfg.accessKeyId,
+          accessKeySecret: cfg.accessKeySecret,
+          securityToken: cfg.securityToken || void 0,
+          regionId: cfg.regionId,
+          endpoint,
+          connectTimeout: cfg.timeout,
+          readTimeout: cfg.readTimeout
+        });
+        return new $AgentRunClient(openApiConfig);
+      }
+    };
+  }
+});
+
+// src/utils/log.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var COLORS = {
+  reset: "\x1B[0m",
+  bright: "\x1B[1m",
+  dim: "\x1B[2m",
+  italic: "\x1B[3m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m"
+};
+var Logger = class {
+  level = "info";
+  // match Python logger name
+  prefix = "agentrun-logger";
+  setLevel(level) {
+    this.level = level;
+  }
+  shouldLog(level) {
+    return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
+  }
+  getColor(level) {
+    switch (level) {
+      case "debug":
+        return COLORS.cyan;
+      case "info":
+        return COLORS.blue;
+      case "warn":
+        return COLORS.yellow;
+      case "error":
+        return COLORS.red;
+      default:
+        return COLORS.reset;
+    }
+  }
+  // format timestamp like Python: YYYY-MM-DD HH:mm:ss,SSS
+  formatTimestamp(d = /* @__PURE__ */ new Date()) {
+    const pad = (n, sz = 2) => n.toString().padStart(sz, "0");
+    const year = d.getFullYear();
+    const month = pad(d.getMonth() + 1);
+    const day = pad(d.getDate());
+    const hour = pad(d.getHours());
+    const minute = pad(d.getMinutes());
+    const second = pad(d.getSeconds());
+    const ms = pad(d.getMilliseconds(), 3);
+    return `${year}-${month}-${day} ${hour}:${minute}:${second},${ms}`;
+  }
+  // attempt to infer caller file and line by parsing Error.stack
+  // helper: parse a single stack frame into {filepath, line, functionName}
+  parseFrame(frame) {
+    const m = frame.match(/^(?:at\s+)?(?:(.+?)\s+\()?(.*?):(\d+):(\d+)\)?$/);
+    if (!m) return null;
+    return {
+      functionName: m[1] ? m[1].trim() : void 0,
+      filepath: m[2],
+      line: parseInt(m[3], 10)
+    };
+  }
+  // get caller by fixed stack offset (used in public log methods)
+  getCallerByOffset() {
+    const err = new Error();
+    const stack = err.stack;
+    if (!stack) return {};
+    const lines = stack.split("\n").map((l) => l.trim());
+    for (let i = 3; i < lines.length; i++) {
+      let parsed = this.parseFrame(lines[i]);
+      if (!parsed) {
+        const m = lines[i].match(/(\/[^:\s]+:\d+:\d+)/);
+        if (m) {
+          const parts = m[1].split(":");
+          parts.pop();
+          const ln = Number(parts.pop());
+          const fp2 = parts.join(":");
+          parsed = { filepath: fp2, line: ln, functionName: void 0 };
+        }
+      }
+      if (!parsed) continue;
+      const fp = parsed.filepath;
+      if (fp.includes("node_modules") || fp.includes("internal") || fp.includes("<anonymous>") || fp.includes("native"))
+        continue;
+      return { filepath: parsed.filepath, line: parsed.line };
+    }
+    const cwd = process.cwd();
+    for (let i = 0; i < lines.length; i++) {
+      let parsed = this.parseFrame(lines[i]);
+      if (!parsed) {
+        const m = lines[i].match(/(\/[^:\s]+:\d+:\d+)/);
+        if (m) {
+          const parts = m[1].split(":");
+          parts.pop();
+          const ln = Number(parts.pop());
+          const fp2 = parts.join(":");
+          parsed = { filepath: fp2, line: ln, functionName: void 0 };
+        }
+      }
+      if (!parsed) continue;
+      const fp = parsed.filepath;
+      if (fp.includes("node_modules") || fp.includes("internal") || fp.includes("<anonymous>") || fp.includes("native"))
+        continue;
+      if (fp.includes("/src/utils/log.ts")) continue;
+      if (fp.startsWith(cwd)) return { filepath: parsed.filepath, line: parsed.line };
+    }
+    for (let i = 0; i < lines.length; i++) {
+      let parsed = this.parseFrame(lines[i]);
+      if (!parsed) {
+        const m = lines[i].match(/(\/[^:\s]+:\d+:\d+)/);
+        if (m) {
+          const parts = m[1].split(":");
+          parts.pop();
+          const ln = Number(parts.pop());
+          const fp2 = parts.join(":");
+          parsed = { filepath: fp2, line: ln, functionName: void 0 };
+        }
+      }
+      if (!parsed) continue;
+      const fp = parsed.filepath;
+      if (fp.includes("node_modules") || fp.includes("internal") || fp.includes("<anonymous>") || fp.includes("native"))
+        continue;
+      if (fp.includes("/src/utils/log.ts")) continue;
+      return { filepath: parsed.filepath, line: parsed.line };
+    }
+    return {};
+  }
+  formatMessage(level, message, filepath, line) {
+    const timestamp = this.formatTimestamp();
+    const color = this.getColor(level);
+    const reset = COLORS.reset;
+    const levelName = level === "warn" ? "WARNING" : level.toUpperCase();
+    const levelStr = `${COLORS.bright}${color}${levelName}${reset}`;
+    const nameStr = `${color}[${this.prefix}]${reset}`;
+    const tsStr = `${color} ${timestamp}${reset}`;
+    const pathInfo = filepath && line !== void 0 ? ` ${COLORS.dim}${COLORS.italic}${filepath}:${line}${reset}` : "";
+    const msg = level === "debug" ? `${COLORS.dim}${message}${reset}` : message;
+    return `
+${levelStr} ${nameStr}${tsStr}${pathInfo}
+${msg}
+`;
+  }
+  debug(message, ...args) {
+    if (this.shouldLog("debug")) {
+      const caller = this.getCallerByOffset();
+      console.debug(this.formatMessage("debug", message, caller.filepath, caller.line), ...args);
+    }
+  }
+  info(message, ...args) {
+    if (this.shouldLog("info")) {
+      const caller = this.getCallerByOffset();
+      console.info(this.formatMessage("info", message, caller.filepath, caller.line), ...args);
+    }
+  }
+  warn(message, ...args) {
+    if (this.shouldLog("warn")) {
+      const caller = this.getCallerByOffset();
+      console.warn(this.formatMessage("warn", message, caller.filepath, caller.line), ...args);
+    }
+  }
+  error(message, ...args) {
+    if (this.shouldLog("error")) {
+      const caller = this.getCallerByOffset();
+      console.error(this.formatMessage("error", message, caller.filepath, caller.line), ...args);
+    }
+  }
+};
+var logger = new Logger();
+if (![void 0, null, "", "False", "FALSE", "false", "0"].includes(process.env["AGENTRUN_SDK_DEBUG"])) {
+  logger.setLevel("debug");
+  if (!globalThis._AGENTRUN_DEBUG_LOGGED) {
+    logger.warn("\u542F\u7528 AgentRun SDK \u8C03\u8BD5\u65E5\u5FD7\uFF0C \u79FB\u9664 AGENTRUN_SDK_DEBUG \u73AF\u5883\u53D8\u91CF\u4EE5\u5173\u95ED");
+    globalThis._AGENTRUN_DEBUG_LOGGED = true;
+  }
+} else {
+  logger.setLevel("info");
+}
+
+// src/utils/version-check.ts
+var VERSION = "0.0.4" ;
+if (!process.env.DISABLE_BREAKING_CHANGES_WARNING && !globalThis._AGENTRUN_VERSION_WARNING_SHOWN) {
+  globalThis._AGENTRUN_VERSION_WARNING_SHOWN = true;
+  logger.warn(
+    `\u5F53\u524D\u60A8\u6B63\u5728\u4F7F\u7528 AgentRun Python SDK \u7248\u672C ${VERSION}\u3002\u65E9\u671F\u7248\u672C\u901A\u5E38\u5305\u542B\u8BB8\u591A\u65B0\u529F\u80FD\uFF0C\u8FD9\u4E9B\u529F\u80FD\x1B[1;33m \u53EF\u80FD\u5F15\u5165\u4E0D\u517C\u5BB9\u7684\u53D8\u66F4 \x1B[0m\u3002\u4E3A\u907F\u514D\u6F5C\u5728\u95EE\u9898\uFF0C\u6211\u4EEC\u5F3A\u70C8\u5EFA\u8BAE\x1B[1;32m \u5C06\u4F9D\u8D56\u9501\u5B9A\u4E3A\u6B64\u7248\u672C \x1B[0m\u3002
+You are currently using AgentRun Python SDK version ${VERSION}. Early versions often include many new features, which\x1B[1;33m may introduce breaking changes\x1B[0m. To avoid potential issues, we strongly recommend \x1B[1;32mpinning the dependency to this version\x1B[0m.
+\x1B[2;3m  pip install 'agentrun-sdk==${VERSION}' \x1B[0m
+
+\u589E\u52A0\x1B[2;3m DISABLE_BREAKING_CHANGES_WARNING=1 \x1B[0m\u5230\u60A8\u7684\u73AF\u5883\u53D8\u91CF\u4EE5\u5173\u95ED\u6B64\u8B66\u544A\u3002
+Add\x1B[2;3m DISABLE_BREAKING_CHANGES_WARNING=1 \x1B[0mto your environment variables to disable this warning.
+     
+Releases:\x1B[2;3m https://github.com/Serverless-Devs/agentrun-sdk-python/releases\x1B[0m`
+  );
+}
+
+// src/utils/index.ts
+init_config();
+
+// src/utils/data-api.ts
+init_config();
+
+// src/utils/exception.ts
+var AgentRunError = class _AgentRunError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AgentRunError";
+    Object.setPrototypeOf(this, _AgentRunError.prototype);
+  }
+};
+var HTTPError = class _HTTPError extends AgentRunError {
+  statusCode;
+  requestId;
+  errorCode;
+  constructor(statusCode, message, options) {
+    super(message);
+    this.name = "HTTPError";
+    this.statusCode = statusCode;
+    this.requestId = options?.requestId;
+    this.errorCode = options?.errorCode;
+    Object.setPrototypeOf(this, _HTTPError.prototype);
+  }
+  /**
+   * Convert HTTP error to resource-specific error based on status code
+   */
+  toResourceError(resourceType, resourceId) {
+    if (this.statusCode == 404) return new ResourceNotExistError(resourceType, resourceId);
+    else if (this.statusCode == 409) return new ResourceAlreadyExistError(resourceType, resourceId);
+    else if ((this.statusCode == 400 || this.statusCode == 500) && this.message.includes("already exists"))
+      return new ResourceAlreadyExistError(resourceType, resourceId);
+    else return this;
+  }
+};
+var ClientError = class _ClientError extends HTTPError {
+  constructor(statusCode, message, options) {
+    super(statusCode, message, options);
+    this.name = "ClientError";
+    Object.setPrototypeOf(this, _ClientError.prototype);
+  }
+};
+var ServerError = class _ServerError extends HTTPError {
+  constructor(statusCode, message, options) {
+    super(statusCode, message, options);
+    this.name = "ServerError";
+    Object.setPrototypeOf(this, _ServerError.prototype);
+  }
+};
+var ResourceNotExistError = class _ResourceNotExistError extends ClientError {
+  resourceType;
+  resourceId;
+  constructor(resourceType, resourceId, options) {
+    const message = resourceId ? `${resourceType} '${resourceId}' does not exist` : `${resourceType} does not exist`;
+    super(404, message, options);
+    this.name = "ResourceNotExistError";
+    this.resourceType = resourceType;
+    this.resourceId = resourceId;
+    Object.setPrototypeOf(this, _ResourceNotExistError.prototype);
+  }
+};
+var ResourceAlreadyExistError = class _ResourceAlreadyExistError extends ClientError {
+  resourceType;
+  resourceId;
+  constructor(resourceType, resourceId, options) {
+    const message = resourceId ? `${resourceType} '${resourceId}' already exists` : `${resourceType} already exists`;
+    super(409, message, options);
+    this.name = "ResourceAlreadyExistError";
+    this.resourceType = resourceType;
+    this.resourceId = resourceId;
+    Object.setPrototypeOf(this, _ResourceAlreadyExistError.prototype);
+  }
+};
+
+// src/utils/data-api.ts
+var ResourceType = /* @__PURE__ */ ((ResourceType2) => {
+  ResourceType2["Runtime"] = "runtime";
+  ResourceType2["LiteLLM"] = "litellm";
+  ResourceType2["Tool"] = "tool";
+  ResourceType2["Template"] = "template";
+  ResourceType2["Sandbox"] = "sandbox";
+  return ResourceType2;
+})(ResourceType || {});
+var DataAPI = class {
+  resourceName;
+  resourceType;
+  accessToken = null;
+  config;
+  namespace;
+  /**
+   * Initialize the Data API Client.
+   *
+   * @param resourceName - Resource name for access token
+   * @param resourceType - Resource type for access token
+   * @param config - Configuration options
+   * @param namespace - API namespace (default: "agents")
+   */
+  constructor(resourceName, resourceType, config2, namespace = "agents") {
+    this.resourceName = resourceName;
+    this.resourceType = resourceType;
+    this.config = Config.withConfigs(config2);
+    this.namespace = namespace;
+    const token = this.config.token;
+    if (token) {
+      logger.debug(`Using provided access token from config`);
+      this.accessToken = token;
+    }
+  }
+  /**
+   * Get the base URL for API requests.
+   */
+  getBaseUrl() {
+    return this.config.dataEndpoint;
+  }
+  /**
+   * Construct full URL with the given path and query parameters.
+   *
+   * @param path - API path (may include query string)
+   * @param query - Query parameters to add/merge
+   * @returns Complete URL string with query parameters
+   */
+  withPath(path, query) {
+    path = path.replace(/^\//, "");
+    const parts = [this.getBaseUrl(), this.namespace, path].filter(Boolean).map((part) => part.replace(/^\/|\/$/g, ""));
+    const baseUrl = parts.join("/");
+    if (!query || Object.keys(query).length === 0) {
+      return baseUrl;
+    }
+    const urlObj = new URL(baseUrl);
+    const existingParams = urlObj.searchParams;
+    for (const key in query) {
+      if (Object.prototype.hasOwnProperty.call(query, key)) {
+        const value = query[key];
+        if (Array.isArray(value)) {
+          value.forEach((v) => existingParams.append(key, String(v)));
+        } else if (value !== void 0 && value !== null) {
+          existingParams.set(key, String(value));
+        }
+      }
+    }
+    urlObj.search = existingParams.toString();
+    return urlObj.toString();
+  }
+  /**
+   * Authenticate and prepare headers for the request.
+   *
+   * @param url - Request URL
+   * @param headers - Request headers
+   * @param query - Query parameters
+   * @param config - Optional config override
+   * @returns Tuple of [url, headers, query]
+   */
+  async auth(url, headers, query, config2) {
+    const cfg = Config.withConfigs(this.config, config2);
+    if (this.accessToken === null && this.resourceName && this.resourceType && !cfg.token) {
+      try {
+        const { ControlAPI: ControlAPI2 } = await Promise.resolve().then(() => (init_control_api(), control_api_exports));
+        const $AgentRun2 = await import('@alicloud/agentrun20250910');
+        const cli = new ControlAPI2(this.config).getClient();
+        const input = this.resourceType === "sandbox" /* Sandbox */ ? new $AgentRun2.GetAccessTokenRequest({
+          resourceId: this.resourceName,
+          resourceType: this.resourceType
+        }) : new $AgentRun2.GetAccessTokenRequest({
+          resourceName: this.resourceName,
+          resourceType: this.resourceType
+        });
+        const resp = await cli.getAccessToken(input);
+        this.accessToken = resp.body?.data?.accessToken || null;
+        logger.debug(
+          `Fetched access token for resource ${this.resourceName} of type ${this.resourceType}`
+        );
+      } catch (e) {
+        logger.warn(
+          `Failed to get access token for ${this.resourceType}(${this.resourceName}): ${e}`
+        );
+      }
+    }
+    const authHeaders = {
+      "Agentrun-Access-Token": cfg.token || this.accessToken || "",
+      ...cfg.headers,
+      ...headers
+    };
+    return [url, authHeaders, query];
+  }
+  /**
+   * Prepare the HTTP request.
+   */
+  async prepareRequest(method, url, data, headers, query, config2) {
+    const reqHeaders = {
+      "Content-Type": "application/json",
+      "User-Agent": "AgentRunDataClient/1.0"
+    };
+    const cfg = Config.withConfigs(this.config, config2);
+    Object.assign(reqHeaders, cfg.headers);
+    if (headers) {
+      Object.assign(reqHeaders, headers);
+    }
+    const [authUrl, authHeaders, authQuery] = await this.auth(url, reqHeaders, query, cfg);
+    let finalUrl = authUrl;
+    if (authQuery && Object.keys(authQuery).length > 0) {
+      const urlObj = new URL(authUrl);
+      for (const key in authQuery) {
+        if (Object.prototype.hasOwnProperty.call(authQuery, key)) {
+          const value = authQuery[key];
+          if (value !== void 0 && value !== null) {
+            urlObj.searchParams.set(key, String(value));
+          }
+        }
+      }
+      finalUrl = urlObj.toString();
+    }
+    let body;
+    if (data !== void 0) {
+      if (Buffer.isBuffer(data)) {
+        body = data;
+      } else if (typeof data === "object") {
+        body = JSON.stringify(data);
+      } else {
+        body = data;
+      }
+    }
+    logger.debug(`${method} ${finalUrl} headers=${JSON.stringify(authHeaders)}`);
+    return { method, url: finalUrl, headers: authHeaders, body };
+  }
+  /**
+   * Make an HTTP request.
+   */
+  async makeRequest(method, path, data, query, headers, config2) {
+    const fullUrl = this.withPath(path, query);
+    const {
+      method: reqMethod,
+      url: reqUrl,
+      headers: reqHeaders,
+      body: reqBody
+    } = await this.prepareRequest(method, fullUrl, data, headers, void 0, config2);
+    const client = reqUrl.startsWith("https") ? https : http;
+    const urlObj = new URL(reqUrl);
+    const options = {
+      hostname: urlObj.hostname,
+      port: urlObj.port || (reqUrl.startsWith("https") ? 443 : 80),
+      path: urlObj.pathname + urlObj.search,
+      method: reqMethod,
+      headers: reqHeaders,
+      timeout: this.config.timeout
+    };
+    return new Promise((resolve, reject) => {
+      const req = client.request(options, (res) => {
+        let responseData = "";
+        res.on("data", (chunk) => responseData += chunk);
+        res.on("end", () => {
+          logger.debug(`Response: ${responseData}`);
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            try {
+              resolve(responseData ? JSON.parse(responseData) : {});
+            } catch (e) {
+              const errorMsg = `Failed to parse JSON response: ${e}`;
+              logger.error(errorMsg);
+              reject(new ClientError(res.statusCode || 0, errorMsg));
+            }
+          } else {
+            const errorMsg = responseData || res.statusMessage || "Unknown error";
+            reject(new ClientError(res.statusCode || 0, errorMsg));
+          }
+        });
+      });
+      req.on("error", (e) => {
+        reject(new ClientError(0, `Request error: ${e.message}`));
+      });
+      req.on("timeout", () => {
+        req.destroy();
+        reject(new ClientError(0, "Request timeout"));
+      });
+      if (reqBody) {
+        req.write(reqBody);
+      }
+      req.end();
+    });
+  }
+  /**
+   * Make a GET request.
+   *
+   * @param path - API path
+   * @param query - Query parameters
+   * @param headers - Additional headers
+   * @param config - Optional config override
+   */
+  async get(path, query, headers, config2) {
+    return this.makeRequest("GET", path, void 0, query, headers, config2);
+  }
+  /**
+   * Make a POST request.
+   *
+   * @param path - API path
+   * @param data - Request body
+   * @param query - Query parameters
+   * @param headers - Additional headers
+   * @param config - Optional config override
+   */
+  async post(path, data, query, headers, config2) {
+    return this.makeRequest("POST", path, data, query, headers, config2);
+  }
+  /**
+   * Make a PUT request.
+   *
+   * @param path - API path
+   * @param data - Request body
+   * @param query - Query parameters
+   * @param headers - Additional headers
+   * @param config - Optional config override
+   */
+  async put(path, data, query, headers, config2) {
+    return this.makeRequest("PUT", path, data, query, headers, config2);
+  }
+  /**
+   * Make a PATCH request.
+   *
+   * @param path - API path
+   * @param data - Request body
+   * @param query - Query parameters
+   * @param headers - Additional headers
+   * @param config - Optional config override
+   */
+  async patch(path, data, query, headers, config2) {
+    return this.makeRequest("PATCH", path, data, query, headers, config2);
+  }
+  /**
+   * Make a DELETE request.
+   *
+   * @param path - API path
+   * @param query - Query parameters
+   * @param headers - Additional headers
+   * @param config - Optional config override
+   */
+  async delete(path, query, headers, config2) {
+    return this.makeRequest("DELETE", path, void 0, query, headers, config2);
+  }
+  /**
+   * Upload a file using multipart/form-data.
+   *
+   * @param path - API path
+   * @param localFilePath - Local file path to upload
+   * @param targetFilePath - Target file path on the server
+   * @param formData - Additional form data fields
+   * @param query - Query parameters
+   * @param headers - Additional headers
+   * @param config - Optional config override
+   */
+  async postFile(path, localFilePath, targetFilePath, formData, query, headers, config2) {
+    const fullUrl = this.withPath(path, query);
+    const { url: reqUrl, headers: reqHeaders } = await this.prepareRequest(
+      "POST",
+      fullUrl,
+      void 0,
+      headers,
+      void 0,
+      config2
+    );
+    const client = reqUrl.startsWith("https") ? https : http;
+    const urlObj = new URL(reqUrl);
+    return new Promise((resolve, reject) => {
+      const boundary = `----WebKitFormBoundary${Math.random().toString(36).substring(2)}`;
+      const contentHeaders = {
+        ...reqHeaders,
+        "Content-Type": `multipart/form-data; boundary=${boundary}`
+      };
+      const options = {
+        hostname: urlObj.hostname,
+        port: urlObj.port || (reqUrl.startsWith("https") ? 443 : 80),
+        path: urlObj.pathname + urlObj.search,
+        method: "POST",
+        headers: contentHeaders,
+        timeout: this.config.timeout
+      };
+      const req = client.request(options, (res) => {
+        let responseData = "";
+        res.on("data", (chunk) => responseData += chunk);
+        res.on("end", () => {
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            try {
+              resolve(responseData ? JSON.parse(responseData) : {});
+            } catch (e) {
+              logger.error(`Failed to parse JSON response: ${e}`);
+              reject(new ClientError(res.statusCode || 0, `Failed to parse JSON: ${e}`));
+            }
+          } else {
+            reject(new ClientError(res.statusCode || 0, responseData || "Unknown error"));
+          }
+        });
+      });
+      req.on("error", (e) => {
+        reject(new ClientError(0, `Request error: ${e.message}`));
+      });
+      const appendField = (name, value) => {
+        req.write(`--${boundary}\r
+`);
+        req.write(`Content-Disposition: form-data; name="${name}"\r
+`);
+        req.write("\r\n");
+        req.write(`${value}\r
+`);
+      };
+      if (formData) {
+        for (const key in formData) {
+          if (Object.prototype.hasOwnProperty.call(formData, key)) {
+            appendField(key, formData[key]);
+          }
+        }
+      }
+      appendField("path", targetFilePath);
+      const filename = nodePath.basename(localFilePath);
+      req.write(`--${boundary}\r
+`);
+      req.write(`Content-Disposition: form-data; name="file"; filename="${filename}"\r
+`);
+      req.write("Content-Type: application/octet-stream\r\n");
+      req.write("\r\n");
+      const fileStream = fs.createReadStream(localFilePath);
+      fileStream.pipe(req, { end: false });
+      fileStream.on("end", () => {
+        req.write(`\r
+--${boundary}--\r
+`);
+        req.end();
+      });
+      fileStream.on("error", (e) => {
+        reject(new ClientError(0, `File stream error: ${e.message}`));
+      });
+    });
+  }
+  /**
+   * Download a file and save it to local path.
+   *
+   * @param path - API path
+   * @param savePath - Local file path to save the downloaded file
+   * @param query - Query parameters
+   * @param headers - Additional headers
+   * @param config - Optional config override
+   */
+  async getFile(path, savePath, query, headers, config2) {
+    const fullUrl = this.withPath(path, query);
+    const { url: reqUrl, headers: reqHeaders } = await this.prepareRequest(
+      "GET",
+      fullUrl,
+      void 0,
+      headers,
+      void 0,
+      config2
+    );
+    const client = reqUrl.startsWith("https") ? https : http;
+    const urlObj = new URL(reqUrl);
+    return new Promise((resolve, reject) => {
+      const options = {
+        hostname: urlObj.hostname,
+        port: urlObj.port || (reqUrl.startsWith("https") ? 443 : 80),
+        path: urlObj.pathname + urlObj.search,
+        method: "GET",
+        headers: reqHeaders,
+        timeout: this.config.timeout
+      };
+      const req = client.request(options, (res) => {
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+          const fileStream = fs.createWriteStream(savePath);
+          let downloadedSize = 0;
+          res.on("data", (chunk) => {
+            fileStream.write(chunk);
+            downloadedSize += chunk.length;
+          });
+          res.on("end", () => {
+            fileStream.end();
+            resolve({ savedPath: savePath, size: downloadedSize });
+          });
+          res.on("error", (e) => {
+            fileStream.end();
+            reject(new ClientError(0, `Response error: ${e.message}`));
+          });
+        } else {
+          let errorData = "";
+          res.on("data", (chunk) => errorData += chunk);
+          res.on("end", () => {
+            reject(new ClientError(res.statusCode || 0, errorData || "Download failed"));
+          });
+        }
+      });
+      req.on("error", (e) => {
+        reject(new ClientError(0, `Request error: ${e.message}`));
+      });
+      req.end();
+    });
+  }
+  /**
+   * Download a video file and save it to local path.
+   *
+   * @param path - API path
+   * @param savePath - Local file path to save the downloaded video
+   * @param query - Query parameters
+   * @param headers - Additional headers
+   * @param config - Optional config override
+   */
+  async getVideo(path, savePath, query, headers, config2) {
+    return this.getFile(path, savePath, query, headers, config2);
+  }
+};
+
+// src/utils/model.ts
+var Status = {
+  CREATING: "CREATING",
+  CREATE_FAILED: "CREATE_FAILED",
+  READY: "READY",
+  UPDATING: "UPDATING",
+  UPDATE_FAILED: "UPDATE_FAILED",
+  DELETING: "DELETING",
+  DELETE_FAILED: "DELETE_FAILED"
+};
+var NetworkMode = {
+  PUBLIC: "PUBLIC",
+  PRIVATE: "PRIVATE",
+  PUBLIC_AND_PRIVATE: "PUBLIC_AND_PRIVATE"
+};
+function toSnakeCase(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function toCamelCase(str) {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function toSnakeCaseKeys(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const snakeKey = toSnakeCase(key);
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      result[snakeKey] = toSnakeCaseKeys(value);
+    } else if (Array.isArray(value)) {
+      result[snakeKey] = value.map(
+        (item) => typeof item === "object" && item !== null ? toSnakeCaseKeys(item) : item
+      );
+    } else {
+      result[snakeKey] = value;
+    }
+  }
+  return result;
+}
+function toCamelCaseKeys(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const camelKey = toCamelCase(key);
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      result[camelKey] = toCamelCaseKeys(value);
+    } else if (Array.isArray(value)) {
+      result[camelKey] = value.map(
+        (item) => typeof item === "object" && item !== null ? toCamelCaseKeys(item) : item
+      );
+    } else {
+      result[camelKey] = value;
+    }
+  }
+  return result;
+}
+function removeUndefined(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+export { AgentRunError, ClientError, Config, DataAPI, HTTPError, NetworkMode, ResourceAlreadyExistError, ResourceNotExistError, ResourceType, ServerError, Status, logger, removeUndefined, toCamelCase, toCamelCaseKeys, toSnakeCase, toSnakeCaseKeys };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map