@agentrun/sdk 0.0.3 → 0.0.4

package/dist/model/index.cjs

@@ -0,0 +1,2392 @@
+'use strict';
+
+var dotenv = require('dotenv');
+var $AgentRun5 = require('@alicloud/agentrun20250910');
+var $OpenApi = require('@alicloud/openapi-client');
+var $Util = require('@alicloud/tea-util');
+var openaiCompatible = require('@ai-sdk/openai-compatible');
+var _2 = require('lodash');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var dotenv__namespace = /*#__PURE__*/_interopNamespace(dotenv);
+var $AgentRun5__namespace = /*#__PURE__*/_interopNamespace($AgentRun5);
+var $OpenApi__namespace = /*#__PURE__*/_interopNamespace($OpenApi);
+var $Util__namespace = /*#__PURE__*/_interopNamespace($Util);
+var _2__namespace = /*#__PURE__*/_interopNamespace(_2);
+
+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");
+    }
+  }
+});
+
+// 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__namespace.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);
+      }
+    };
+  }
+});
+var $AgentRunClient; exports.ModelControlAPI = void 0;
+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
+    $AgentRun5__namespace.default?.default ?? $AgentRun5__namespace.default ?? $AgentRun5__namespace;
+    exports.ModelControlAPI = 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__namespace.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 ModelControlAPI;
+var init_control = __esm({
+  "src/model/api/control.ts"() {
+    init_control_api();
+    init_exception();
+    init_log();
+    ModelControlAPI = class extends exports.ModelControlAPI {
+      constructor(config2) {
+        super(config2);
+      }
+      /**
+       * Create model service
+       *
+       * @param params - Method parameters
+       * @param params.input - Model service configuration
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Created model service object
+       */
+      createModelService = async (params) => {
+        const { input, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util__namespace.RuntimeOptions({});
+          const response = await client.createModelServiceWithOptions(
+            new $AgentRun5__namespace.CreateModelServiceRequest({ body: input }),
+            headers ?? {},
+            runtime
+          );
+          logger.debug(
+            `request api createModelService, 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 model service
+       *
+       * @param params - Method parameters
+       * @param params.modelServiceName - Model service name
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Deleted model service object
+       */
+      deleteModelService = async (params) => {
+        const { modelServiceName, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util__namespace.RuntimeOptions({});
+          const response = await client.deleteModelServiceWithOptions(
+            modelServiceName,
+            headers ?? {},
+            runtime
+          );
+          logger.debug(
+            `request api deleteModelService, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([modelServiceName])}
+  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 model service
+       *
+       * @param params - Method parameters
+       * @param params.modelServiceName - Model service name
+       * @param params.input - Model service configuration
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Updated model service object
+       */
+      updateModelService = async (params) => {
+        const { modelServiceName, input, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util__namespace.RuntimeOptions({});
+          const response = await client.updateModelServiceWithOptions(
+            modelServiceName,
+            new $AgentRun5__namespace.UpdateModelServiceRequest({ body: input }),
+            headers ?? {},
+            runtime
+          );
+          logger.debug(
+            `request api updateModelService, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([modelServiceName, 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 model service
+       *
+       * @param params - Method parameters
+       * @param params.modelServiceName - Model service name
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Model service object
+       */
+      getModelService = async (params) => {
+        const { modelServiceName, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util__namespace.RuntimeOptions({});
+          const response = await client.getModelServiceWithOptions(
+            modelServiceName,
+            headers ?? {},
+            runtime
+          );
+          logger.debug(
+            `request api getModelService, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([modelServiceName])}
+  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 model services
+       *
+       * @param params - Method parameters
+       * @param params.input - List options
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns List of model service objects
+       */
+      listModelServices = async (params) => {
+        const { input, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util__namespace.RuntimeOptions({});
+          const response = await client.listModelServicesWithOptions(input, headers ?? {}, runtime);
+          logger.debug(
+            `request api listModelServices, 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 model proxy
+       *
+       * @param params - Method parameters
+       * @param params.input - Model proxy configuration
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Created model proxy object
+       */
+      createModelProxy = async (params) => {
+        const { input, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util__namespace.RuntimeOptions({});
+          const response = await client.createModelProxyWithOptions(
+            new $AgentRun5__namespace.CreateModelProxyRequest({ body: input }),
+            headers ?? {},
+            runtime
+          );
+          logger.debug(
+            `request api createModelProxy, 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 model proxy
+       *
+       * @param params - Method parameters
+       * @param params.modelProxyName - Model proxy name
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Deleted model proxy object
+       */
+      deleteModelProxy = async (params) => {
+        const { modelProxyName, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util__namespace.RuntimeOptions({});
+          const response = await client.deleteModelProxyWithOptions(
+            modelProxyName,
+            headers ?? {},
+            runtime
+          );
+          logger.debug(
+            `request api deleteModelProxy, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([modelProxyName])}
+  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 model proxy
+       *
+       * @param params - Method parameters
+       * @param params.modelProxyName - Model proxy name
+       * @param params.input - Model proxy configuration
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Updated model proxy object
+       */
+      updateModelProxy = async (params) => {
+        const { modelProxyName, input, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util__namespace.RuntimeOptions({});
+          const response = await client.updateModelProxyWithOptions(
+            modelProxyName,
+            new $AgentRun5__namespace.UpdateModelProxyRequest({ body: input }),
+            headers ?? {},
+            runtime
+          );
+          logger.debug(
+            `request api updateModelProxy, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([modelProxyName, 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 model proxy
+       *
+       * @param params - Method parameters
+       * @param params.modelProxyName - Model proxy name
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Model proxy object
+       */
+      getModelProxy = async (params) => {
+        const { modelProxyName, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util__namespace.RuntimeOptions({});
+          const response = await client.getModelProxyWithOptions(
+            modelProxyName,
+            headers ?? {},
+            runtime
+          );
+          logger.debug(
+            `request api getModelProxy, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([modelProxyName])}
+  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 model proxies
+       *
+       * @param params - Method parameters
+       * @param params.input - List options
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns List of model proxy objects
+       */
+      listModelProxies = async (params) => {
+        const { input, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util__namespace.RuntimeOptions({});
+          const response = await client.listModelProxiesWithOptions(input, headers ?? {}, runtime);
+          logger.debug(
+            `request api listModelProxies, 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/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/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;
+      };
+    };
+  }
+});
+var ModelAPI;
+var init_model_api = __esm({
+  "src/model/api/model-api.ts"() {
+    ModelAPI = class {
+      getModelInfo;
+      constructor(getModelInfo) {
+        this.getModelInfo = getModelInfo;
+      }
+      //   abstract modelInfo(params: { config?: Config }): Promise<ModelInfo>;
+      getProvider = async (params) => {
+        const { model, config: config2 } = params;
+        const info = await this.getModelInfo({ config: config2 });
+        const provider = openaiCompatible.createOpenAICompatible({
+          name: model || info.model || "",
+          apiKey: info.apiKey,
+          baseURL: info.baseUrl || "",
+          headers: info.headers
+        });
+        return { provider, model: model || info.model || "" };
+      };
+      getModel = async (params) => {
+        const { provider, model } = await this.getProvider(params);
+        return provider(model);
+      };
+      getEmbeddingModel = async (params) => {
+        const { provider, model } = await this.getProvider(params);
+        return provider.embeddingModel(model);
+      };
+      completion = async (params) => {
+        const { messages, model, stream = false, config: config2, ...kwargs } = params;
+        const { streamText, generateText } = await import('ai');
+        return await (stream ? streamText : generateText)({
+          model: await this.getModel({ model, config: config2 }),
+          messages,
+          ...kwargs
+        });
+      };
+      embedding = async (params) => {
+        const { values, model, config: config2, ...kwargs } = params;
+        const { embedMany } = await import('ai');
+        return await embedMany({
+          model: await this.getEmbeddingModel({ model, config: config2 }),
+          values,
+          ...kwargs
+        });
+      };
+    };
+  }
+});
+
+// src/model/model.ts
+exports.BackendType = void 0; exports.ModelType = void 0; exports.Provider = void 0;
+var init_model2 = __esm({
+  "src/model/model.ts"() {
+    exports.BackendType = {
+      PROXY: "proxy",
+      SERVICE: "service"
+    };
+    exports.ModelType = {
+      LLM: "llm",
+      TEXT_EMBEDDING: "text-embedding",
+      SPEECH2TEXT: "speech2text",
+      TTS: "tts",
+      RERANK: "rerank",
+      MODERATION: "moderation"
+    };
+    exports.Provider = {
+      OPENAI: "openai",
+      ANTHROPIC: "anthropic",
+      BAICHUAN: "baichuan",
+      DEEPSEEK: "deepseek",
+      GEMINI: "gemini",
+      HUNYUAN: "hunyuan",
+      MINIMAX: "minimax",
+      MOONSHOT: "moonshot",
+      SPARK: "spark",
+      STEPFUN: "stepfun",
+      TONGYI: "tongyi",
+      VERTEX_AI: "vertex_ai",
+      WENXIN: "wenxin",
+      YI: "yi",
+      ZHIPUAI: "zhipuai",
+      CUSTOM: "custom"
+    };
+  }
+});
+
+// src/utils/data-api.ts
+var init_data_api = __esm({
+  "src/utils/data-api.ts"() {
+    init_config();
+    init_exception();
+    init_log();
+  }
+});
+
+// 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 CredentialControlAPI;
+var init_control2 = __esm({
+  "src/credential/api/control.ts"() {
+    init_control_api();
+    init_exception();
+    init_log();
+    CredentialControlAPI = class extends exports.ModelControlAPI {
+      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__namespace.RuntimeOptions({});
+          const response = await client.createCredentialWithOptions(
+            new $AgentRun5__namespace.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__namespace.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__namespace.RuntimeOptions({});
+          const response = await client.updateCredentialWithOptions(
+            credentialName,
+            new $AgentRun5__namespace.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__namespace.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__namespace.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/credential/model.ts
+var CredentialListOutput;
+var init_model3 = __esm({
+  "src/credential/model.ts"() {
+    init_resource();
+    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_control2();
+    init_credential();
+    init_model3();
+    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 $AgentRun5__namespace.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 $AgentRun5__namespace.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 $AgentRun5__namespace.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/credential.ts
+var credential_exports = {};
+__export(credential_exports, {
+  Credential: () => Credential
+});
+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;
+      };
+    };
+  }
+});
+exports.ModelProxy = void 0;
+var init_model_proxy = __esm({
+  "src/model/model-proxy.ts"() {
+    init_config();
+    init_resource();
+    init_model_api();
+    init_model2();
+    exports.ModelProxy = class _ModelProxy extends ResourceBase {
+      // ImmutableProps
+      modelType;
+      // MutableProps
+      credentialName;
+      description;
+      networkConfiguration;
+      tags;
+      cpu;
+      litellmVersion;
+      memory;
+      modelProxyName;
+      proxyModel;
+      serviceRegionId;
+      proxyConfig;
+      executionRoleArn;
+      // SystemProps
+      endpoint;
+      functionName;
+      modelProxyId;
+      createdAt;
+      lastUpdatedAt;
+      modelApi;
+      constructor() {
+        super();
+        this.modelApi = new ModelAPI(this.modelInfo);
+        this.completion = this.modelApi.completion;
+        this.embedding = this.modelApi.embedding;
+      }
+      completion;
+      embedding;
+      /**
+       * 获取客户端 / Get client
+       *
+       * @returns ModelClient 实例
+       */
+      static getClient() {
+        const { ModelClient: ModelClient2 } = (init_client2(), __toCommonJS(client_exports2));
+        return new ModelClient2();
+      }
+      uniqIdCallback = () => this.modelProxyId;
+      /**
+       * 创建模型代理 / Create model proxy
+       *
+       * @param params - 参数 / Parameters
+       * @returns 创建的模型代理对象 / Created model proxy object
+       */
+      static async create(params) {
+        const { input, config: config2 } = params;
+        return await this.getClient().create({ input, config: config2 });
+      }
+      /**
+       * 根据名称删除模型代理 / Delete model proxy by name
+       *
+       * @param params - 参数 / Parameters
+       * @returns 删除的模型代理对象 / Deleted model proxy object
+       */
+      static async delete(params) {
+        const { name, config: config2 } = params;
+        return await this.getClient().delete({
+          name,
+          backendType: exports.BackendType.PROXY,
+          config: config2
+        });
+      }
+      /**
+       * 根据名称更新模型代理 / Update model proxy by name
+       *
+       * @param params - 参数 / Parameters
+       * @returns 更新后的模型代理对象 / Updated model proxy object
+       */
+      static async update(params) {
+        const { name, input, config: config2 } = params;
+        return await this.getClient().update({ name, input, config: config2 });
+      }
+      /**
+       * 根据名称获取模型代理 / Get model proxy by name
+       *
+       * @param params - 参数 / Parameters
+       * @returns 模型代理对象 / Model proxy object
+       */
+      static async get(params) {
+        const { name, config: config2 } = params;
+        return await this.getClient().get({
+          name,
+          backendType: exports.BackendType.PROXY,
+          config: config2
+        });
+      }
+      /**
+       * 列出模型代理（分页）/ List model proxies (paginated)
+       *
+       * @param pageInput - 分页参数 / Pagination parameters
+       * @param config - 配置 / Configuration
+       * @param kwargs - 其他查询参数 / Other query parameters
+       * @returns 模型代理列表 / Model proxy list
+       */
+      static list = async (params) => {
+        const { input, config: config2 } = params ?? {};
+        return await this.getClient().list({
+          input: {
+            modelProxyName: void 0,
+            // 标识这是 ModelProxyListInput
+            ...input
+          },
+          config: config2
+        });
+      };
+      static listAll = listAllResourcesFunction(this.list);
+      /**
+       * 更新模型代理 / Update model proxy
+       *
+       * @param input - 模型代理更新输入参数 / Model proxy update input parameters
+       * @param config - 配置 / Configuration
+       * @returns 更新后的模型代理对象 / Updated model proxy object
+       */
+      update = async (params) => {
+        const { input, config: config2 } = params;
+        if (!this.modelProxyName) {
+          throw new Error("modelProxyName is required to update a ModelProxy");
+        }
+        const result = await _ModelProxy.update({
+          name: this.modelProxyName,
+          input,
+          config: config2
+        });
+        this.updateSelf(result);
+        return this;
+      };
+      /**
+       * 删除模型代理 / Delete model proxy
+       *
+       * @param params - 参数 / Parameters
+       * @returns 删除的模型代理对象 / Deleted model proxy object
+       */
+      delete = async (params) => {
+        if (!this.modelProxyName) {
+          throw new Error("modelProxyName is required to delete a ModelProxy");
+        }
+        return await _ModelProxy.delete({
+          name: this.modelProxyName,
+          config: params?.config
+        });
+      };
+      /**
+       * 刷新模型代理信息 / Refresh model proxy information
+       *
+       * @param params - 参数 / Parameters
+       * @returns 刷新后的模型代理对象 / Refreshed model proxy object
+       */
+      get = async (params) => {
+        if (!this.modelProxyName) {
+          throw new Error("modelProxyName is required to refresh a ModelProxy");
+        }
+        const result = await _ModelProxy.get({
+          name: this.modelProxyName,
+          config: params?.config
+        });
+        this.updateSelf(result);
+        return this;
+      };
+      /**
+       * 获取模型信息 / Get model information
+       *
+       * @param params - 参数 / Parameters
+       * @param params.config - 配置 / Configuration
+       * @returns 模型基本信息 / Model base information
+       */
+      modelInfo = async (params) => {
+        const cfg = Config.withConfigs(this._config, params?.config);
+        if (!this.modelProxyName) {
+          throw new Error("modelProxyName is required");
+        }
+        if (!this.endpoint) {
+          throw new Error("endpoint is required");
+        }
+        let apiKey = "";
+        if (this.credentialName) {
+          const { Credential: Credential2 } = (init_credential(), __toCommonJS(credential_exports));
+          const credential = await Credential2.get({
+            name: this.credentialName,
+            config: cfg
+          });
+          apiKey = credential.credentialSecret || "";
+        }
+        const defaultModel = this.proxyModel === "single" ? _2__namespace.get(this.proxyConfig, "endpoints[0].modelNames[0]") : this.modelProxyName;
+        return {
+          apiKey,
+          baseUrl: this.endpoint,
+          model: defaultModel,
+          headers: cfg.headers
+        };
+      };
+    };
+  }
+});
+
+// src/model/model-service.ts
+exports.ModelService = void 0;
+var init_model_service = __esm({
+  "src/model/model-service.ts"() {
+    init_config();
+    init_resource();
+    init_model_api();
+    init_model2();
+    exports.ModelService = class _ModelService extends ResourceBase {
+      // ImmutableProps
+      modelInfoConfigs;
+      modelServiceName;
+      provider;
+      // MutableProps
+      credentialName;
+      description;
+      networkConfiguration;
+      tags;
+      providerSettings;
+      // SystemProps
+      modelServiceId;
+      createdAt;
+      lastUpdatedAt;
+      // CommonProps
+      modelType;
+      modelApi;
+      constructor() {
+        super();
+        this.modelApi = new ModelAPI(this.modelInfo);
+        this.completion = this.modelApi.completion;
+        this.embedding = this.modelApi.embedding;
+      }
+      completion;
+      embedding;
+      /**
+       * 获取客户端 / Get client
+       *
+       * @returns ModelClient 实例
+       */
+      static getClient() {
+        const { ModelClient: ModelClient2 } = (init_client2(), __toCommonJS(client_exports2));
+        return new ModelClient2();
+      }
+      uniqIdCallback = () => this.modelServiceId;
+      /**
+       * 创建模型服务 / Create model service
+       *
+       * @param params - 参数 / Parameters
+       * @returns 创建的模型服务对象 / Created model service object
+       */
+      static async create(params) {
+        const { input, config: config2 } = params;
+        return await this.getClient().create({ input, config: config2 });
+      }
+      /**
+       * 根据名称删除模型服务 / Delete model service by name
+       *
+       * @param params - 参数 / Parameters
+       * @returns 删除的模型服务对象 / Deleted model service object
+       */
+      static async delete(params) {
+        const { name, config: config2 } = params;
+        return await this.getClient().delete({
+          name,
+          backendType: exports.BackendType.SERVICE,
+          config: config2
+        });
+      }
+      /**
+       * 根据名称更新模型服务 / Update model service by name
+       *
+       * @param params - 参数 / Parameters
+       * @returns 更新后的模型服务对象 / Updated model service object
+       */
+      static async update(params) {
+        const { name, input, config: config2 } = params;
+        return await this.getClient().update({ name, input, config: config2 });
+      }
+      /**
+       * 根据名称获取模型服务 / Get model service by name
+       *
+       * @param params - 参数 / Parameters
+       * @returns 模型服务对象 / Model service object
+       */
+      static async get(params) {
+        const { name, config: config2 } = params;
+        return await this.getClient().get({
+          name,
+          backendType: exports.BackendType.SERVICE,
+          config: config2
+        });
+      }
+      /**
+       * 列出模型服务（分页）/ List model services (paginated)
+       *
+       * @param pageInput - 分页参数 / Pagination parameters
+       * @param config - 配置 / Configuration
+       * @param kwargs - 其他查询参数 / Other query parameters
+       * @returns 模型服务列表 / Model service list
+       */
+      static list = async (params) => {
+        const { input, config: config2 } = params ?? {};
+        return await this.getClient().list({
+          input: {
+            ...input
+          },
+          config: config2
+        });
+      };
+      static listAll = listAllResourcesFunction(this.list);
+      /**
+       * 更新模型服务 / Update model service
+       *
+       * @param params - 参数 / Parameters
+       * @returns 更新后的模型服务对象 / Updated model service object
+       */
+      update = async (params) => {
+        const { input, config: config2 } = params;
+        if (!this.modelServiceName) {
+          throw new Error("modelServiceName is required to update a ModelService");
+        }
+        const result = await _ModelService.update({
+          name: this.modelServiceName,
+          input,
+          config: config2
+        });
+        this.updateSelf(result);
+        return this;
+      };
+      /**
+       * 删除模型服务 / Delete model service
+       *
+       * @param config - 配置 / Configuration
+       * @returns 删除的模型服务对象 / Deleted model service object
+       */
+      delete = async (params) => {
+        if (!this.modelServiceName) {
+          throw new Error("modelServiceName is required to delete a ModelService");
+        }
+        return await _ModelService.delete({
+          name: this.modelServiceName,
+          config: params?.config
+        });
+      };
+      /**
+       * 刷新模型服务信息 / Refresh model service information
+       *
+       * @param config - 配置 / Configuration
+       * @returns 刷新后的模型服务对象 / Refreshed model service object
+       */
+      get = async (params) => {
+        if (!this.modelServiceName) {
+          throw new Error("modelServiceName is required to refresh a ModelService");
+        }
+        const result = await _ModelService.get({
+          name: this.modelServiceName,
+          config: params?.config
+        });
+        this.updateSelf(result);
+        return this;
+      };
+      /**
+       * 获取模型信息 / Get model information
+       *
+       * @param params - 参数 / Parameters
+       * @param params.config - 配置 / Configuration
+       * @returns 模型基本信息 / Model base information
+       */
+      modelInfo = async (params) => {
+        const cfg = Config.withConfigs(this._config, params?.config);
+        if (!this.providerSettings) {
+          throw new Error("providerSettings is required");
+        }
+        if (!this.providerSettings.baseUrl) {
+          throw new Error("providerSettings.baseUrl is required");
+        }
+        let apiKey = this.providerSettings.apiKey || "";
+        if (!apiKey && this.credentialName) {
+          const { Credential: Credential2 } = (init_credential(), __toCommonJS(credential_exports));
+          const credential = await Credential2.get({
+            name: this.credentialName,
+            config: cfg
+          });
+          apiKey = credential.credentialSecret || "";
+        }
+        const defaultModel = this.providerSettings.modelNames && this.providerSettings.modelNames.length > 0 ? this.providerSettings.modelNames[0] : void 0;
+        return {
+          apiKey,
+          baseUrl: this.providerSettings.baseUrl,
+          model: defaultModel,
+          headers: cfg.headers,
+          provider: this.provider
+        };
+      };
+    };
+  }
+});
+
+// src/model/client.ts
+var client_exports2 = {};
+__export(client_exports2, {
+  ModelClient: () => exports.ModelClient
+});
+exports.ModelClient = void 0;
+var init_client2 = __esm({
+  "src/model/client.ts"() {
+    init_config();
+    init_exception();
+    init_control();
+    init_model_proxy();
+    init_model_service();
+    exports.ModelClient = class {
+      config;
+      controlApi;
+      /**
+       * 初始化客户端 / Initialize client
+       *
+       * @param config - 配置对象,可选 / Configuration object, optional
+       */
+      constructor(config2) {
+        this.config = config2;
+        this.controlApi = new ModelControlAPI(config2);
+      }
+      /**
+       * 创建模型服务
+       * Create model service
+       *
+       * @param params - 参数 / Parameters
+       * @returns 创建的对象 / Created object
+       */
+      create = async (params) => {
+        const { input, config: config2 } = params;
+        const cfg = Config.withConfigs(this.config, config2);
+        try {
+          if ("modelProxyName" in input) {
+            const modelProxyInput = input;
+            if (!modelProxyInput.proxyModel) {
+              const endpoints = _2__namespace.get(modelProxyInput, "proxyConfig.endpoints", []);
+              modelProxyInput.proxyModel = endpoints.length > 1 ? "multi" : "single";
+            }
+            const createInput = new $AgentRun5__namespace.CreateModelProxyInput({
+              ...modelProxyInput,
+              cpu: modelProxyInput.cpu ?? 2,
+              // 默认值 2
+              memory: modelProxyInput.memory ?? 4096,
+              // 默认值 4096
+              proxyMode: modelProxyInput.proxyModel
+            });
+            const result = await this.controlApi.createModelProxy({
+              input: createInput,
+              config: cfg
+            });
+            const proxy = new exports.ModelProxy();
+            Object.assign(proxy, result);
+            return proxy;
+          } else {
+            const modelServiceInput = input;
+            const createInput = new $AgentRun5__namespace.CreateModelServiceInput({
+              ...modelServiceInput
+            });
+            const result = await this.controlApi.createModelService({
+              input: createInput,
+              config: cfg
+            });
+            const service = new exports.ModelService();
+            Object.assign(service, result);
+            return service;
+          }
+        } catch (e) {
+          if (e instanceof HTTPError) {
+            const name = "modelProxyName" in input ? input.modelProxyName : input.modelServiceName;
+            throw e.toResourceError("Model", name);
+          }
+          throw e;
+        }
+      };
+      /**
+       * 删除模型服务
+       * Delete model service
+       *
+       * @param params - 参数 / Parameters
+       * @returns 删除的对象 / Deleted object
+       *
+       * @throws ResourceNotExistError - 模型服务不存在 / Model service does not exist
+       */
+      delete = async (params) => {
+        const { name, backendType, config: config2 } = params;
+        const cfg = Config.withConfigs(this.config, config2);
+        let error = null;
+        if (backendType === "proxy" || backendType === void 0) {
+          try {
+            const result = await this.controlApi.deleteModelProxy({
+              modelProxyName: name,
+              config: cfg
+            });
+            const proxy = new exports.ModelProxy();
+            Object.assign(proxy, result);
+            return proxy;
+          } catch (e) {
+            if (e instanceof HTTPError) {
+              error = e;
+            } else {
+              throw e;
+            }
+          }
+        }
+        if (backendType === "proxy" && error !== null) {
+          throw error.toResourceError("Model", name);
+        }
+        try {
+          const result = await this.controlApi.deleteModelService({
+            modelServiceName: name,
+            config: cfg
+          });
+          const service = new exports.ModelService();
+          Object.assign(service, result);
+          return service;
+        } catch (e) {
+          if (e instanceof HTTPError) {
+            throw e.toResourceError("Model", name);
+          }
+          throw e;
+        }
+      };
+      /**
+       * 更新模型服务
+       * Update model service
+       *
+       * @param params - 参数 / Parameters
+       * @returns 更新后的模型服务对象 / Updated model service object
+       *
+       * @throws ResourceNotExistError - 模型服务不存在 / Model service does not exist
+       */
+      update = async (params) => {
+        const { name, input, config: config2 } = params;
+        const cfg = Config.withConfigs(this.config, config2);
+        if ("proxyModel" in input || "executionRoleArn" in input) {
+          const modelProxyInput = input;
+          try {
+            if (!modelProxyInput.proxyModel && modelProxyInput.proxyModel !== void 0) {
+              const endpoints = _2__namespace.get(modelProxyInput, "proxyConfig.endpoints", []);
+              modelProxyInput.proxyModel = endpoints.length > 1 ? "multi" : "single";
+            }
+            const updateInput = new $AgentRun5__namespace.UpdateModelProxyInput({
+              ...modelProxyInput,
+              proxyMode: modelProxyInput.proxyModel
+            });
+            const result = await this.controlApi.updateModelProxy({
+              modelProxyName: name,
+              input: updateInput,
+              config: cfg
+            });
+            const proxy = new exports.ModelProxy();
+            Object.assign(proxy, result);
+            return proxy;
+          } catch (e) {
+            if (e instanceof HTTPError) {
+              throw e.toResourceError("Model", name);
+            }
+            throw e;
+          }
+        } else {
+          const modelServiceInput = input;
+          try {
+            const updateInput = new $AgentRun5__namespace.UpdateModelServiceInput({
+              ...modelServiceInput
+            });
+            const result = await this.controlApi.updateModelService({
+              modelServiceName: name,
+              input: updateInput,
+              config: cfg
+            });
+            const service = new exports.ModelService();
+            Object.assign(service, result);
+            return service;
+          } catch (e) {
+            if (e instanceof HTTPError) {
+              throw e.toResourceError("Model", name);
+            }
+            throw e;
+          }
+        }
+      };
+      /**
+       * 获取模型服务
+       * Get model service
+       *
+       * @param params - 参数 / Parameters
+       * @returns 模型服务对象 / Model service object
+       *
+       * @throws ResourceNotExistError - 模型服务不存在 / Model service does not exist
+       */
+      get = async (params) => {
+        const { name, backendType, config: config2 } = params;
+        const cfg = Config.withConfigs(this.config, config2);
+        let error = null;
+        if (backendType === "proxy" || backendType === void 0) {
+          try {
+            const result = await this.controlApi.getModelProxy({
+              modelProxyName: name,
+              config: cfg
+            });
+            const proxy = new exports.ModelProxy();
+            Object.assign(proxy, result);
+            return proxy;
+          } catch (e) {
+            if (e instanceof HTTPError) {
+              error = e;
+            } else {
+              throw e;
+            }
+          }
+        }
+        if (backendType === "proxy" && error !== null) {
+          throw error.toResourceError("Model", name);
+        }
+        try {
+          const result = await this.controlApi.getModelService({
+            modelServiceName: name,
+            config: cfg
+          });
+          const service = new exports.ModelService();
+          Object.assign(service, result);
+          return service;
+        } catch (e) {
+          if (e instanceof HTTPError) {
+            throw e.toResourceError("Model", name);
+          }
+          throw e;
+        }
+      };
+      /**
+       * 列出模型服务
+       * List model services
+       *
+       * @param params - 参数 / Parameters
+       * @returns 模型服务列表 / Model service list
+       */
+      list = async (params) => {
+        const { input, config: config2 } = params ?? {};
+        const cfg = Config.withConfigs(this.config, config2);
+        if (input && "modelProxyName" in input) {
+          const modelProxyInput = input;
+          const request = new $AgentRun5__namespace.ListModelProxiesRequest({
+            ...modelProxyInput
+          });
+          const result = await this.controlApi.listModelProxies({
+            input: request,
+            config: cfg
+          });
+          return (result.items || []).map((item) => {
+            const proxy = new exports.ModelProxy();
+            Object.assign(proxy, item);
+            return proxy;
+          });
+        } else {
+          const modelServiceInput = input ?? {};
+          const request = new $AgentRun5__namespace.ListModelServicesRequest({
+            ...modelServiceInput
+          });
+          const result = await this.controlApi.listModelServices({
+            input: request,
+            config: cfg
+          });
+          return (result.items || []).map((item) => {
+            const service = new exports.ModelService();
+            Object.assign(service, item);
+            return service;
+          });
+        }
+      };
+    };
+  }
+});
+
+// src/model/index.ts
+init_version_check();
+init_client2();
+init_model_service();
+init_model_proxy();
+init_control_api();
+init_model2();
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map