@agentrun/sdk 0.0.3 → 0.0.4

package/dist/agent-runtime/api/index.js

@@ -0,0 +1,882 @@
+import * as $AgentRun2 from '@alicloud/agentrun20250910';
+import * as $Util from '@alicloud/tea-util';
+import * as $OpenApi from '@alicloud/openapi-client';
+import * as dotenv from 'dotenv';
+
+// src/utils/log.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var COLORS = {
+  reset: "\x1B[0m",
+  bright: "\x1B[1m",
+  dim: "\x1B[2m",
+  italic: "\x1B[3m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m"
+};
+var Logger = class {
+  level = "info";
+  // match Python logger name
+  prefix = "agentrun-logger";
+  setLevel(level) {
+    this.level = level;
+  }
+  shouldLog(level) {
+    return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
+  }
+  getColor(level) {
+    switch (level) {
+      case "debug":
+        return COLORS.cyan;
+      case "info":
+        return COLORS.blue;
+      case "warn":
+        return COLORS.yellow;
+      case "error":
+        return COLORS.red;
+      default:
+        return COLORS.reset;
+    }
+  }
+  // format timestamp like Python: YYYY-MM-DD HH:mm:ss,SSS
+  formatTimestamp(d = /* @__PURE__ */ new Date()) {
+    const pad = (n, sz = 2) => n.toString().padStart(sz, "0");
+    const year = d.getFullYear();
+    const month = pad(d.getMonth() + 1);
+    const day = pad(d.getDate());
+    const hour = pad(d.getHours());
+    const minute = pad(d.getMinutes());
+    const second = pad(d.getSeconds());
+    const ms = pad(d.getMilliseconds(), 3);
+    return `${year}-${month}-${day} ${hour}:${minute}:${second},${ms}`;
+  }
+  // attempt to infer caller file and line by parsing Error.stack
+  // helper: parse a single stack frame into {filepath, line, functionName}
+  parseFrame(frame) {
+    const m = frame.match(/^(?:at\s+)?(?:(.+?)\s+\()?(.*?):(\d+):(\d+)\)?$/);
+    if (!m) return null;
+    return {
+      functionName: m[1] ? m[1].trim() : void 0,
+      filepath: m[2],
+      line: parseInt(m[3], 10)
+    };
+  }
+  // get caller by fixed stack offset (used in public log methods)
+  getCallerByOffset() {
+    const err = new Error();
+    const stack = err.stack;
+    if (!stack) return {};
+    const lines = stack.split("\n").map((l) => l.trim());
+    for (let i = 3; i < lines.length; i++) {
+      let parsed = this.parseFrame(lines[i]);
+      if (!parsed) {
+        const m = lines[i].match(/(\/[^:\s]+:\d+:\d+)/);
+        if (m) {
+          const parts = m[1].split(":");
+          parts.pop();
+          const ln = Number(parts.pop());
+          const fp2 = parts.join(":");
+          parsed = { filepath: fp2, line: ln, functionName: void 0 };
+        }
+      }
+      if (!parsed) continue;
+      const fp = parsed.filepath;
+      if (fp.includes("node_modules") || fp.includes("internal") || fp.includes("<anonymous>") || fp.includes("native"))
+        continue;
+      return { filepath: parsed.filepath, line: parsed.line };
+    }
+    const cwd = process.cwd();
+    for (let i = 0; i < lines.length; i++) {
+      let parsed = this.parseFrame(lines[i]);
+      if (!parsed) {
+        const m = lines[i].match(/(\/[^:\s]+:\d+:\d+)/);
+        if (m) {
+          const parts = m[1].split(":");
+          parts.pop();
+          const ln = Number(parts.pop());
+          const fp2 = parts.join(":");
+          parsed = { filepath: fp2, line: ln, functionName: void 0 };
+        }
+      }
+      if (!parsed) continue;
+      const fp = parsed.filepath;
+      if (fp.includes("node_modules") || fp.includes("internal") || fp.includes("<anonymous>") || fp.includes("native"))
+        continue;
+      if (fp.includes("/src/utils/log.ts")) continue;
+      if (fp.startsWith(cwd)) return { filepath: parsed.filepath, line: parsed.line };
+    }
+    for (let i = 0; i < lines.length; i++) {
+      let parsed = this.parseFrame(lines[i]);
+      if (!parsed) {
+        const m = lines[i].match(/(\/[^:\s]+:\d+:\d+)/);
+        if (m) {
+          const parts = m[1].split(":");
+          parts.pop();
+          const ln = Number(parts.pop());
+          const fp2 = parts.join(":");
+          parsed = { filepath: fp2, line: ln, functionName: void 0 };
+        }
+      }
+      if (!parsed) continue;
+      const fp = parsed.filepath;
+      if (fp.includes("node_modules") || fp.includes("internal") || fp.includes("<anonymous>") || fp.includes("native"))
+        continue;
+      if (fp.includes("/src/utils/log.ts")) continue;
+      return { filepath: parsed.filepath, line: parsed.line };
+    }
+    return {};
+  }
+  formatMessage(level, message, filepath, line) {
+    const timestamp = this.formatTimestamp();
+    const color = this.getColor(level);
+    const reset = COLORS.reset;
+    const levelName = level === "warn" ? "WARNING" : level.toUpperCase();
+    const levelStr = `${COLORS.bright}${color}${levelName}${reset}`;
+    const nameStr = `${color}[${this.prefix}]${reset}`;
+    const tsStr = `${color} ${timestamp}${reset}`;
+    const pathInfo = filepath && line !== void 0 ? ` ${COLORS.dim}${COLORS.italic}${filepath}:${line}${reset}` : "";
+    const msg = level === "debug" ? `${COLORS.dim}${message}${reset}` : message;
+    return `
+${levelStr} ${nameStr}${tsStr}${pathInfo}
+${msg}
+`;
+  }
+  debug(message, ...args) {
+    if (this.shouldLog("debug")) {
+      const caller = this.getCallerByOffset();
+      console.debug(this.formatMessage("debug", message, caller.filepath, caller.line), ...args);
+    }
+  }
+  info(message, ...args) {
+    if (this.shouldLog("info")) {
+      const caller = this.getCallerByOffset();
+      console.info(this.formatMessage("info", message, caller.filepath, caller.line), ...args);
+    }
+  }
+  warn(message, ...args) {
+    if (this.shouldLog("warn")) {
+      const caller = this.getCallerByOffset();
+      console.warn(this.formatMessage("warn", message, caller.filepath, caller.line), ...args);
+    }
+  }
+  error(message, ...args) {
+    if (this.shouldLog("error")) {
+      const caller = this.getCallerByOffset();
+      console.error(this.formatMessage("error", message, caller.filepath, caller.line), ...args);
+    }
+  }
+};
+var logger = new Logger();
+if (![void 0, null, "", "False", "FALSE", "false", "0"].includes(process.env["AGENTRUN_SDK_DEBUG"])) {
+  logger.setLevel("debug");
+  if (!globalThis._AGENTRUN_DEBUG_LOGGED) {
+    logger.warn("\u542F\u7528 AgentRun SDK \u8C03\u8BD5\u65E5\u5FD7\uFF0C \u79FB\u9664 AGENTRUN_SDK_DEBUG \u73AF\u5883\u53D8\u91CF\u4EE5\u5173\u95ED");
+    globalThis._AGENTRUN_DEBUG_LOGGED = true;
+  }
+} else {
+  logger.setLevel("info");
+}
+
+// src/utils/version-check.ts
+var VERSION = "0.0.4" ;
+if (!process.env.DISABLE_BREAKING_CHANGES_WARNING && !globalThis._AGENTRUN_VERSION_WARNING_SHOWN) {
+  globalThis._AGENTRUN_VERSION_WARNING_SHOWN = true;
+  logger.warn(
+    `\u5F53\u524D\u60A8\u6B63\u5728\u4F7F\u7528 AgentRun Python SDK \u7248\u672C ${VERSION}\u3002\u65E9\u671F\u7248\u672C\u901A\u5E38\u5305\u542B\u8BB8\u591A\u65B0\u529F\u80FD\uFF0C\u8FD9\u4E9B\u529F\u80FD\x1B[1;33m \u53EF\u80FD\u5F15\u5165\u4E0D\u517C\u5BB9\u7684\u53D8\u66F4 \x1B[0m\u3002\u4E3A\u907F\u514D\u6F5C\u5728\u95EE\u9898\uFF0C\u6211\u4EEC\u5F3A\u70C8\u5EFA\u8BAE\x1B[1;32m \u5C06\u4F9D\u8D56\u9501\u5B9A\u4E3A\u6B64\u7248\u672C \x1B[0m\u3002
+You are currently using AgentRun Python SDK version ${VERSION}. Early versions often include many new features, which\x1B[1;33m may introduce breaking changes\x1B[0m. To avoid potential issues, we strongly recommend \x1B[1;32mpinning the dependency to this version\x1B[0m.
+\x1B[2;3m  pip install 'agentrun-sdk==${VERSION}' \x1B[0m
+
+\u589E\u52A0\x1B[2;3m DISABLE_BREAKING_CHANGES_WARNING=1 \x1B[0m\u5230\u60A8\u7684\u73AF\u5883\u53D8\u91CF\u4EE5\u5173\u95ED\u6B64\u8B66\u544A\u3002
+Add\x1B[2;3m DISABLE_BREAKING_CHANGES_WARNING=1 \x1B[0mto your environment variables to disable this warning.
+     
+Releases:\x1B[2;3m https://github.com/Serverless-Devs/agentrun-sdk-python/releases\x1B[0m`
+  );
+}
+dotenv.config();
+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 = class _Config {
+  _accessKeyId;
+  _accessKeySecret;
+  _securityToken;
+  _accountId;
+  _token;
+  _regionId;
+  _timeout;
+  _readTimeout;
+  _controlEndpoint;
+  _dataEndpoint;
+  _devsEndpoint;
+  _headers;
+  constructor(options = {}) {
+    this._accessKeyId = options.accessKeyId ?? getEnvWithDefault("", "AGENTRUN_ACCESS_KEY_ID", "ALIBABA_CLOUD_ACCESS_KEY_ID");
+    this._accessKeySecret = options.accessKeySecret ?? getEnvWithDefault("", "AGENTRUN_ACCESS_KEY_SECRET", "ALIBABA_CLOUD_ACCESS_KEY_SECRET");
+    this._securityToken = options.securityToken ?? getEnvWithDefault("", "AGENTRUN_SECURITY_TOKEN", "ALIBABA_CLOUD_SECURITY_TOKEN");
+    this._accountId = options.accountId ?? getEnvWithDefault("", "AGENTRUN_ACCOUNT_ID", "FC_ACCOUNT_ID");
+    this._token = options.token;
+    this._regionId = options.regionId ?? getEnvWithDefault("cn-hangzhou", "AGENTRUN_REGION", "FC_REGION");
+    this._timeout = options.timeout ?? 6e5;
+    this._readTimeout = options.readTimeout ?? 1e8;
+    this._controlEndpoint = options.controlEndpoint ?? getEnvWithDefault("", "AGENTRUN_CONTROL_ENDPOINT");
+    this._dataEndpoint = options.dataEndpoint ?? getEnvWithDefault("", "AGENTRUN_DATA_ENDPOINT");
+    this._devsEndpoint = options.devsEndpoint ?? getEnvWithDefault("", "DEVS_ENDPOINT");
+    this._headers = options.headers ?? {};
+  }
+  /**
+   * Create a new Config by merging multiple configs.
+   * Later configs take precedence.
+   */
+  static withConfigs(...configs) {
+    return new _Config().update(...configs);
+  }
+  /**
+   * Update this config with values from other configs.
+   * Non-undefined values from later configs take precedence.
+   */
+  update(...configs) {
+    for (const config2 of configs) {
+      if (!config2) continue;
+      if (config2._accessKeyId) this._accessKeyId = config2._accessKeyId;
+      if (config2._accessKeySecret) this._accessKeySecret = config2._accessKeySecret;
+      if (config2._securityToken) this._securityToken = config2._securityToken;
+      if (config2._accountId) this._accountId = config2._accountId;
+      if (config2._token) this._token = config2._token;
+      if (config2._regionId) this._regionId = config2._regionId;
+      if (config2._timeout) this._timeout = config2._timeout;
+      if (config2._readTimeout) this._readTimeout = config2._readTimeout;
+      if (config2._controlEndpoint) this._controlEndpoint = config2._controlEndpoint;
+      if (config2._dataEndpoint) this._dataEndpoint = config2._dataEndpoint;
+      if (config2._devsEndpoint) this._devsEndpoint = config2._devsEndpoint;
+      if (config2._headers && Object.keys(config2._headers).length > 0) {
+        this._headers = { ...this._headers, ...config2._headers };
+      }
+    }
+    return this;
+  }
+  get accessKeyId() {
+    return this._accessKeyId;
+  }
+  get accessKeySecret() {
+    return this._accessKeySecret;
+  }
+  get securityToken() {
+    return this._securityToken;
+  }
+  get accountId() {
+    if (!this._accountId) {
+      throw new Error(
+        "Account ID is not set. Please add AGENTRUN_ACCOUNT_ID environment variable or set it in code."
+      );
+    }
+    return this._accountId;
+  }
+  get token() {
+    return this._token;
+  }
+  get regionId() {
+    return this._regionId || "cn-hangzhou";
+  }
+  get timeout() {
+    return this._timeout || 6e5;
+  }
+  get readTimeout() {
+    return this._readTimeout || 1e8;
+  }
+  get controlEndpoint() {
+    if (this._controlEndpoint) {
+      return this._controlEndpoint;
+    }
+    return `https://agentrun.${this.regionId}.aliyuncs.com`;
+  }
+  get dataEndpoint() {
+    if (this._dataEndpoint) {
+      return this._dataEndpoint;
+    }
+    return `https://${this.accountId}.agentrun-data.${this.regionId}.aliyuncs.com`;
+  }
+  get devsEndpoint() {
+    if (this._devsEndpoint) {
+      return this._devsEndpoint;
+    }
+    return `https://devs.${this.regionId}.aliyuncs.com`;
+  }
+  get headers() {
+    return this._headers;
+  }
+};
+
+// src/utils/control-api.ts
+var $AgentRunClient = (
+  // @ts-expect-error - ESM interop: default.default exists when imported as ESM namespace
+  $AgentRun2.default?.default ?? $AgentRun2.default ?? $AgentRun2
+);
+var ControlAPI = class {
+  config;
+  constructor(config2) {
+    this.config = config2;
+  }
+  /**
+   * Get the underlying AgentRun client instance
+   */
+  getClient(config2) {
+    const cfg = Config.withConfigs(this.config, config2);
+    let endpoint = cfg.controlEndpoint;
+    if (endpoint.startsWith("http://") || endpoint.startsWith("https://")) {
+      endpoint = endpoint.split("://")[1];
+    }
+    const openApiConfig = new $OpenApi.Config({
+      accessKeyId: cfg.accessKeyId,
+      accessKeySecret: cfg.accessKeySecret,
+      securityToken: cfg.securityToken || void 0,
+      regionId: cfg.regionId,
+      endpoint,
+      connectTimeout: cfg.timeout,
+      readTimeout: cfg.readTimeout
+    });
+    return new $AgentRunClient(openApiConfig);
+  }
+};
+
+// src/utils/exception.ts
+var AgentRunError = class _AgentRunError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AgentRunError";
+    Object.setPrototypeOf(this, _AgentRunError.prototype);
+  }
+};
+var HTTPError = class _HTTPError extends AgentRunError {
+  statusCode;
+  requestId;
+  errorCode;
+  constructor(statusCode, message, options) {
+    super(message);
+    this.name = "HTTPError";
+    this.statusCode = statusCode;
+    this.requestId = options?.requestId;
+    this.errorCode = options?.errorCode;
+    Object.setPrototypeOf(this, _HTTPError.prototype);
+  }
+  /**
+   * Convert HTTP error to resource-specific error based on status code
+   */
+  toResourceError(resourceType, resourceId) {
+    if (this.statusCode == 404) return new ResourceNotExistError(resourceType, resourceId);
+    else if (this.statusCode == 409) return new ResourceAlreadyExistError(resourceType, resourceId);
+    else if ((this.statusCode == 400 || this.statusCode == 500) && this.message.includes("already exists"))
+      return new ResourceAlreadyExistError(resourceType, resourceId);
+    else return this;
+  }
+};
+var ClientError = class _ClientError extends HTTPError {
+  constructor(statusCode, message, options) {
+    super(statusCode, message, options);
+    this.name = "ClientError";
+    Object.setPrototypeOf(this, _ClientError.prototype);
+  }
+};
+var ServerError = class _ServerError extends HTTPError {
+  constructor(statusCode, message, options) {
+    super(statusCode, message, options);
+    this.name = "ServerError";
+    Object.setPrototypeOf(this, _ServerError.prototype);
+  }
+};
+var ResourceNotExistError = class _ResourceNotExistError extends ClientError {
+  resourceType;
+  resourceId;
+  constructor(resourceType, resourceId, options) {
+    const message = resourceId ? `${resourceType} '${resourceId}' does not exist` : `${resourceType} does not exist`;
+    super(404, message, options);
+    this.name = "ResourceNotExistError";
+    this.resourceType = resourceType;
+    this.resourceId = resourceId;
+    Object.setPrototypeOf(this, _ResourceNotExistError.prototype);
+  }
+};
+var ResourceAlreadyExistError = class _ResourceAlreadyExistError extends ClientError {
+  resourceType;
+  resourceId;
+  constructor(resourceType, resourceId, options) {
+    const message = resourceId ? `${resourceType} '${resourceId}' already exists` : `${resourceType} already exists`;
+    super(409, message, options);
+    this.name = "ResourceAlreadyExistError";
+    this.resourceType = resourceType;
+    this.resourceId = resourceId;
+    Object.setPrototypeOf(this, _ResourceAlreadyExistError.prototype);
+  }
+};
+
+// src/agent-runtime/api/control.ts
+var 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 $AgentRun2.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 $AgentRun2.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 $AgentRun2.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 $AgentRun2.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 $AgentRun2.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;
+    }
+  };
+};
+
+export { AgentRuntimeControlAPI };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map