@agentrun/sdk 0.0.3 → 0.0.4

package/dist/credential/index.js

@@ -0,0 +1,1263 @@
+import * as dotenv from 'dotenv';
+import * as $AgentRun from '@alicloud/agentrun20250910';
+import * as $OpenApi from '@alicloud/openapi-client';
+import * as $Util from '@alicloud/tea-util';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// 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");
+    }
+  }
+});
+
+// src/utils/version-check.ts
+var VERSION;
+var init_version_check = __esm({
+  "src/utils/version-check.ts"() {
+    init_log();
+    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`
+      );
+    }
+  }
+});
+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/data-api.ts
+var init_data_api = __esm({
+  "src/utils/data-api.ts"() {
+    init_config();
+    init_exception();
+    init_log();
+  }
+});
+
+// src/utils/model.ts
+function isFinalStatus(status) {
+  return [
+    void 0,
+    null,
+    "",
+    ...["READY", "CREATE_FAILED", "UPDATE_FAILED", "DELETE_FAILED"]
+  ].includes(status);
+}
+var Status;
+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"
+    };
+  }
+});
+
+// src/utils/index.ts
+var init_utils = __esm({
+  "src/utils/index.ts"() {
+    init_version_check();
+    init_config();
+    init_data_api();
+    init_exception();
+    init_log();
+    init_model();
+  }
+});
+var $AgentRunClient, ControlAPI;
+var init_control_api = __esm({
+  "src/utils/control-api.ts"() {
+    init_config();
+    $AgentRunClient = // @ts-expect-error - ESM interop: default.default exists when imported as ESM namespace
+    $AgentRun.default?.default ?? $AgentRun.default ?? $AgentRun;
+    ControlAPI = class {
+      config;
+      constructor(config2) {
+        this.config = config2;
+      }
+      /**
+       * Get the underlying AgentRun client instance
+       */
+      getClient(config2) {
+        const cfg = Config.withConfigs(this.config, config2);
+        let endpoint = cfg.controlEndpoint;
+        if (endpoint.startsWith("http://") || endpoint.startsWith("https://")) {
+          endpoint = endpoint.split("://")[1];
+        }
+        const openApiConfig = new $OpenApi.Config({
+          accessKeyId: cfg.accessKeyId,
+          accessKeySecret: cfg.accessKeySecret,
+          securityToken: cfg.securityToken || void 0,
+          regionId: cfg.regionId,
+          endpoint,
+          connectTimeout: cfg.timeout,
+          readTimeout: cfg.readTimeout
+        });
+        return new $AgentRunClient(openApiConfig);
+      }
+    };
+  }
+});
+var CredentialControlAPI;
+var init_control = __esm({
+  "src/credential/api/control.ts"() {
+    init_control_api();
+    init_exception();
+    init_log();
+    CredentialControlAPI = class extends ControlAPI {
+      constructor(config2) {
+        super(config2);
+      }
+      /**
+       * Create credential
+       *
+       * @param params - Method parameters
+       * @param params.input - Credential configuration
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Created credential object
+       */
+      createCredential = async (params) => {
+        const { input, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.createCredentialWithOptions(
+            new $AgentRun.CreateCredentialRequest({ body: input }),
+            headers ?? {},
+            runtime
+          );
+          logger.debug(
+            `request api createCredential, 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 credential
+       *
+       * @param params - Method parameters
+       * @param params.credentialName - Credential name
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Deleted credential object
+       */
+      deleteCredential = async (params) => {
+        const { credentialName, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.deleteCredentialWithOptions(
+            credentialName,
+            headers ?? {},
+            runtime
+          );
+          logger.debug(
+            `request api deleteCredential, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([credentialName])}
+  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 credential
+       *
+       * @param params - Method parameters
+       * @param params.credentialName - Credential name
+       * @param params.input - Credential configuration
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Updated credential object
+       */
+      updateCredential = async (params) => {
+        const { credentialName, input, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.updateCredentialWithOptions(
+            credentialName,
+            new $AgentRun.UpdateCredentialRequest({ body: input }),
+            headers ?? {},
+            runtime
+          );
+          logger.debug(
+            `request api updateCredential, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([credentialName, 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 credential
+       *
+       * @param params - Method parameters
+       * @param params.credentialName - Credential name
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Credential object
+       */
+      getCredential = async (params) => {
+        const { credentialName, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.getCredentialWithOptions(
+            credentialName,
+            headers ?? {},
+            runtime
+          );
+          logger.debug(
+            `request api getCredential, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([credentialName])}
+  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 credentials
+       *
+       * @param params - Method parameters
+       * @param params.input - List options
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns List of credential objects
+       */
+      listCredentials = async (params) => {
+        const { input, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.listCredentialsWithOptions(input, headers ?? {}, runtime);
+          logger.debug(
+            `request api listCredentials, 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;
+        }
+      };
+    };
+  }
+});
+
+// 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/credential/credential.ts
+var Credential;
+var init_credential = __esm({
+  "src/credential/credential.ts"() {
+    init_resource();
+    init_resource();
+    init_client();
+    Credential = class _Credential extends ResourceBase {
+      credentialName;
+      /** 描述 */
+      description;
+      /** 是否启用 */
+      enabled;
+      credentialId;
+      createdAt;
+      updatedAt;
+      relatedResources;
+      /** 凭证认证类型 */
+      credentialAuthType;
+      /** 凭证来源类型 */
+      credentialSourceType;
+      /** 凭证公共配置 */
+      credentialPublicConfig;
+      /** 凭证密钥 */
+      credentialSecret;
+      _config;
+      constructor(data, config2) {
+        super();
+        if (data) updateObjectProperties(this, data);
+        this._config = config2;
+      }
+      static getClient = () => {
+        return new CredentialClient();
+      };
+      /**
+       * Create a new Credential
+       */
+      static create = async (paramsOrInput) => {
+        const hasInputProp = paramsOrInput && paramsOrInput.input !== void 0;
+        const input = hasInputProp ? paramsOrInput.input : paramsOrInput;
+        const config2 = hasInputProp ? paramsOrInput.config : void 0;
+        return await _Credential.getClient().create({ input, config: config2 });
+      };
+      /**
+       * Delete a Credential by name
+       */
+      static delete = async (paramsOrName) => {
+        const isString = typeof paramsOrName === "string";
+        const name = isString ? paramsOrName : paramsOrName.name;
+        const config2 = isString ? void 0 : paramsOrName.config;
+        return await _Credential.getClient().delete({ name, config: config2 });
+      };
+      /**
+       * Update a Credential by name
+       */
+      static update = async (paramsOrName) => {
+        const name = paramsOrName.name;
+        const input = paramsOrName.input;
+        const config2 = paramsOrName.config;
+        return await _Credential.getClient().update({ name, input, config: config2 });
+      };
+      /**
+       * Get a Credential by name
+       */
+      static get = async (paramsOrName) => {
+        const isString = typeof paramsOrName === "string";
+        const name = isString ? paramsOrName : paramsOrName.name;
+        const config2 = isString ? void 0 : paramsOrName.config;
+        return await _Credential.getClient().get({ name, config: config2 });
+      };
+      /**
+       * List all Credentials (with pagination)
+       */
+      static list = async (paramsOrUndefined) => {
+        const input = paramsOrUndefined?.input ?? paramsOrUndefined;
+        const config2 = paramsOrUndefined?.config;
+        return await _Credential.getClient().list({ input, config: config2 });
+      };
+      static listAll = listAllResourcesFunction(this.list);
+      /**
+       * Delete this credential
+       */
+      delete = async (params) => {
+        const config2 = params?.config;
+        if (!this.credentialName) {
+          throw new Error("credentialName is required to delete a Credential");
+        }
+        const result = await _Credential.delete({
+          name: this.credentialName,
+          config: config2 ?? this._config
+        });
+        updateObjectProperties(this, result);
+        return this;
+      };
+      /**
+       * Update this credential
+       */
+      update = async (params) => {
+        const hasInputProp = params && params.input !== void 0;
+        const input = hasInputProp ? params.input : params;
+        const config2 = hasInputProp ? params.config : void 0;
+        if (!this.credentialName) {
+          throw new Error("credentialName is required to update a Credential");
+        }
+        const result = await _Credential.update({
+          name: this.credentialName,
+          input,
+          config: config2 ?? this._config
+        });
+        updateObjectProperties(this, result);
+        return this;
+      };
+      /**
+       * Refresh this credential's data
+       */
+      get = async (params) => {
+        const config2 = params?.config;
+        if (!this.credentialName) {
+          throw new Error("credentialName is required to refresh a Credential");
+        }
+        const result = await _Credential.get({
+          name: this.credentialName,
+          config: config2 ?? this._config
+        });
+        updateObjectProperties(this, result);
+        return this;
+      };
+    };
+  }
+});
+
+// src/credential/model.ts
+var CredentialConfig, CredentialListOutput;
+var init_model2 = __esm({
+  "src/credential/model.ts"() {
+    init_resource();
+    CredentialConfig = class _CredentialConfig {
+      constructor(data) {
+        if (data) updateObjectProperties(this, data);
+      }
+      /** 配置访问 AgentRun 的 api key 凭证 */
+      static inboundApiKey(params) {
+        const { apiKey, headerKey = "Authorization" } = params;
+        return new _CredentialConfig({
+          credentialSourceType: "internal",
+          credentialAuthType: "api_key",
+          credentialPublicConfig: { headerKey },
+          credentialSecret: apiKey
+        });
+      }
+      /** 配置访问 AgentRun 的静态 JWKS 凭证 */
+      static inboundStaticJwt(params) {
+        const { jwks } = params;
+        return new _CredentialConfig({
+          credentialSourceType: "internal",
+          credentialAuthType: "jwt",
+          credentialPublicConfig: { authType: "static_jwks", jwks },
+          credentialSecret: ""
+        });
+      }
+      /** 配置访问 AgentRun 的远程 JWT 凭证 */
+      static inboundRemoteJwt(uri, timeout = 3e3, ttl = 3e4, publicConfig) {
+        return new _CredentialConfig({
+          credentialSourceType: "internal",
+          credentialAuthType: "jwt",
+          credentialPublicConfig: { uri, timeout, ttl, ...publicConfig },
+          credentialSecret: ""
+        });
+      }
+      /** 配置访问 AgentRun 的 Basic 凭证 */
+      static inboundBasic(params) {
+        const { users } = params;
+        return new _CredentialConfig({
+          credentialSourceType: "internal",
+          credentialAuthType: "basic",
+          credentialPublicConfig: { users },
+          credentialSecret: ""
+        });
+      }
+      /** 配置访问第三方工具的 api key 凭证 */
+      static outboundLLMApiKey(params) {
+        const { apiKey, provider } = params;
+        return new _CredentialConfig({
+          credentialSourceType: "external_llm",
+          credentialAuthType: "api_key",
+          credentialPublicConfig: { provider },
+          credentialSecret: apiKey
+        });
+      }
+      /** 配置访问第三方工具的 ak/sk 凭证 */
+      static outboundLLMAKSK(provider, accessKeyId, accessKeySecret, accountId) {
+        return new _CredentialConfig({
+          credentialSourceType: "external_tool",
+          credentialAuthType: "aksk",
+          credentialPublicConfig: {
+            provider,
+            authConfig: { accessKey: accessKeyId, accountId }
+          },
+          credentialSecret: accessKeySecret
+        });
+      }
+      /** 配置访问第三方工具的自定义凭证 */
+      static outboundToolAKSKCustom(params) {
+        const { authConfig } = params;
+        return new _CredentialConfig({
+          credentialSourceType: "external_tool",
+          credentialAuthType: "aksk",
+          credentialPublicConfig: { provider: "custom", authConfig },
+          credentialSecret: ""
+        });
+      }
+      /** 配置访问第三方工具的自定义 Header 凭证 */
+      static outboundToolCustomHeader(params) {
+        const { headers } = params;
+        return new _CredentialConfig({
+          credentialSourceType: "external_tool",
+          credentialAuthType: "custom_header",
+          credentialPublicConfig: { authConfig: headers },
+          credentialSecret: ""
+        });
+      }
+    };
+    CredentialListOutput = class {
+      createdAt;
+      credentialAuthType;
+      credentialId;
+      credentialName;
+      credentialSourceType;
+      enabled;
+      relatedResourceCount;
+      updatedAt;
+      constructor(data) {
+        if (data) updateObjectProperties(this, data);
+      }
+      uniqIdCallback = () => this.credentialId;
+      toCredential = async (params) => {
+        const { CredentialClient: CredentialClient2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+        return await new CredentialClient2(params?.config).get({
+          name: this.credentialName || "",
+          config: params?.config
+        });
+      };
+    };
+  }
+});
+
+// src/credential/client.ts
+var client_exports = {};
+__export(client_exports, {
+  CredentialClient: () => CredentialClient
+});
+var CredentialClient;
+var init_client = __esm({
+  "src/credential/client.ts"() {
+    init_utils();
+    init_config();
+    init_control();
+    init_credential();
+    init_model2();
+    CredentialClient = class {
+      config;
+      controlApi;
+      constructor(config2) {
+        this.config = config2;
+        this.controlApi = new CredentialControlAPI(config2);
+      }
+      /**
+       * Create a Credential
+       */
+      create = async (params) => {
+        try {
+          const { input, config: config2 } = params;
+          const cfg = Config.withConfigs(this.config, config2);
+          const credCfg = input.credentialConfig;
+          const normalized = {
+            ...input,
+            credentialAuthType: credCfg?.credentialAuthType ?? credCfg?.authType,
+            credentialSourceType: credCfg?.credentialSourceType ?? credCfg?.sourceType,
+            credentialPublicConfig: credCfg?.credentialPublicConfig ?? credCfg?.publicConfig,
+            credentialSecret: credCfg?.credentialSecret ?? credCfg?.secret
+          };
+          if (normalized.credentialPublicConfig) {
+            const publicConfig = normalized.credentialPublicConfig;
+            if (!("users" in publicConfig)) {
+              publicConfig.users = [];
+            }
+          }
+          if (normalized.credentialAuthType === "basic") {
+            const pub = normalized.credentialPublicConfig ?? {};
+            if (pub.username) {
+              normalized.credentialPublicConfig = {
+                users: [
+                  {
+                    username: pub.username,
+                    password: normalized.credentialSecret ?? ""
+                  }
+                ]
+              };
+              normalized.credentialSecret = "";
+            }
+          }
+          const result = await this.controlApi.createCredential({
+            input: new $AgentRun.CreateCredentialInput(normalized),
+            config: cfg
+          });
+          return new Credential(result);
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("Credential", params?.input?.credentialName);
+          }
+          throw error;
+        }
+      };
+      /**
+       * Delete a Credential
+       */
+      delete = async (params) => {
+        try {
+          const { name, config: config2 } = params;
+          const cfg = Config.withConfigs(this.config, config2);
+          const result = await this.controlApi.deleteCredential({
+            credentialName: name,
+            config: cfg
+          });
+          return new Credential(result);
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("Credential", params?.name);
+          }
+          throw error;
+        }
+      };
+      /**
+       * Update a Credential
+       */
+      update = async (params) => {
+        try {
+          const { name, input, config: config2 } = params;
+          const cfg = Config.withConfigs(this.config, config2);
+          const credCfg = input.credentialConfig;
+          const normalized = { ...input };
+          if (credCfg) {
+            normalized.credentialAuthType = credCfg?.credentialAuthType ?? credCfg?.authType;
+            normalized.credentialSourceType = credCfg?.credentialSourceType ?? credCfg?.sourceType;
+            normalized.credentialPublicConfig = credCfg?.credentialPublicConfig ?? credCfg?.publicConfig;
+            normalized.credentialSecret = credCfg?.credentialSecret ?? credCfg?.secret;
+            if (normalized.credentialPublicConfig) {
+              const publicConfig = normalized.credentialPublicConfig;
+              if (!("users" in publicConfig)) {
+                publicConfig.users = [];
+              }
+            }
+            if (normalized.credentialAuthType === "basic") {
+              const pub = normalized.credentialPublicConfig ?? {};
+              if (pub.username) {
+                normalized.credentialPublicConfig = {
+                  users: [
+                    {
+                      username: pub.username,
+                      password: normalized.credentialSecret ?? ""
+                    }
+                  ]
+                };
+                normalized.credentialSecret = "";
+              }
+            }
+          }
+          const result = await this.controlApi.updateCredential({
+            credentialName: name,
+            input: new $AgentRun.UpdateCredentialInput(normalized),
+            config: cfg
+          });
+          return new Credential(result);
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("Credential", params?.name);
+          }
+          throw error;
+        }
+      };
+      /**
+       * Get a Credential
+       */
+      get = async (params) => {
+        try {
+          const { name, config: config2 } = params;
+          const cfg = Config.withConfigs(this.config, config2);
+          const result = await this.controlApi.getCredential({
+            credentialName: name,
+            config: cfg
+          });
+          return new Credential(result);
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("Credential", params?.name);
+          }
+          throw error;
+        }
+      };
+      /**
+       * List Credentials
+       */
+      list = async (params) => {
+        try {
+          const { input, config: config2 } = params ?? {};
+          const cfg = Config.withConfigs(this.config, config2);
+          const results = await this.controlApi.listCredentials({
+            input: new $AgentRun.ListCredentialsRequest({ ...input }),
+            config: cfg
+          });
+          return results.items?.map((item) => new CredentialListOutput(item)) ?? [];
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("Credential");
+          }
+          throw error;
+        }
+      };
+    };
+  }
+});
+
+// src/credential/index.ts
+init_version_check();
+init_client();
+init_credential();
+init_control();
+init_model2();
+
+export { Credential, CredentialClient, CredentialConfig, CredentialControlAPI };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map