@agentrun/sdk 0.0.3 → 0.0.4

package/dist/agent-runtime/index.js

@@ -0,0 +1,2496 @@
+import * as dotenv from 'dotenv';
+import * as $AgentRun3 from '@alicloud/agentrun20250910';
+import * as $OpenApi from '@alicloud/openapi-client';
+import * as $Util from '@alicloud/tea-util';
+import * as http from 'http';
+import * as https from 'https';
+import * as fs2 from 'fs';
+import * as path from 'path';
+import { URL } from 'url';
+import * as crc64Lib from 'crc64-ecma182.js';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/log.ts
+var LOG_LEVELS, COLORS, Logger, logger;
+var init_log = __esm({
+  "src/utils/log.ts"() {
+    LOG_LEVELS = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3
+    };
+    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"
+    };
+    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);
+        }
+      }
+    };
+    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");
+    }
+  }
+});
+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/exception.ts
+var AgentRunError, HTTPError, ClientError, ServerError, ResourceNotExistError, ResourceAlreadyExistError;
+var init_exception = __esm({
+  "src/utils/exception.ts"() {
+    AgentRunError = class _AgentRunError extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "AgentRunError";
+        Object.setPrototypeOf(this, _AgentRunError.prototype);
+      }
+    };
+    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;
+      }
+    };
+    ClientError = class _ClientError extends HTTPError {
+      constructor(statusCode, message, options) {
+        super(statusCode, message, options);
+        this.name = "ClientError";
+        Object.setPrototypeOf(this, _ClientError.prototype);
+      }
+    };
+    ServerError = class _ServerError extends HTTPError {
+      constructor(statusCode, message, options) {
+        super(statusCode, message, options);
+        this.name = "ServerError";
+        Object.setPrototypeOf(this, _ServerError.prototype);
+      }
+    };
+    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);
+      }
+    };
+    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/model.ts
+function isFinalStatus(status) {
+  return [
+    void 0,
+    null,
+    "",
+    ...["READY", "CREATE_FAILED", "UPDATE_FAILED", "DELETE_FAILED"]
+  ].includes(status);
+}
+var Status, NetworkMode;
+var init_model = __esm({
+  "src/utils/model.ts"() {
+    Status = {
+      CREATING: "CREATING",
+      CREATE_FAILED: "CREATE_FAILED",
+      READY: "READY",
+      UPDATING: "UPDATING",
+      UPDATE_FAILED: "UPDATE_FAILED",
+      DELETING: "DELETING",
+      DELETE_FAILED: "DELETE_FAILED"
+    };
+    NetworkMode = {
+      PUBLIC: "PUBLIC",
+      PRIVATE: "PRIVATE",
+      PUBLIC_AND_PRIVATE: "PUBLIC_AND_PRIVATE"
+    };
+  }
+});
+
+// src/utils/control-api.ts
+var control_api_exports = {};
+__export(control_api_exports, {
+  $AgentRun: () => $AgentRun3,
+  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
+    $AgentRun3.default?.default ?? $AgentRun3.default ?? $AgentRun3;
+    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);
+      }
+    };
+  }
+});
+var AgentRuntimeControlAPI;
+var init_control = __esm({
+  "src/agent-runtime/api/control.ts"() {
+    init_control_api();
+    init_exception();
+    init_log();
+    AgentRuntimeControlAPI = class extends ControlAPI {
+      constructor(config2) {
+        super(config2);
+      }
+      /**
+       * Create Agent Runtime
+       *
+       * @param params - Method parameters
+       * @param params.input - Agent Runtime configuration
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Created Runtime object
+       */
+      createAgentRuntime = async (params) => {
+        const { input, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.createAgentRuntimeWithOptions(
+            new $AgentRun3.CreateAgentRuntimeRequest({ body: input }),
+            headers ?? {},
+            runtime
+          );
+          logger.debug(
+            `request api createAgentRuntime, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([input])}
+  response: ${JSON.stringify(response.body?.data)}`
+          );
+          return response.body?.data;
+        } catch (error) {
+          if (error && typeof error === "object" && "statusCode" in error) {
+            const e = error;
+            const statusCode = e.statusCode;
+            const message = e.message || "Unknown error";
+            const requestId = e.data?.requestId;
+            if (statusCode >= 400 && statusCode < 500) {
+              throw new ClientError(statusCode, message, { requestId });
+            } else if (statusCode >= 500) {
+              throw new ServerError(statusCode, message, { requestId });
+            }
+          }
+          throw error;
+        }
+      };
+      /**
+       * Delete Agent Runtime
+       *
+       * @param params - Method parameters
+       * @param params.agentId - Agent Runtime ID
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Deleted Runtime object
+       */
+      deleteAgentRuntime = async (params) => {
+        const { agentId, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.deleteAgentRuntimeWithOptions(agentId, headers ?? {}, runtime);
+          logger.debug(
+            `request api deleteAgentRuntime, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([agentId])}
+  response: ${JSON.stringify(response.body?.data)}`
+          );
+          return response.body?.data;
+        } catch (error) {
+          if (error && typeof error === "object" && "statusCode" in error) {
+            const e = error;
+            const statusCode = e.statusCode;
+            const message = e.message || "Unknown error";
+            const requestId = e.data?.requestId;
+            if (statusCode >= 400 && statusCode < 500) {
+              throw new ClientError(statusCode, message, { requestId });
+            } else if (statusCode >= 500) {
+              throw new ServerError(statusCode, message, { requestId });
+            }
+          }
+          throw error;
+        }
+      };
+      /**
+       * Update Agent Runtime
+       *
+       * @param params - Method parameters
+       * @param params.agentId - Agent Runtime ID
+       * @param params.input - Agent Runtime configuration
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Updated Runtime object
+       */
+      updateAgentRuntime = async (params) => {
+        const { agentId, input, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.updateAgentRuntimeWithOptions(
+            agentId,
+            new $AgentRun3.UpdateAgentRuntimeRequest({ body: input }),
+            headers ?? {},
+            runtime
+          );
+          logger.debug(
+            `request api updateAgentRuntime, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([agentId, input])}
+  response: ${JSON.stringify(response.body?.data)}`
+          );
+          return response.body?.data;
+        } catch (error) {
+          if (error && typeof error === "object" && "statusCode" in error) {
+            const e = error;
+            const statusCode = e.statusCode;
+            const message = e.message || "Unknown error";
+            const requestId = e.data?.requestId;
+            if (statusCode >= 400 && statusCode < 500) {
+              throw new ClientError(statusCode, message, { requestId });
+            } else if (statusCode >= 500) {
+              throw new ServerError(statusCode, message, { requestId });
+            }
+          }
+          throw error;
+        }
+      };
+      /**
+       * Get Agent Runtime
+       *
+       * @param params - Method parameters
+       * @param params.agentId - Agent Runtime ID
+       * @param params.request - Get request options
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Runtime object
+       */
+      getAgentRuntime = async (params) => {
+        const { agentId, request, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.getAgentRuntimeWithOptions(
+            agentId,
+            request ?? new $AgentRun3.GetAgentRuntimeRequest({}),
+            headers ?? {},
+            runtime
+          );
+          logger.debug(
+            `request api getAgentRuntime, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([agentId, request])}
+  response: ${JSON.stringify(response.body?.data)}`
+          );
+          return response.body?.data;
+        } catch (error) {
+          if (error && typeof error === "object" && "statusCode" in error) {
+            const e = error;
+            const statusCode = e.statusCode;
+            const message = e.message || "Unknown error";
+            const requestId = e.data?.requestId;
+            if (statusCode >= 400 && statusCode < 500) {
+              throw new ClientError(statusCode, message, { requestId });
+            } else if (statusCode >= 500) {
+              throw new ServerError(statusCode, message, { requestId });
+            }
+          }
+          throw error;
+        }
+      };
+      /**
+       * List Agent Runtimes
+       *
+       * @param params - Method parameters
+       * @param params.input - List options
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns List of Runtime objects
+       */
+      listAgentRuntimes = async (params) => {
+        const { input, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.listAgentRuntimesWithOptions(input, headers ?? {}, runtime);
+          logger.debug(
+            `request api listAgentRuntimes, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([input])}
+  response: ${JSON.stringify(response.body?.data)}`
+          );
+          return response.body?.data;
+        } catch (error) {
+          if (error && typeof error === "object" && "statusCode" in error) {
+            const e = error;
+            const statusCode = e.statusCode;
+            const message = e.message || "Unknown error";
+            const requestId = e.data?.requestId;
+            if (statusCode >= 400 && statusCode < 500) {
+              throw new ClientError(statusCode, message, { requestId });
+            } else if (statusCode >= 500) {
+              throw new ServerError(statusCode, message, { requestId });
+            }
+          }
+          throw error;
+        }
+      };
+      /**
+       * Create Agent Runtime Endpoint
+       *
+       * @param params - Method parameters
+       * @param params.agentId - Agent Runtime ID
+       * @param params.input - Endpoint configuration
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Created Endpoint object
+       */
+      createAgentRuntimeEndpoint = async (params) => {
+        const { agentId, input, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.createAgentRuntimeEndpointWithOptions(
+            agentId,
+            new $AgentRun3.CreateAgentRuntimeEndpointRequest({ body: input }),
+            headers ?? {},
+            runtime
+          );
+          logger.debug(
+            `request api createAgentRuntimeEndpoint, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([agentId, input])}
+  response: ${JSON.stringify(response.body?.data)}`
+          );
+          return response.body?.data;
+        } catch (error) {
+          if (error && typeof error === "object" && "statusCode" in error) {
+            const e = error;
+            const statusCode = e.statusCode;
+            const message = e.message || "Unknown error";
+            const requestId = e.data?.requestId;
+            if (statusCode >= 400 && statusCode < 500) {
+              throw new ClientError(statusCode, message, { requestId });
+            } else if (statusCode >= 500) {
+              throw new ServerError(statusCode, message, { requestId });
+            }
+          }
+          throw error;
+        }
+      };
+      /**
+       * Delete Agent Runtime Endpoint
+       *
+       * @param params - Method parameters
+       * @param params.agentId - Agent Runtime ID
+       * @param params.endpointId - Endpoint ID
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Deleted Endpoint object
+       */
+      deleteAgentRuntimeEndpoint = async (params) => {
+        const { agentId, endpointId, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.deleteAgentRuntimeEndpointWithOptions(
+            agentId,
+            endpointId,
+            headers ?? {},
+            runtime
+          );
+          logger.debug(
+            `request api deleteAgentRuntimeEndpoint, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([agentId, endpointId])}
+  response: ${JSON.stringify(response.body?.data)}`
+          );
+          return response.body?.data;
+        } catch (error) {
+          if (error && typeof error === "object" && "statusCode" in error) {
+            const e = error;
+            const statusCode = e.statusCode;
+            const message = e.message || "Unknown error";
+            const requestId = e.data?.requestId;
+            if (statusCode >= 400 && statusCode < 500) {
+              throw new ClientError(statusCode, message, { requestId });
+            } else if (statusCode >= 500) {
+              throw new ServerError(statusCode, message, { requestId });
+            }
+          }
+          throw error;
+        }
+      };
+      /**
+       * Update Agent Runtime Endpoint
+       *
+       * @param params - Method parameters
+       * @param params.agentId - Agent Runtime ID
+       * @param params.endpointId - Endpoint ID
+       * @param params.input - Endpoint configuration
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Updated Endpoint object
+       */
+      updateAgentRuntimeEndpoint = async (params) => {
+        const { agentId, endpointId, input, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.updateAgentRuntimeEndpointWithOptions(
+            agentId,
+            endpointId,
+            new $AgentRun3.UpdateAgentRuntimeEndpointRequest({ body: input }),
+            headers ?? {},
+            runtime
+          );
+          logger.debug(
+            `request api updateAgentRuntimeEndpoint, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([agentId, endpointId, input])}
+  response: ${JSON.stringify(response.body?.data)}`
+          );
+          return response.body?.data;
+        } catch (error) {
+          if (error && typeof error === "object" && "statusCode" in error) {
+            const e = error;
+            const statusCode = e.statusCode;
+            const message = e.message || "Unknown error";
+            const requestId = e.data?.requestId;
+            if (statusCode >= 400 && statusCode < 500) {
+              throw new ClientError(statusCode, message, { requestId });
+            } else if (statusCode >= 500) {
+              throw new ServerError(statusCode, message, { requestId });
+            }
+          }
+          throw error;
+        }
+      };
+      /**
+       * Get Agent Runtime Endpoint
+       *
+       * @param params - Method parameters
+       * @param params.agentId - Agent Runtime ID
+       * @param params.endpointId - Endpoint ID
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Endpoint object
+       */
+      getAgentRuntimeEndpoint = async (params) => {
+        const { agentId, endpointId, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.getAgentRuntimeEndpointWithOptions(
+            agentId,
+            endpointId,
+            headers ?? {},
+            runtime
+          );
+          logger.debug(
+            `request api getAgentRuntimeEndpoint, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([agentId, endpointId])}
+  response: ${JSON.stringify(response.body?.data)}`
+          );
+          return response.body?.data;
+        } catch (error) {
+          if (error && typeof error === "object" && "statusCode" in error) {
+            const e = error;
+            const statusCode = e.statusCode;
+            const message = e.message || "Unknown error";
+            const requestId = e.data?.requestId;
+            if (statusCode >= 400 && statusCode < 500) {
+              throw new ClientError(statusCode, message, { requestId });
+            } else if (statusCode >= 500) {
+              throw new ServerError(statusCode, message, { requestId });
+            }
+          }
+          throw error;
+        }
+      };
+      /**
+       * List Agent Runtime Endpoints
+       *
+       * @param params - Method parameters
+       * @param params.agentId - Agent Runtime ID
+       * @param params.input - List options
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns List of Endpoint objects
+       */
+      listAgentRuntimeEndpoints = async (params) => {
+        const { agentId, input, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.listAgentRuntimeEndpointsWithOptions(
+            agentId,
+            input,
+            headers ?? {},
+            runtime
+          );
+          logger.debug(
+            `request api listAgentRuntimeEndpoints, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([agentId, input])}
+  response: ${JSON.stringify(response.body?.data)}`
+          );
+          return response.body?.data;
+        } catch (error) {
+          if (error && typeof error === "object" && "statusCode" in error) {
+            const e = error;
+            const statusCode = e.statusCode;
+            const message = e.message || "Unknown error";
+            const requestId = e.data?.requestId;
+            if (statusCode >= 400 && statusCode < 500) {
+              throw new ClientError(statusCode, message, { requestId });
+            } else if (statusCode >= 500) {
+              throw new ServerError(statusCode, message, { requestId });
+            }
+          }
+          throw error;
+        }
+      };
+      /**
+       * List Agent Runtime Versions
+       *
+       * @param params - Method parameters
+       * @param params.agentId - Agent Runtime ID
+       * @param params.input - List options
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns List of Version objects
+       */
+      listAgentRuntimeVersions = async (params) => {
+        const { agentId, input, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.listAgentRuntimeVersionsWithOptions(
+            agentId,
+            input,
+            headers ?? {},
+            runtime
+          );
+          logger.debug(
+            `request api listAgentRuntimeVersions, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([agentId, input])}
+  response: ${JSON.stringify(response.body?.data)}`
+          );
+          return response.body?.data;
+        } catch (error) {
+          if (error && typeof error === "object" && "statusCode" in error) {
+            const e = error;
+            const statusCode = e.statusCode;
+            const message = e.message || "Unknown error";
+            const requestId = e.data?.requestId;
+            if (statusCode >= 400 && statusCode < 500) {
+              throw new ClientError(statusCode, message, { requestId });
+            } else if (statusCode >= 500) {
+              throw new ServerError(statusCode, message, { requestId });
+            }
+          }
+          throw error;
+        }
+      };
+    };
+  }
+});
+var DataAPI;
+var init_data_api = __esm({
+  "src/utils/data-api.ts"() {
+    init_config();
+    init_exception();
+    init_log();
+    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(path2, query) {
+        path2 = path2.replace(/^\//, "");
+        const parts = [this.getBaseUrl(), this.namespace, path2].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 $AgentRun4 = await import('@alicloud/agentrun20250910');
+            const cli = new ControlAPI2(this.config).getClient();
+            const input = this.resourceType === "sandbox" /* Sandbox */ ? new $AgentRun4.GetAccessTokenRequest({
+              resourceId: this.resourceName,
+              resourceType: this.resourceType
+            }) : new $AgentRun4.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, path2, data, query, headers, config2) {
+        const fullUrl = this.withPath(path2, 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(path2, query, headers, config2) {
+        return this.makeRequest("GET", path2, 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(path2, data, query, headers, config2) {
+        return this.makeRequest("POST", path2, 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(path2, data, query, headers, config2) {
+        return this.makeRequest("PUT", path2, 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(path2, data, query, headers, config2) {
+        return this.makeRequest("PATCH", path2, 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(path2, query, headers, config2) {
+        return this.makeRequest("DELETE", path2, 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(path2, localFilePath, targetFilePath, formData, query, headers, config2) {
+        const fullUrl = this.withPath(path2, 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 = path.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 = fs2.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(path2, savePath, query, headers, config2) {
+        const fullUrl = this.withPath(path2, 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 = fs2.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(path2, savePath, query, headers, config2) {
+        return this.getFile(path2, savePath, query, headers, config2);
+      }
+    };
+  }
+});
+
+// src/agent-runtime/api/data.ts
+var AgentRuntimeDataAPI;
+var init_data = __esm({
+  "src/agent-runtime/api/data.ts"() {
+    init_config();
+    init_data_api();
+    AgentRuntimeDataAPI = class extends DataAPI {
+      constructor(agentRuntimeName, agentRuntimeEndpointName = "Default", config2) {
+        super(
+          agentRuntimeName,
+          "runtime" /* Runtime */,
+          config2,
+          `agent-runtimes/${agentRuntimeName}/endpoints/${agentRuntimeEndpointName}/invocations`
+        );
+      }
+      /**
+       * Invoke agent runtime using OpenAI-compatible API
+       */
+      async invokeOpenai(args) {
+        const { messages, stream = false, config: config2 } = args;
+        const cfg = Config.withConfigs(this.getConfig(), config2);
+        const apiBase = this.withPath("openai/v1");
+        const [, headers] = await this.getAuthHeaders(apiBase, {}, cfg);
+        const { default: OpenAI } = await import('openai');
+        const client = new OpenAI({
+          apiKey: "",
+          // Empty API key, we use custom headers for auth
+          baseURL: apiBase,
+          defaultHeaders: headers,
+          timeout: cfg.timeout
+        });
+        return client.chat.completions.create({
+          model: this.getResourceName(),
+          messages,
+          stream
+        });
+      }
+      // Expose protected methods for use in this subclass
+      getConfig() {
+        return this.config;
+      }
+      getResourceName() {
+        return this.resourceName;
+      }
+      async getAuthHeaders(url, headers, config2) {
+        const [authUrl, authHeaders] = await this.auth(url, headers, void 0, config2);
+        return [authUrl, authHeaders];
+      }
+    };
+  }
+});
+
+// src/utils/resource.ts
+function updateObjectProperties(target, source) {
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key) && typeof source[key] !== "function" && !key.startsWith("_")) {
+      target[key] = source[key];
+    }
+  }
+}
+function listAllResourcesFunction(list) {
+  return async (params) => {
+    const { config: config2, ...restParams } = params ?? {};
+    const allResults = [];
+    let page = 1;
+    const pageSize = 50;
+    while (true) {
+      const pageResults = await list({
+        input: {
+          ...restParams,
+          pageNumber: page,
+          pageSize
+        },
+        config: config2
+      });
+      page += 1;
+      allResults.push(...pageResults);
+      if (pageResults.length < pageSize) break;
+    }
+    const resultSet = /* @__PURE__ */ new Set();
+    const results = [];
+    for (const item of allResults) {
+      const uniqId = item.uniqIdCallback() || "";
+      if (!resultSet.has(uniqId) && uniqId) {
+        resultSet.add(uniqId);
+        results.push(item);
+      }
+    }
+    return results;
+  };
+}
+var ResourceBase;
+var init_resource = __esm({
+  "src/utils/resource.ts"() {
+    init_exception();
+    init_log();
+    init_model();
+    ResourceBase = class {
+      status;
+      _config;
+      // static async list(params?: {
+      //   input?: PageableInput;
+      //   config?: Config;
+      // }): Promise<WithUniqIdCallback[]> {
+      //   return [];
+      // }
+      waitUntil = async (params) => {
+        const { checkFinishedCallback, intervalSeconds = 5, timeoutSeconds = 300 } = params;
+        const startTime = Date.now();
+        while (true) {
+          if (await checkFinishedCallback(this)) return this;
+          if (Date.now() - startTime >= timeoutSeconds * 1e3) {
+            throw new Error("Timeout waiting for resource to reach desired state");
+          }
+          await new Promise((resolve) => setTimeout(resolve, intervalSeconds * 1e3));
+        }
+      };
+      waitUntilReadyOrFailed = async (params) => {
+        const { callback, intervalSeconds = 5, timeoutSeconds = 300 } = params ?? {};
+        async function checkFinishedCallback(resource) {
+          await resource.refresh();
+          if (callback) await callback(resource);
+          logger.debug(`Resource status: ${resource.status}`);
+          return isFinalStatus(resource.status);
+        }
+        return await this.waitUntil({
+          checkFinishedCallback,
+          intervalSeconds,
+          timeoutSeconds
+        });
+      };
+      deleteAndWaitUntilFinished = async (params) => {
+        const { callback, intervalSeconds = 5, timeoutSeconds = 300 } = params ?? {};
+        try {
+          await this.delete();
+        } catch (error) {
+          if (error instanceof ResourceNotExistError) return;
+        }
+        async function checkFinishedCallback(resource) {
+          try {
+            await resource.refresh();
+            if (callback) await callback(resource);
+          } catch (error) {
+            if (error instanceof ResourceNotExistError) return true;
+            if (resource.status === Status.DELETING) return false;
+            throw Error(`Resource status is ${resource.status}`);
+          }
+          return false;
+        }
+        return await this.waitUntil({
+          checkFinishedCallback,
+          intervalSeconds,
+          timeoutSeconds
+        });
+      };
+      refresh = async (params) => await this.get(params);
+      /**
+       * 更新实例自身的属性 / Update instance properties
+       *
+       * @param source - 源对象 / Source object
+       */
+      updateSelf(source) {
+        updateObjectProperties(this, source);
+      }
+      setConfig = (config2) => {
+        this._config = config2;
+        return this;
+      };
+    };
+  }
+});
+
+// src/agent-runtime/endpoint.ts
+var AgentRuntimeEndpoint;
+var init_endpoint = __esm({
+  "src/agent-runtime/endpoint.ts"() {
+    init_config();
+    init_resource();
+    init_data();
+    AgentRuntimeEndpoint = class _AgentRuntimeEndpoint extends ResourceBase {
+      // System properties
+      agentRuntimeEndpointArn;
+      agentRuntimeEndpointId;
+      agentRuntimeEndpointName;
+      agentRuntimeId;
+      description;
+      endpointPublicUrl;
+      resourceName;
+      routingConfiguration;
+      statusReason;
+      tags;
+      targetVersion;
+      _config;
+      _dataApi;
+      _agentRuntimeName;
+      constructor(data, config2) {
+        super();
+        if (data) {
+          updateObjectProperties(this, data);
+        }
+        this._config = config2;
+      }
+      uniqIdCallback = () => this.agentRuntimeEndpointId;
+      static getClient() {
+        const { AgentRuntimeClient: AgentRuntimeClient2 } = (init_client(), __toCommonJS(client_exports));
+        return new AgentRuntimeClient2();
+      }
+      /**
+       * Create an endpoint by Agent Runtime ID
+       */
+      static async create(params) {
+        const { agentRuntimeId, input, config: config2 } = params;
+        return await _AgentRuntimeEndpoint.getClient().createEndpoint({
+          agentRuntimeId,
+          input,
+          config: config2
+        });
+      }
+      /**
+       * Delete an endpoint by ID
+       */
+      static async delete(params) {
+        const { agentRuntimeId, endpointId, config: config2 } = params;
+        return await _AgentRuntimeEndpoint.getClient().deleteEndpoint({
+          agentRuntimeId,
+          endpointId,
+          config: config2
+        });
+      }
+      /**
+       * Update an endpoint by ID
+       */
+      static async update(params) {
+        const { agentRuntimeId, endpointId, input, config: config2 } = params;
+        return await _AgentRuntimeEndpoint.getClient().updateEndpoint({
+          agentRuntimeId,
+          endpointId,
+          input,
+          config: config2
+        });
+      }
+      /**
+       * Get an endpoint by ID
+       */
+      static async get(params) {
+        const { agentRuntimeId, endpointId, config: config2 } = params;
+        return await _AgentRuntimeEndpoint.getClient().getEndpoint({
+          agentRuntimeId,
+          endpointId,
+          config: config2
+        });
+      }
+      /**
+       * List endpoints by Agent Runtime ID
+       */
+      static async list(params) {
+        const { agentRuntimeId, input, config: config2 } = params;
+        return await _AgentRuntimeEndpoint.getClient().listEndpoints({
+          agentRuntimeId,
+          input,
+          config: config2
+        });
+      }
+      static listAll = async (params) => {
+        const { agentRuntimeId, ...restParams } = params;
+        return await listAllResourcesFunction(
+          (params2) => this.list({ ...params2, agentRuntimeId })
+        )(restParams);
+      };
+      get = async (params) => {
+        return await _AgentRuntimeEndpoint.get({
+          agentRuntimeId: this.agentRuntimeId,
+          endpointId: this.agentRuntimeEndpointId,
+          config: params?.config
+        });
+      };
+      /**
+       * Delete this endpoint
+       */
+      delete = async (params) => {
+        const config2 = params?.config;
+        if (!this.agentRuntimeId || !this.agentRuntimeEndpointId) {
+          throw new Error(
+            "agentRuntimeId and agentRuntimeEndpointId are required to delete an endpoint"
+          );
+        }
+        const result = await _AgentRuntimeEndpoint.delete({
+          agentRuntimeId: this.agentRuntimeId,
+          endpointId: this.agentRuntimeEndpointId,
+          config: config2 ?? this._config
+        });
+        updateObjectProperties(this, result);
+        return this;
+      };
+      /**
+       * Update this endpoint
+       */
+      update = async (params) => {
+        const { input, config: config2 } = params;
+        if (!this.agentRuntimeId || !this.agentRuntimeEndpointId) {
+          throw new Error(
+            "agentRuntimeId and agentRuntimeEndpointId are required to update an endpoint"
+          );
+        }
+        const result = await _AgentRuntimeEndpoint.update({
+          agentRuntimeId: this.agentRuntimeId,
+          endpointId: this.agentRuntimeEndpointId,
+          input,
+          config: config2 ?? this._config
+        });
+        updateObjectProperties(this, result);
+        return this;
+      };
+      /**
+       * Refresh this endpoint's data
+       */
+      refresh = async (params) => {
+        const config2 = params?.config;
+        if (!this.agentRuntimeId || !this.agentRuntimeEndpointId) {
+          throw new Error(
+            "agentRuntimeId and agentRuntimeEndpointId are required to refresh an endpoint"
+          );
+        }
+        const result = await _AgentRuntimeEndpoint.get({
+          agentRuntimeId: this.agentRuntimeId,
+          endpointId: this.agentRuntimeEndpointId,
+          config: config2 ?? this._config
+        });
+        updateObjectProperties(this, result);
+        return this;
+      };
+      /**
+       * Invoke agent runtime using OpenAI-compatible API through this endpoint
+       *
+       * This method provides an OpenAI-compatible interface to invoke the agent runtime
+       * through this specific endpoint.
+       *
+       * @param args - Invocation arguments
+       * @returns OpenAI chat completion response
+       *
+       * @example
+       * ```typescript
+       * const endpoint = await AgentRuntimeEndpoint.get({
+       *   agentRuntimeId: "runtime-id",
+       *   endpointId: "endpoint-id"
+       * });
+       * const response = await endpoint.invokeOpenai({
+       *   messages: [{ role: "user", content: "Hello" }],
+       *   stream: false
+       * });
+       * ```
+       */
+      invokeOpenai = async (args) => {
+        const { messages, stream, config: config2 } = args;
+        const cfg = Config.withConfigs(this._config, config2);
+        if (!this._dataApi) {
+          if (!this._agentRuntimeName && this.agentRuntimeId) {
+            const client = _AgentRuntimeEndpoint.getClient();
+            const runtime = await client.get({
+              id: this.agentRuntimeId,
+              config: cfg
+            });
+            this._agentRuntimeName = runtime.agentRuntimeName;
+          }
+          if (!this._agentRuntimeName) {
+            throw new Error("Unable to determine agent runtime name for this endpoint");
+          }
+          this._dataApi = new AgentRuntimeDataAPI(
+            this._agentRuntimeName,
+            this.agentRuntimeEndpointName || "",
+            cfg
+          );
+        }
+        return this._dataApi.invokeOpenai({
+          messages,
+          stream,
+          config: cfg
+        });
+      };
+    };
+  }
+});
+async function codeFromZipFile(language, command, zipFilePath) {
+  const data = await fs2.promises.readFile(zipFilePath);
+  const checksum = crc64Lib.crc64(data);
+  return {
+    language,
+    command,
+    zipFile: data.toString("base64"),
+    checksum
+  };
+}
+function codeFromOss(language, command, bucket, object) {
+  return {
+    language,
+    command,
+    ossBucketName: bucket,
+    ossObjectName: object
+  };
+}
+async function codeFromFile(language, command, filePath) {
+  const archiver = await import('archiver').catch(() => null);
+  if (!archiver) {
+    throw new Error(
+      "archiver package is required for codeFromFile. Install it with: npm install archiver"
+    );
+  }
+  const stats = await fs2.promises.stat(filePath);
+  const zipFilePath = path.join(path.dirname(filePath), `${Date.now()}.zip`);
+  const output = fs2.createWriteStream(zipFilePath);
+  const archive = archiver.default("zip", { zlib: { level: 9 } });
+  await new Promise((resolve, reject) => {
+    output.on("close", resolve);
+    archive.on("error", reject);
+    archive.pipe(output);
+    if (stats.isDirectory()) {
+      archive.directory(filePath, false);
+    } else {
+      archive.file(filePath, { name: path.basename(filePath) });
+    }
+    archive.finalize();
+  });
+  const code = await codeFromZipFile(language, command, zipFilePath);
+  await fs2.promises.unlink(zipFilePath);
+  return code;
+}
+var AgentRuntimeArtifact, AgentRuntimeLanguage, AgentRuntimeProtocolType;
+var init_model2 = __esm({
+  "src/agent-runtime/model.ts"() {
+    init_model();
+    AgentRuntimeArtifact = {
+      CODE: "Code",
+      CONTAINER: "Container"
+    };
+    AgentRuntimeLanguage = {
+      PYTHON310: "python3.10",
+      PYTHON312: "python3.12",
+      NODEJS18: "nodejs18",
+      NODEJS20: "nodejs20",
+      JAVA8: "java8",
+      JAVA11: "java11"
+    };
+    AgentRuntimeProtocolType = {
+      HTTP: "HTTP",
+      MCP: "MCP"
+    };
+  }
+});
+
+// src/agent-runtime/runtime.ts
+var AgentRuntime;
+var init_runtime = __esm({
+  "src/agent-runtime/runtime.ts"() {
+    init_config();
+    init_resource();
+    init_data();
+    init_endpoint();
+    AgentRuntime = class _AgentRuntime extends ResourceBase {
+      // System properties
+      agentRuntimeArn;
+      agentRuntimeId;
+      agentRuntimeName;
+      agentRuntimeVersion;
+      artifactType;
+      codeConfiguration;
+      containerConfiguration;
+      cpu;
+      createdAt;
+      credentialName;
+      description;
+      environmentVariables;
+      executionRoleArn;
+      healthCheckConfiguration;
+      lastUpdatedAt;
+      logConfiguration;
+      memory;
+      networkConfiguration;
+      port;
+      protocolConfiguration;
+      resourceName;
+      sessionConcurrencyLimitPerInstance;
+      sessionIdleTimeoutSeconds;
+      statusReason;
+      tags;
+      _config;
+      _dataApiCache = {};
+      constructor(data, config2) {
+        super();
+        if (data) {
+          updateObjectProperties(this, data);
+        }
+        this._config = config2;
+      }
+      uniqIdCallback = () => this.agentRuntimeId;
+      static getClient() {
+        const { AgentRuntimeClient: AgentRuntimeClient2 } = (init_client(), __toCommonJS(client_exports));
+        return new AgentRuntimeClient2();
+      }
+      /**
+       * Create a new Agent Runtime
+       */
+      static async create(params) {
+        const { input, config: config2 } = params;
+        return await _AgentRuntime.getClient().create({ input, config: config2 });
+      }
+      /**
+       * Delete an Agent Runtime by ID
+       */
+      static async delete(params) {
+        const { id, config: config2 } = params;
+        return await _AgentRuntime.getClient().delete({ id, config: config2 });
+      }
+      /**
+       * Update an Agent Runtime by ID
+       */
+      static async update(params) {
+        const { id, input, config: config2 } = params;
+        return await _AgentRuntime.getClient().update({ id, input, config: config2 });
+      }
+      /**
+       * Get an Agent Runtime by ID
+       */
+      static async get(params) {
+        const { id, config: config2 } = params;
+        return await _AgentRuntime.getClient().get({ id, config: config2 });
+      }
+      /**
+       * List Agent Runtimes
+       */
+      static async list(params) {
+        const { input, config: config2 } = params ?? {};
+        return await _AgentRuntime.getClient().list({ input, config: config2 });
+      }
+      static listAll = listAllResourcesFunction(this.list);
+      /**
+       * List Agent Runtime versions by ID
+       */
+      static async listVersionsById(params) {
+        const { agentRuntimeId, input, config: config2 } = params;
+        const client = _AgentRuntime.getClient();
+        return await client.listVersions({ agentRuntimeId, input, config: config2 });
+      }
+      /**
+       * Delete this runtime
+       */
+      delete = async (params) => {
+        const config2 = params?.config;
+        if (!this.agentRuntimeId) {
+          throw new Error("agentRuntimeId is required to delete an Agent Runtime");
+        }
+        const result = await _AgentRuntime.delete({
+          id: this.agentRuntimeId,
+          config: config2 ?? this._config
+        });
+        updateObjectProperties(this, result);
+        return this;
+      };
+      /**
+       * Update this runtime
+       */
+      update = async (params) => {
+        const { input, config: config2 } = params;
+        if (!this.agentRuntimeId) {
+          throw new Error("agentRuntimeId is required to update an Agent Runtime");
+        }
+        const result = await _AgentRuntime.update({
+          id: this.agentRuntimeId,
+          input,
+          config: config2 ?? this._config
+        });
+        updateObjectProperties(this, result);
+        return this;
+      };
+      /**
+       * Refresh this runtime's data
+       */
+      get = async (params) => {
+        const config2 = params?.config;
+        if (!this.agentRuntimeId) {
+          throw new Error("agentRuntimeId is required to refresh an Agent Runtime");
+        }
+        const result = await _AgentRuntime.get({
+          id: this.agentRuntimeId,
+          config: config2 ?? this._config
+        });
+        updateObjectProperties(this, result);
+        return this;
+      };
+      /**
+       * Create an endpoint for this runtime
+       */
+      createEndpoint = async (params) => {
+        const { input, config: config2 } = params;
+        if (!this.agentRuntimeId) {
+          throw new Error("agentRuntimeId is required to create an endpoint");
+        }
+        return AgentRuntimeEndpoint.create({
+          agentRuntimeId: this.agentRuntimeId,
+          input,
+          config: config2 ?? this._config
+        });
+      };
+      /**
+       * Delete an endpoint from this runtime
+       */
+      deleteEndpoint = async (params) => {
+        const { endpointId, config: config2 } = params;
+        if (!this.agentRuntimeId) {
+          throw new Error("agentRuntimeId is required to delete an endpoint");
+        }
+        return AgentRuntimeEndpoint.delete({
+          agentRuntimeId: this.agentRuntimeId,
+          endpointId,
+          config: config2 ?? this._config
+        });
+      };
+      /**
+       * Update an endpoint of this runtime
+       */
+      updateEndpoint = async (params) => {
+        const { endpointId, input, config: config2 } = params;
+        if (!this.agentRuntimeId) {
+          throw new Error("agentRuntimeId is required to update an endpoint");
+        }
+        return AgentRuntimeEndpoint.update({
+          agentRuntimeId: this.agentRuntimeId,
+          endpointId,
+          input,
+          config: config2 ?? this._config
+        });
+      };
+      /**
+       * Get an endpoint of this runtime
+       */
+      getEndpoint = async (params) => {
+        const { endpointId, config: config2 } = params;
+        if (!this.agentRuntimeId) {
+          throw new Error("agentRuntimeId is required to get an endpoint");
+        }
+        return AgentRuntimeEndpoint.get({
+          agentRuntimeId: this.agentRuntimeId,
+          endpointId,
+          config: config2 ?? this._config
+        });
+      };
+      /**
+       * List endpoints of this runtime
+       */
+      listEndpoints = async (params) => {
+        const config2 = params?.config;
+        if (!this.agentRuntimeId) {
+          throw new Error("agentRuntimeId is required to list endpoints");
+        }
+        return AgentRuntimeEndpoint.list({
+          agentRuntimeId: this.agentRuntimeId,
+          config: config2 ?? this._config
+        });
+      };
+      /**
+       * List versions of this runtime
+       */
+      listVersions = async (params) => {
+        const config2 = params?.config;
+        if (!this.agentRuntimeId) {
+          throw new Error("agentRuntimeId is required to list versions");
+        }
+        return _AgentRuntime.listVersionsById({
+          agentRuntimeId: this.agentRuntimeId,
+          config: config2 ?? this._config
+        });
+      };
+      /**
+       * Invoke agent runtime using OpenAI-compatible API
+       *
+       * This method provides an OpenAI-compatible interface to invoke the agent runtime.
+       * It creates a Data API client and forwards the invocation request.
+       *
+       * @param args - Invocation arguments
+       * @returns OpenAI chat completion response
+       *
+       * @example
+       * ```typescript
+       * const runtime = await AgentRuntime.get({ id: "runtime-id" });
+       * const response = await runtime.invokeOpenai({
+       *   agentRuntimeEndpointName: "Default",
+       *   messages: [{ role: "user", content: "Hello" }],
+       *   stream: false
+       * });
+       * ```
+       */
+      invokeOpenai = async (args) => {
+        const { agentRuntimeEndpointName = "Default", messages, stream, config: config2 } = args;
+        if (!this.agentRuntimeName) {
+          throw new Error("agentRuntimeName is required to invoke OpenAI");
+        }
+        const cfg = Config.withConfigs(this._config, config2);
+        if (!this._dataApiCache[agentRuntimeEndpointName]) {
+          this._dataApiCache[agentRuntimeEndpointName] = new AgentRuntimeDataAPI(
+            this.agentRuntimeName,
+            agentRuntimeEndpointName,
+            cfg
+          );
+        }
+        return this._dataApiCache[agentRuntimeEndpointName].invokeOpenai({
+          messages,
+          stream,
+          config: cfg
+        });
+      };
+    };
+  }
+});
+
+// src/agent-runtime/client.ts
+var client_exports = {};
+__export(client_exports, {
+  AgentRuntimeClient: () => AgentRuntimeClient
+});
+var AgentRuntimeClient;
+var init_client = __esm({
+  "src/agent-runtime/client.ts"() {
+    init_config();
+    init_exception();
+    init_model();
+    init_control();
+    init_data();
+    init_endpoint();
+    init_model2();
+    init_runtime();
+    AgentRuntimeClient = class {
+      config;
+      controlApi;
+      constructor(config2) {
+        this.config = config2;
+        this.controlApi = new AgentRuntimeControlAPI(config2);
+      }
+      /**
+       * Create an Agent Runtime
+       */
+      create = async (params) => {
+        const { input, config: config2 } = params;
+        const cfg = Config.withConfigs(this.config, config2);
+        try {
+          if (!input.networkConfiguration) {
+            input.networkConfiguration = {};
+          }
+          if (!input.artifactType) {
+            if (input.codeConfiguration) {
+              input.artifactType = AgentRuntimeArtifact.CODE;
+            } else if (input.containerConfiguration) {
+              input.artifactType = AgentRuntimeArtifact.CONTAINER;
+            } else {
+              throw new Error("Either codeConfiguration or containerConfiguration must be provided");
+            }
+          }
+          const result = await this.controlApi.createAgentRuntime({
+            input: new $AgentRun3.CreateAgentRuntimeInput({
+              ...input,
+              codeConfiguration: input.codeConfiguration ? new $AgentRun3.CodeConfiguration({
+                ...input.codeConfiguration
+              }) : void 0,
+              containerConfiguration: input.containerConfiguration ? new $AgentRun3.ContainerConfiguration({
+                ...input.containerConfiguration
+              }) : void 0,
+              networkConfiguration: input.networkConfiguration ? new $AgentRun3.NetworkConfiguration({
+                networkMode: input.networkConfiguration.networkMode || NetworkMode.PUBLIC,
+                securityGroupId: input.networkConfiguration.securityGroupId,
+                vpcId: input.networkConfiguration.vpcId,
+                vswitchIds: input.networkConfiguration.vSwitchIds
+              }) : void 0
+            }),
+            config: cfg
+          });
+          return new AgentRuntime(result, cfg);
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("AgentRuntime", input.agentRuntimeName);
+          }
+          throw error;
+        }
+      };
+      /**
+       * Delete an Agent Runtime
+       */
+      delete = async (params) => {
+        const { id, config: config2 } = params;
+        const cfg = Config.withConfigs(this.config, config2);
+        try {
+          const endpoints = await this.listEndpoints({
+            agentRuntimeId: id,
+            config: cfg
+          });
+          for (const endpoint of endpoints) {
+            await endpoint.delete({ config: cfg });
+          }
+          let remaining = await this.listEndpoints({
+            agentRuntimeId: id,
+            config: cfg
+          });
+          while (remaining.length > 0) {
+            await new Promise((resolve) => setTimeout(resolve, 1e3));
+            remaining = await this.listEndpoints({
+              agentRuntimeId: id,
+              config: cfg
+            });
+          }
+          const result = await this.controlApi.deleteAgentRuntime({
+            agentId: id,
+            config: cfg
+          });
+          return new AgentRuntime(result, cfg);
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("AgentRuntime", id);
+          }
+          throw error;
+        }
+      };
+      /**
+       * Update an Agent Runtime
+       */
+      update = async (params) => {
+        const { id, input, config: config2 } = params;
+        const cfg = Config.withConfigs(this.config, config2);
+        try {
+          const result = await this.controlApi.updateAgentRuntime({
+            agentId: id,
+            input: new $AgentRun3.UpdateAgentRuntimeInput({
+              ...input,
+              codeConfiguration: input.codeConfiguration ? new $AgentRun3.CodeConfiguration({
+                ...input.codeConfiguration
+              }) : void 0,
+              containerConfiguration: input.containerConfiguration ? new $AgentRun3.ContainerConfiguration({
+                ...input.containerConfiguration
+              }) : void 0
+            }),
+            config: cfg
+          });
+          return new AgentRuntime(result, cfg);
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("AgentRuntime", id);
+          }
+          throw error;
+        }
+      };
+      /**
+       * Get an Agent Runtime
+       */
+      get = async (params) => {
+        const { id, config: config2 } = params;
+        const cfg = Config.withConfigs(this.config, config2);
+        try {
+          const result = await this.controlApi.getAgentRuntime({
+            agentId: id,
+            config: cfg
+          });
+          return new AgentRuntime(result, cfg);
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("AgentRuntime", id);
+          }
+          throw error;
+        }
+      };
+      /**
+       * List Agent Runtimes
+       */
+      list = async (params) => {
+        const { input, config: config2 } = params ?? {};
+        const cfg = Config.withConfigs(this.config, config2);
+        const request = new $AgentRun3.ListAgentRuntimesRequest({
+          ...input
+        });
+        const result = await this.controlApi.listAgentRuntimes({
+          input: request,
+          config: cfg
+        });
+        return (result.items || []).map((item) => new AgentRuntime(item, cfg));
+      };
+      // /**
+      //  * List all Agent Runtimes (with pagination)
+      //  */
+      // listAll = async (params?: {
+      //   options?: {
+      //     agentRuntimeName?: string;
+      //     tags?: string;
+      //     searchMode?: string;
+      //   };
+      //   config?: Config;
+      // }): Promise<AgentRuntime[]> => {
+      //   const { options, config } = params ?? {};
+      //   return AgentRuntime.listAll(options, config ?? this.config);
+      // };
+      /**
+       * Create an endpoint for an Agent Runtime
+       */
+      createEndpoint = async (params) => {
+        const { agentRuntimeId, input, config: config2 } = params;
+        const cfg = Config.withConfigs(this.config, config2);
+        try {
+          const targetVersion = input.targetVersion || "LATEST";
+          const result = await this.controlApi.createAgentRuntimeEndpoint({
+            agentId: agentRuntimeId,
+            input: new $AgentRun3.CreateAgentRuntimeEndpointInput({
+              ...input,
+              targetVersion
+            }),
+            config: cfg
+          });
+          return new AgentRuntimeEndpoint(result, cfg);
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError(
+              "AgentRuntimeEndpoint",
+              `${agentRuntimeId}/${input.agentRuntimeEndpointName}`
+            );
+          }
+          throw error;
+        }
+      };
+      /**
+       * Delete an endpoint
+       */
+      deleteEndpoint = async (params) => {
+        const { agentRuntimeId, endpointId, config: config2 } = params;
+        const cfg = Config.withConfigs(this.config, config2);
+        try {
+          const result = await this.controlApi.deleteAgentRuntimeEndpoint({
+            agentId: agentRuntimeId,
+            endpointId,
+            config: cfg
+          });
+          return new AgentRuntimeEndpoint(result, cfg);
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("AgentRuntimeEndpoint", `${agentRuntimeId}/${endpointId}`);
+          }
+          throw error;
+        }
+      };
+      /**
+       * Update an endpoint
+       */
+      updateEndpoint = async (params) => {
+        const { agentRuntimeId, endpointId, input, config: config2 } = params;
+        const cfg = Config.withConfigs(this.config, config2);
+        try {
+          const result = await this.controlApi.updateAgentRuntimeEndpoint({
+            agentId: agentRuntimeId,
+            endpointId,
+            input: new $AgentRun3.UpdateAgentRuntimeEndpointInput({
+              ...input
+            }),
+            config: cfg
+          });
+          return new AgentRuntimeEndpoint(result, cfg);
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("AgentRuntimeEndpoint", `${agentRuntimeId}/${endpointId}`);
+          }
+          throw error;
+        }
+      };
+      /**
+       * Get an endpoint
+       */
+      getEndpoint = async (params) => {
+        const { agentRuntimeId, endpointId, config: config2 } = params;
+        const cfg = Config.withConfigs(this.config, config2);
+        try {
+          const result = await this.controlApi.getAgentRuntimeEndpoint({
+            agentId: agentRuntimeId,
+            endpointId,
+            config: cfg
+          });
+          return new AgentRuntimeEndpoint(result, cfg);
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("AgentRuntimeEndpoint", `${agentRuntimeId}/${endpointId}`);
+          }
+          throw error;
+        }
+      };
+      /**
+       * List endpoints for an Agent Runtime
+       */
+      listEndpoints = async (params) => {
+        const { agentRuntimeId, input, config: config2 } = params;
+        const cfg = Config.withConfigs(this.config, config2);
+        try {
+          const request = new $AgentRun3.ListAgentRuntimeEndpointsRequest({
+            ...input
+          });
+          const result = await this.controlApi.listAgentRuntimeEndpoints({
+            agentId: agentRuntimeId,
+            input: request,
+            config: cfg
+          });
+          return (result.items || []).map((item) => new AgentRuntimeEndpoint(item, cfg));
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("AgentRuntime", agentRuntimeId);
+          }
+          throw error;
+        }
+      };
+      /**
+       * List versions for an Agent Runtime
+       */
+      listVersions = async (params) => {
+        const { agentRuntimeId, input, config: config2 } = params;
+        const cfg = Config.withConfigs(this.config, config2);
+        const versions = [];
+        let page = 1;
+        const pageSize = 50;
+        while (true) {
+          const request = new $AgentRun3.ListAgentRuntimeVersionsRequest({
+            ...input,
+            pageNumber: input?.pageNumber ?? page,
+            pageSize: input?.pageSize ?? pageSize
+          });
+          const result = await this.controlApi.listAgentRuntimeVersions({
+            agentId: agentRuntimeId,
+            input: request,
+            config: cfg
+          });
+          if (result.items) {
+            for (const item of result.items) {
+              versions.push({
+                agentRuntimeArn: item.agentRuntimeArn,
+                agentRuntimeId: item.agentRuntimeId,
+                agentRuntimeName: item.agentRuntimeName,
+                agentRuntimeVersion: item.agentRuntimeVersion,
+                description: item.description,
+                lastUpdatedAt: item.lastUpdatedAt
+              });
+            }
+          }
+          if (!result.items || result.items.length < pageSize) {
+            break;
+          }
+          page++;
+        }
+        const seen = /* @__PURE__ */ new Set();
+        return versions.filter((v) => {
+          if (!v.agentRuntimeVersion || seen.has(v.agentRuntimeVersion)) {
+            return false;
+          }
+          seen.add(v.agentRuntimeVersion);
+          return true;
+        });
+      };
+      /**
+       * Invoke agent runtime using OpenAI-compatible API
+       *
+       * This method provides an OpenAI-compatible interface to invoke the agent runtime.
+       *
+       * @param params - Parameters including agent runtime name, endpoint name, and invocation args
+       * @returns OpenAI chat completion response
+       *
+       * @example
+       * ```typescript
+       * const client = new AgentRuntimeClient();
+       * const response = await client.invokeOpenai({
+       *   agentRuntimeName: "my-runtime",
+       *   agentRuntimeEndpointName: "Default",
+       *   messages: [{ role: "user", content: "Hello" }],
+       *   stream: false
+       * });
+       * ```
+       */
+      invokeOpenai = async (params) => {
+        const {
+          agentRuntimeName,
+          agentRuntimeEndpointName = "Default",
+          messages,
+          stream,
+          config: config2
+        } = params;
+        const cfg = Config.withConfigs(this.config, config2);
+        const dataApi = new AgentRuntimeDataAPI(agentRuntimeName, agentRuntimeEndpointName, cfg);
+        return dataApi.invokeOpenai({
+          messages,
+          stream,
+          config: cfg
+        });
+      };
+    };
+  }
+});
+
+// src/utils/version-check.ts
+init_log();
+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/agent-runtime/index.ts
+init_client();
+init_runtime();
+init_endpoint();
+init_control();
+init_data();
+init_model2();
+
+export { AgentRuntime, AgentRuntimeArtifact, AgentRuntimeClient, AgentRuntimeControlAPI, AgentRuntimeDataAPI, AgentRuntimeEndpoint, AgentRuntimeLanguage, AgentRuntimeProtocolType, codeFromFile, codeFromOss, codeFromZipFile };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map