@agentrun/sdk 0.0.3 → 0.0.4

package/dist/toolset/index.js

@@ -0,0 +1,1920 @@
+import * as dotenv from 'dotenv';
+import * as $Devs from '@alicloud/devs20230714';
+import { Authorization, AuthorizationParameters, APIKeyAuthParameter, Toolset, ToolsetSpec, ToolsetSchema, ListToolsetsRequest } from '@alicloud/devs20230714';
+import * as $OpenApi from '@alicloud/openapi-client';
+import * as $Util from '@alicloud/tea-util';
+import YAML from 'js-yaml';
+
+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.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 $DevsClient, ToolControlAPI;
+var init_control = __esm({
+  "src/toolset/api/control.ts"() {
+    init_config();
+    init_exception();
+    init_log();
+    $DevsClient = // @ts-expect-error - ESM interop: default.default exists when imported as ESM namespace
+    $Devs.default?.default ?? $Devs.default ?? $Devs;
+    ToolControlAPI = class {
+      config;
+      /**
+       * Initialize API client
+       * 初始化 API 客户端
+       *
+       * @param config - Global configuration object / 全局配置对象
+       */
+      constructor(config2) {
+        this.config = config2;
+      }
+      /**
+       * Get DevS client
+       * 获取 DevS 客户端
+       */
+      getDevsClient(config2) {
+        const cfg = Config.withConfigs(this.config, config2);
+        let endpoint = cfg.devsEndpoint;
+        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
+        });
+        return new $DevsClient(openApiConfig);
+      }
+      /**
+       * Get toolset
+       * 获取工具
+       *
+       * @param name - Tool name / Tool 名称
+       * @param headers - Request headers / 请求头
+       * @param config - Configuration / 配置
+       * @returns Toolset object / ToolSet 对象
+       * @throws AgentRuntimeError - Throws on call failure / 调用失败时抛出
+       * @throws ClientError - Client error / 客户端错误
+       * @throws ServerError - Server error / 服务器错误
+       */
+      getToolset = async (params) => {
+        const { name, headers, config: config2 } = params;
+        try {
+          const client = this.getDevsClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.getToolsetWithOptions(name, headers || {}, runtime);
+          logger.debug(`API getToolset called, Request ID: ${response.body?.requestId}`);
+          if (!response.body) {
+            throw new Error("Empty response body");
+          }
+          return response.body;
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("ToolSet", name);
+          }
+          this.handleError(error, name);
+        }
+      };
+      /**
+       * List toolsets
+       * 枚举 ToolSets
+       *
+       * @param input - List configuration / 枚举的配置
+       * @param headers - Request headers / 请求头
+       * @param config - Configuration / 配置
+       * @returns ToolSet list / ToolSet 列表
+       * @throws AgentRuntimeError - Throws on call failure / 调用失败时抛出
+       * @throws ClientError - Client error / 客户端错误
+       * @throws ServerError - Server error / 服务器错误
+       */
+      listToolsets = async (params) => {
+        const { input, headers, config: config2 } = params;
+        try {
+          const client = this.getDevsClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.listToolsetsWithOptions(input, headers || {}, runtime);
+          logger.debug(
+            `API listToolsets called, Request ID: ${response?.headers?.["x-acs-request-id"]}`
+          );
+          if (!response.body) {
+            throw new Error("Empty response body");
+          }
+          return response.body;
+        } catch (error) {
+          this.handleError(error);
+        }
+      };
+      /**
+       * Create toolset
+       * 创建工具集
+       *
+       * @param input - Toolset input / ToolSet 输入
+       * @param headers - Request headers / 请求头
+       * @param config - Configuration / 配置
+       * @returns Toolset object / ToolSet 对象
+       */
+      createToolset = async (params) => {
+        const { input, headers, config: config2 } = params;
+        try {
+          const client = this.getDevsClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.createToolsetWithOptions(
+            new $Devs.CreateToolsetRequest({ body: input }),
+            headers || {},
+            runtime
+          );
+          logger.debug(`API createToolset called, Request ID: ${response.body?.requestId}`);
+          if (!response.body) {
+            throw new Error("Empty response body");
+          }
+          return response.body;
+        } catch (error) {
+          this.handleError(error, input?.name);
+        }
+      };
+      /**
+       * Update toolset
+       * 更新工具集
+       *
+       * @param name - Toolset name / ToolSet 名称
+       * @param input - Toolset input / ToolSet 输入
+       * @param headers - Request headers / 请求头
+       * @param config - Configuration / 配置
+       * @returns Toolset object / ToolSet 对象
+       */
+      updateToolset = async (params) => {
+        const { name, input, headers, config: config2 } = params;
+        try {
+          const client = this.getDevsClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.updateToolsetWithOptions(
+            name,
+            new $Devs.UpdateToolsetRequest({ body: input }),
+            headers || {},
+            runtime
+          );
+          logger.debug(`API updateToolset called, Request ID: ${response.body?.requestId}`);
+          if (!response.body) {
+            throw new Error("Empty response body");
+          }
+          return response.body;
+        } catch (error) {
+          this.handleError(error, name);
+        }
+      };
+      /**
+       * Delete toolset
+       * 删除工具集
+       *
+       * @param name - Toolset name / ToolSet 名称
+       * @param headers - Request headers / 请求头
+       * @param config - Configuration / 配置
+       * @returns Toolset object / ToolSet 对象
+       */
+      deleteToolset = async (params) => {
+        const { name, headers, config: config2 } = params;
+        try {
+          const client = this.getDevsClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.deleteToolsetWithOptions(name, headers || {}, runtime);
+          logger.debug(`API deleteToolset called, Request ID: ${response.body?.requestId}`);
+          if (!response.body) {
+            throw new Error("Empty response body");
+          }
+          return response.body;
+        } catch (error) {
+          this.handleError(error, name);
+        }
+      };
+      /**
+       * Handle API errors
+       * 处理 API 错误
+       */
+      handleError(error, _resourceName) {
+        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/toolset/api/mcp.ts
+var mcp_exports = {};
+__export(mcp_exports, {
+  MCPSession: () => MCPSession,
+  MCPToolSet: () => MCPToolSet
+});
+var MCPSession, MCPToolSet;
+var init_mcp = __esm({
+  "src/toolset/api/mcp.ts"() {
+    init_config();
+    init_log();
+    MCPSession = class {
+      url;
+      config;
+      client;
+      // Will be typed when @modelcontextprotocol/sdk is installed
+      clientSession;
+      constructor(url, config2) {
+        this.url = url;
+        this.config = Config.withConfigs(config2);
+      }
+      /**
+       * Create and initialize the session
+       * 创建并初始化会话
+       */
+      connect = async (_params) => {
+        try {
+          const { Client } = await import('@modelcontextprotocol/sdk/client/index.js');
+          const { SSEClientTransport } = await import('@modelcontextprotocol/sdk/client/sse.js');
+          const transport = new SSEClientTransport(new URL(this.url));
+          this.client = new Client(
+            {
+              name: "agentrun-nodejs-client",
+              version: "1.0.0"
+            },
+            {
+              capabilities: {}
+            }
+          );
+          await this.client.connect(transport);
+          return this.client;
+        } catch (error) {
+          logger.error("Failed to create MCP session:", error);
+          throw error;
+        }
+      };
+      /**
+       * Close the session
+       * 关闭会话
+       */
+      close = async (_params) => {
+        if (this.client) {
+          try {
+            await this.client.close();
+          } catch (error) {
+            logger.error("Failed to close MCP session:", error);
+          }
+        }
+      };
+      /**
+       * Get toolsets
+       * 获取工具集
+       */
+      toolsets(config2) {
+        const cfg = Config.withConfigs(this.config, config2);
+        return new MCPToolSet(this.url + "/toolsets", cfg);
+      }
+    };
+    MCPToolSet = class {
+      url;
+      config;
+      constructor(url, config2) {
+        this.url = url;
+        this.config = Config.withConfigs(config2);
+      }
+      /**
+       * Create a new session
+       * 创建新会话
+       */
+      newSession(config2) {
+        const cfg = Config.withConfigs(this.config, config2);
+        return new MCPSession(this.url, cfg);
+      }
+      /**
+       * List available tools (async)
+       * 列出可用工具（异步）
+       */
+      toolsAsync = async (params) => {
+        const session = this.newSession(params?.config);
+        try {
+          const client = await session.connect();
+          const result = await client.listTools();
+          return result.tools || [];
+        } finally {
+          await session.close();
+        }
+      };
+      /**
+       * List available tools (sync wrapper)
+       * 列出可用工具（同步包装）
+       *
+       * Note: This is a convenience method that wraps the async version.
+       * In Node.js, prefer using toolsAsync() directly.
+       */
+      tools(config2) {
+        return this.toolsAsync({ config: config2 });
+      }
+      /**
+       * Call a tool (async)
+       * 调用工具（异步）
+       */
+      callToolAsync = async (name, args, config2) => {
+        const session = this.newSession(config2);
+        try {
+          const client = await session.connect();
+          const result = await client.callTool({
+            name,
+            arguments: args || {}
+          });
+          if (result.content && Array.isArray(result.content)) {
+            return result.content.map((item) => {
+              if (typeof item === "object" && item !== null) {
+                if (typeof item.toJSON === "function") {
+                  return item.toJSON();
+                }
+                return { ...item };
+              }
+              return item;
+            });
+          }
+          return result.content || [];
+        } finally {
+          await session.close();
+        }
+      };
+      /**
+       * Call a tool (sync wrapper)
+       * 调用工具（同步包装）
+       *
+       * Note: This is a convenience method that wraps the async version.
+       * In Node.js, prefer using callToolAsync() directly.
+       */
+      callTool(name, args, config2) {
+        return this.callToolAsync(name, args, config2);
+      }
+    };
+  }
+});
+
+// src/toolset/api/index.ts
+var init_api = __esm({
+  "src/toolset/api/index.ts"() {
+    init_version_check();
+    init_control();
+    init_mcp();
+  }
+});
+
+// src/utils/model.ts
+var init_model = __esm({
+  "src/utils/model.ts"() {
+  }
+});
+
+// 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 init_resource = __esm({
+  "src/utils/resource.ts"() {
+    init_exception();
+    init_log();
+    init_model();
+  }
+});
+
+// src/toolset/model.ts
+var model_exports = {};
+__export(model_exports, {
+  ToolInfo: () => ToolInfo,
+  ToolSchema: () => ToolSchema,
+  ToolSetSchemaType: () => ToolSetSchemaType
+});
+var ToolSetSchemaType, ToolSchema, ToolInfo;
+var init_model2 = __esm({
+  "src/toolset/model.ts"() {
+    ToolSetSchemaType = /* @__PURE__ */ ((ToolSetSchemaType2) => {
+      ToolSetSchemaType2["OPENAPI"] = "OpenAPI";
+      ToolSetSchemaType2["MCP"] = "MCP";
+      return ToolSetSchemaType2;
+    })(ToolSetSchemaType || {});
+    ToolSchema = class _ToolSchema {
+      // Basic fields / 基本字段
+      type;
+      description;
+      title;
+      // Object type fields / 对象类型字段
+      properties;
+      required;
+      additionalProperties;
+      // Array type fields / 数组类型字段
+      items;
+      minItems;
+      maxItems;
+      // String type fields / 字符串类型字段
+      pattern;
+      minLength;
+      maxLength;
+      format;
+      // date, date-time, email, uri, etc.
+      enum;
+      // Number type fields / 数值类型字段
+      minimum;
+      maximum;
+      exclusiveMinimum;
+      exclusiveMaximum;
+      // Union types / 联合类型
+      anyOf;
+      oneOf;
+      allOf;
+      // Default value / 默认值
+      default;
+      constructor(data) {
+        if (data) {
+          Object.assign(this, data);
+        }
+      }
+      /**
+       * Create ToolSchema from any OpenAPI/JSON Schema
+       * 从任意 OpenAPI/JSON Schema 创建 ToolSchema
+       *
+       * Recursively parses all nested structures, preserving complete schema information.
+       * 递归解析所有嵌套结构，保留完整的 schema 信息。
+       */
+      static fromAnyOpenAPISchema(schema) {
+        if (!schema || typeof schema !== "object") {
+          return new _ToolSchema({ type: "string" });
+        }
+        const s = schema;
+        const propertiesRaw = s.properties;
+        const properties = propertiesRaw ? Object.fromEntries(
+          Object.entries(propertiesRaw).map(([key, value]) => [
+            key,
+            _ToolSchema.fromAnyOpenAPISchema(value)
+          ])
+        ) : void 0;
+        const itemsRaw = s.items;
+        const items = itemsRaw ? _ToolSchema.fromAnyOpenAPISchema(itemsRaw) : void 0;
+        const anyOfRaw = s.anyOf;
+        const anyOf = anyOfRaw ? anyOfRaw.map(_ToolSchema.fromAnyOpenAPISchema) : void 0;
+        const oneOfRaw = s.oneOf;
+        const oneOf = oneOfRaw ? oneOfRaw.map(_ToolSchema.fromAnyOpenAPISchema) : void 0;
+        const allOfRaw = s.allOf;
+        const allOf = allOfRaw ? allOfRaw.map(_ToolSchema.fromAnyOpenAPISchema) : void 0;
+        return new _ToolSchema({
+          // Basic fields
+          type: s.type,
+          description: s.description,
+          title: s.title,
+          // Object type
+          properties,
+          required: s.required,
+          additionalProperties: s.additionalProperties,
+          // Array type
+          items,
+          minItems: s.minItems,
+          maxItems: s.maxItems,
+          // String type
+          pattern: s.pattern,
+          minLength: s.minLength,
+          maxLength: s.maxLength,
+          format: s.format,
+          enum: s.enum,
+          // Number type
+          minimum: s.minimum,
+          maximum: s.maximum,
+          exclusiveMinimum: s.exclusiveMinimum,
+          exclusiveMaximum: s.exclusiveMaximum,
+          // Union types
+          anyOf,
+          oneOf,
+          allOf,
+          // Default value
+          default: s.default
+        });
+      }
+      /**
+       * Convert to standard JSON Schema format
+       * 转换为标准 JSON Schema 格式
+       */
+      toJSONSchema() {
+        const result = {};
+        if (this.type !== void 0) result.type = this.type;
+        if (this.description !== void 0) result.description = this.description;
+        if (this.title !== void 0) result.title = this.title;
+        if (this.properties) {
+          result.properties = Object.fromEntries(
+            Object.entries(this.properties).map(([k, v]) => [k, v.toJSONSchema()])
+          );
+        }
+        if (this.required) result.required = this.required;
+        if (this.additionalProperties !== void 0) {
+          result.additionalProperties = this.additionalProperties;
+        }
+        if (this.items) result.items = this.items.toJSONSchema();
+        if (this.minItems !== void 0) result.minItems = this.minItems;
+        if (this.maxItems !== void 0) result.maxItems = this.maxItems;
+        if (this.pattern) result.pattern = this.pattern;
+        if (this.minLength !== void 0) result.minLength = this.minLength;
+        if (this.maxLength !== void 0) result.maxLength = this.maxLength;
+        if (this.format) result.format = this.format;
+        if (this.enum) result.enum = this.enum;
+        if (this.minimum !== void 0) result.minimum = this.minimum;
+        if (this.maximum !== void 0) result.maximum = this.maximum;
+        if (this.exclusiveMinimum !== void 0) {
+          result.exclusiveMinimum = this.exclusiveMinimum;
+        }
+        if (this.exclusiveMaximum !== void 0) {
+          result.exclusiveMaximum = this.exclusiveMaximum;
+        }
+        if (this.anyOf) result.anyOf = this.anyOf.map((s) => s.toJSONSchema());
+        if (this.oneOf) result.oneOf = this.oneOf.map((s) => s.toJSONSchema());
+        if (this.allOf) result.allOf = this.allOf.map((s) => s.toJSONSchema());
+        if (this.default !== void 0) result.default = this.default;
+        return result;
+      }
+    };
+    ToolInfo = class _ToolInfo {
+      name;
+      description;
+      parameters;
+      constructor(data) {
+        if (data) {
+          this.name = data.name;
+          this.description = data.description;
+          this.parameters = data.parameters;
+        }
+      }
+      /**
+       * Create ToolInfo from MCP tool
+       * 从 MCP tool 创建 ToolInfo
+       */
+      static fromMCPTool(tool) {
+        if (!tool) {
+          throw new Error("MCP tool is required");
+        }
+        let toolName;
+        let toolDescription;
+        let inputSchema;
+        if (typeof tool === "object" && tool !== null) {
+          const t = tool;
+          if ("name" in t) {
+            toolName = t.name;
+            toolDescription = t.description;
+            inputSchema = t.inputSchema || t.input_schema;
+          } else {
+            throw new Error(`Unsupported MCP tool format: ${typeof tool}`);
+          }
+        } else {
+          throw new Error(`Unsupported MCP tool format: ${typeof tool}`);
+        }
+        if (!toolName) {
+          throw new Error("MCP tool must have a name");
+        }
+        let parameters;
+        if (inputSchema) {
+          parameters = ToolSchema.fromAnyOpenAPISchema(inputSchema);
+        }
+        return new _ToolInfo({
+          name: toolName,
+          description: toolDescription,
+          parameters: parameters || new ToolSchema({ type: "object", properties: {} })
+        });
+      }
+    };
+  }
+});
+
+// src/toolset/openapi.ts
+var openapi_exports = {};
+__export(openapi_exports, {
+  ApiSet: () => ApiSet,
+  OpenAPI: () => OpenAPI
+});
+var OpenAPI, ApiSet;
+var init_openapi = __esm({
+  "src/toolset/openapi.ts"() {
+    init_config();
+    init_log();
+    OpenAPI = class {
+      _schema;
+      _baseUrl;
+      _defaultHeaders;
+      _defaultQueryParams;
+      _config;
+      _tools = /* @__PURE__ */ new Map();
+      constructor(options) {
+        if (typeof options.schema === "string") {
+          try {
+            this._schema = YAML.load(options.schema);
+          } catch {
+            this._schema = JSON.parse(options.schema);
+          }
+        } else {
+          this._schema = JSON.parse(JSON.stringify(options.schema));
+        }
+        this._resolveAllRefs();
+        this._baseUrl = options.baseUrl || this._extractBaseUrl();
+        this._defaultHeaders = options.headers ? { ...options.headers } : {};
+        this._defaultQueryParams = options.queryParams ? { ...options.queryParams } : {};
+        this._config = options.config;
+        this._parseTools();
+      }
+      /**
+       * Get the parsed schema
+       */
+      get schema() {
+        return this._schema;
+      }
+      /**
+       * Get all parsed tools
+       */
+      get tools() {
+        return Array.from(this._tools.values());
+      }
+      /**
+       * Get a specific tool by name
+       */
+      getTool(name) {
+        return this._tools.get(name);
+      }
+      /**
+       * Invoke a tool
+       */
+      invokeToolAsync = async (name, args = {}, _config) => {
+        const tool = this._tools.get(name);
+        if (!tool) {
+          throw new Error(`Tool '${name}' not found.`);
+        }
+        const method = (tool.method || "get").toUpperCase();
+        let path = tool.path || "/";
+        const queryParams = {
+          ...this._defaultQueryParams
+        };
+        const headerParams = { ...this._defaultHeaders };
+        let bodyContent = void 0;
+        for (const [key, value] of Object.entries(args)) {
+          if (key === "body") {
+            bodyContent = value;
+          } else if (path.includes(`{${key}}`)) {
+            path = path.replace(`{${key}}`, String(value));
+          } else if (typeof value === "string" && key.startsWith("X-")) {
+            headerParams[key] = value;
+          } else {
+            queryParams[key] = value;
+          }
+        }
+        const url = new URL(path, this._baseUrl);
+        for (const [key, value] of Object.entries(queryParams)) {
+          if (value !== void 0 && value !== null) {
+            url.searchParams.set(key, String(value));
+          }
+        }
+        try {
+          const fetchOptions = {
+            method,
+            headers: {
+              "Content-Type": "application/json",
+              ...headerParams
+            }
+          };
+          if (bodyContent && ["POST", "PUT", "PATCH"].includes(method)) {
+            fetchOptions.body = JSON.stringify(bodyContent);
+          }
+          const response = await fetch(url.toString(), fetchOptions);
+          const responseClone = response.clone();
+          let responseBody;
+          try {
+            responseBody = await response.json();
+          } catch {
+            responseBody = await responseClone.text();
+          }
+          return {
+            status_code: response.status,
+            headers: Object.fromEntries(response.headers.entries()),
+            body: responseBody
+          };
+        } catch (error) {
+          return {
+            status_code: 0,
+            error: error instanceof Error ? error.message : String(error)
+          };
+        }
+      };
+      /**
+       * Synchronous invoke (wrapper for async)
+       */
+      invokeToolSync(_name, _args = {}) {
+        throw new Error(
+          "Synchronous invocation is not supported in Node.js. Use invokeToolAsync instead."
+        );
+      }
+      // Alias for Python compatibility
+      invoke_tool = (name, args = {}, _config) => {
+        return this.invokeToolAsync(name, args);
+      };
+      /**
+       * Extract base URL from schema
+       */
+      _extractBaseUrl() {
+        const servers = this._schema.servers;
+        if (servers && servers.length > 0) {
+          return servers[0].url;
+        }
+        return "";
+      }
+      /**
+       * Resolve all $ref references in the schema
+       */
+      _resolveAllRefs() {
+        this._schema = this._resolveRefs(this._schema, this._schema);
+      }
+      /**
+       * Recursively resolve $ref references
+       */
+      _resolveRefs(obj, root) {
+        if (obj === null || obj === void 0) {
+          return obj;
+        }
+        if (Array.isArray(obj)) {
+          return obj.map((item) => this._resolveRefs(item, root));
+        }
+        if (typeof obj === "object") {
+          const result = {};
+          const objRecord = obj;
+          if ("$ref" in objRecord && typeof objRecord.$ref === "string") {
+            const refPath = objRecord.$ref;
+            const resolved = this._resolveRef(refPath, root);
+            const resolvedDeep = this._resolveRefs(resolved, root);
+            if (typeof resolvedDeep === "object" && resolvedDeep !== null) {
+              Object.assign(result, resolvedDeep);
+            }
+            for (const [key, value] of Object.entries(objRecord)) {
+              if (key !== "$ref") {
+                result[key] = this._resolveRefs(value, root);
+              }
+            }
+            return result;
+          }
+          for (const [key, value] of Object.entries(objRecord)) {
+            result[key] = this._resolveRefs(value, root);
+          }
+          return result;
+        }
+        return obj;
+      }
+      /**
+       * Resolve a single $ref path
+       */
+      _resolveRef(refPath, root) {
+        if (!refPath.startsWith("#/")) {
+          logger.warn(`External $ref not supported: ${refPath}`);
+          return {};
+        }
+        const path = refPath.substring(2).split("/");
+        let current = root;
+        for (const part of path) {
+          if (current === null || current === void 0) {
+            return {};
+          }
+          if (typeof current === "object" && !Array.isArray(current)) {
+            current = current[part];
+          } else {
+            return {};
+          }
+        }
+        return current;
+      }
+      /**
+       * Parse tools from OpenAPI paths
+       */
+      _parseTools() {
+        const paths = this._schema.paths;
+        if (!paths) {
+          return;
+        }
+        for (const [path, pathItem] of Object.entries(paths)) {
+          if (typeof pathItem !== "object" || pathItem === null) {
+            continue;
+          }
+          for (const [method, operation] of Object.entries(pathItem)) {
+            if (!["get", "post", "put", "patch", "delete", "options", "head"].includes(method)) {
+              continue;
+            }
+            if (typeof operation !== "object" || operation === null) {
+              continue;
+            }
+            const op = operation;
+            const operationId = op.operationId;
+            if (!operationId) {
+              continue;
+            }
+            const parameters = this._parseParameters(op, path);
+            const tool = {
+              name: operationId,
+              description: op.summary || op.description,
+              parameters,
+              operationId,
+              method,
+              path
+            };
+            this._tools.set(operationId, tool);
+          }
+        }
+      }
+      /**
+       * Parse operation parameters into a schema
+       */
+      _parseParameters(operation, _path) {
+        const result = {
+          type: "object",
+          properties: {},
+          required: []
+        };
+        const params = operation.parameters;
+        if (params && Array.isArray(params)) {
+          for (const param of params) {
+            const name = param.name;
+            const schema = param.schema;
+            const required = param.required;
+            if (!name) continue;
+            result.properties[name] = {
+              type: schema?.type || "string",
+              description: param.description || void 0,
+              ...schema
+            };
+            if (required) {
+              result.required.push(name);
+            }
+          }
+        }
+        const requestBody = operation.requestBody;
+        if (requestBody) {
+          const content = requestBody.content;
+          if (content) {
+            const jsonContent = content["application/json"];
+            if (jsonContent && jsonContent.schema) {
+              result.properties["body"] = jsonContent.schema;
+              if (requestBody.required) {
+                result.required.push("body");
+              }
+            }
+          }
+        }
+        return result;
+      }
+    };
+    ApiSet = class _ApiSet {
+      _tools;
+      _invoker;
+      // Can be OpenAPI or MCP invoker
+      _baseUrl;
+      _defaultHeaders;
+      _defaultQueryParams;
+      _baseConfig;
+      constructor(tools, invoker, baseUrl, headers, queryParams, config2) {
+        this._tools = new Map(tools.filter((t) => t.name).map((t) => [t.name, t]));
+        this._invoker = invoker;
+        this._baseUrl = baseUrl;
+        this._defaultHeaders = headers ? { ...headers } : {};
+        this._defaultQueryParams = queryParams ? { ...queryParams } : {};
+        this._baseConfig = config2;
+      }
+      /**
+       * Invoke a tool by name
+       * 调用指定的工具
+       */
+      invoke = async (name, args = {}, config2) => {
+        if (!this._tools.has(name)) {
+          throw new Error(`Tool '${name}' not found.`);
+        }
+        const convertedArgs = this._convertArguments(args);
+        const effectiveConfig = Config.withConfigs(this._baseConfig, config2);
+        if (typeof this._invoker.invokeToolAsync === "function") {
+          return await this._invoker.invokeToolAsync(name, convertedArgs, effectiveConfig);
+        } else if (typeof this._invoker.invoke_tool === "function") {
+          return await this._invoker.invoke_tool(name, convertedArgs, effectiveConfig);
+        } else if (typeof this._invoker === "function") {
+          return await this._invoker(name, convertedArgs);
+        } else {
+          throw new Error("Invalid invoker provided.");
+        }
+      };
+      /**
+       * Get all tools
+       * 返回所有工具列表
+       */
+      get tools() {
+        return Array.from(this._tools.values());
+      }
+      /**
+       * Get a specific tool
+       * 获取指定名称的工具
+       */
+      getTool(name) {
+        return this._tools.get(name);
+      }
+      /**
+       * Convert arguments from framework-specific types to native JavaScript types
+       * 将常见框架类型转换为 JavaScript 原生类型
+       *
+       * Purpose: Ensure we send JSON-serializable data to OpenAPI
+       * 目的：确保我们发送到 OpenAPI 的 JSON body 是可以被序列化的
+       */
+      _convertToNative(value) {
+        if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+          return value;
+        }
+        if (Array.isArray(value)) {
+          return value.map((item) => this._convertToNative(item));
+        }
+        if (typeof value === "object") {
+          const obj = value;
+          if (typeof obj.toJSON === "function") {
+            try {
+              return this._convertToNative(obj.toJSON());
+            } catch {
+            }
+          }
+          const result = {};
+          for (const [k, v] of Object.entries(obj)) {
+            result[k] = this._convertToNative(v);
+          }
+          return result;
+        }
+        return value;
+      }
+      /**
+       * Convert arguments dictionary
+       * 转换参数字典
+       */
+      _convertArguments(args) {
+        if (!args || typeof args !== "object") {
+          return args;
+        }
+        const result = {};
+        for (const [k, v] of Object.entries(args)) {
+          result[k] = this._convertToNative(v);
+        }
+        return result;
+      }
+      /**
+       * Create ApiSet from MCP tools
+       * 从 MCP tools 创建 ApiSet
+       *
+       * @param tools - MCP tools list or single tool / MCP tools 列表或单个工具
+       * @param mcpClient - MCP client (MCPToolSet instance) / MCP 客户端（MCPToolSet 实例）
+       * @param config - Configuration object / 配置对象
+       */
+      static fromMCPTools(params) {
+        const { tools, mcpClient, config: config2 } = params;
+        const toolInfos = [];
+        let toolArray;
+        if (Array.isArray(tools)) {
+          toolArray = tools;
+        } else if (tools) {
+          toolArray = [tools];
+        } else {
+          toolArray = [];
+        }
+        for (const tool of toolArray) {
+          if (!tool) {
+            continue;
+          }
+          try {
+            const { ToolInfo: ToolInfo2 } = (init_model2(), __toCommonJS(model_exports));
+            const toolInfo = ToolInfo2.fromMCPTool(tool);
+            toolInfos.push(toolInfo);
+          } catch (error) {
+            logger.warn(`Failed to parse MCP tool:`, error);
+            continue;
+          }
+        }
+        class MCPInvoker {
+          constructor(mcpClient2, config3) {
+            this.mcpClient = mcpClient2;
+            this.config = config3;
+          }
+          invokeToolAsync = async (name, args, config3) => {
+            const cfg = Config.withConfigs(this.config, config3);
+            return await this.mcpClient.callToolAsync(name, args, cfg);
+          };
+        }
+        const invoker = new MCPInvoker(mcpClient, config2);
+        return new _ApiSet(toolInfos, invoker, void 0, void 0, void 0, config2);
+      }
+    };
+  }
+});
+
+// src/toolset/toolset.ts
+var ToolSet;
+var init_toolset = __esm({
+  "src/toolset/toolset.ts"() {
+    init_config();
+    init_log();
+    init_resource();
+    ToolSet = class _ToolSet {
+      name;
+      uid;
+      kind;
+      description;
+      createdTime;
+      generation;
+      labels;
+      spec;
+      status;
+      _config;
+      constructor(data, config2) {
+        if (data) {
+          updateObjectProperties(this, data);
+        }
+        this._config = config2;
+      }
+      /**
+       * Get DevS client
+       */
+      static getClient() {
+        const { ToolSetClient: ToolSetClient2 } = (init_client(), __toCommonJS(client_exports));
+        return new ToolSetClient2();
+      }
+      uniqIdCallback = () => this.name;
+      /**
+       * Create a new ToolSet
+       */
+      static async create(params) {
+        const { input, config: config2 } = params;
+        return await _ToolSet.getClient().create({ input, config: config2 });
+      }
+      /**
+       * Delete a ToolSet by Name
+       */
+      static async delete(params) {
+        const { name, config: config2 } = params;
+        return await _ToolSet.getClient().delete({ name, config: config2 });
+      }
+      /**
+       * Get a ToolSet by Name
+       */
+      static async get(params) {
+        const { name, config: config2 } = params;
+        return await _ToolSet.getClient().get({ name, config: config2 });
+      }
+      /**
+       * List ToolSets
+       */
+      static list = async (...args) => {
+        let input;
+        let config2;
+        if (args.length >= 1 && "input" in args[0]) {
+          input = args[0].input;
+        } else {
+          input = args[0];
+        }
+        if (args.length >= 1 && "config" in args[0]) {
+          config2 = args[0].config;
+        } else if (args.length > 1 && args[1] instanceof Config) {
+          config2 = args[1];
+        }
+        return await this.getClient().list({
+          input: {
+            ...input
+          },
+          config: config2
+        });
+      };
+      static listAll = async (...args) => {
+        let input;
+        let config2;
+        if (args.length >= 1 && "input" in args[0]) {
+          input = args[0].input;
+        } else {
+          input = args[0];
+        }
+        if (args.length >= 1 && "config" in args[0]) {
+          config2 = args[0].config;
+        } else if (args.length > 1 && args[1] instanceof Config) {
+          config2 = args[1];
+        }
+        return await listAllResourcesFunction(this.list)({ ...input, config: config2 });
+      };
+      /**
+       * Update a ToolSet by Name
+       */
+      static async update(params) {
+        const { name, input, config: config2 } = params;
+        return await _ToolSet.getClient().update({ name, input, config: config2 });
+      }
+      /**
+       * Delete this toolset
+       */
+      delete = async (params) => {
+        const config2 = params?.config;
+        if (!this.name) {
+          throw new Error("name is required to delete a ToolSet");
+        }
+        const result = await _ToolSet.delete({
+          name: this.name,
+          config: config2 ?? this._config
+        });
+        updateObjectProperties(this, result);
+        return this;
+      };
+      /**
+       * Update this toolset
+       */
+      update = async (params) => {
+        const { input, config: config2 } = params;
+        if (!this.name) {
+          throw new Error("name is required to update a ToolSet");
+        }
+        const result = await _ToolSet.update({
+          name: this.name,
+          input,
+          config: config2 ?? this._config
+        });
+        updateObjectProperties(this, result);
+        return this;
+      };
+      /**
+       * Refresh this toolset's data
+       */
+      refresh = async (params) => {
+        const config2 = params?.config;
+        if (!this.name) {
+          throw new Error("name is required to refresh a ToolSet");
+        }
+        const result = await _ToolSet.get({
+          name: this.name,
+          config: config2 ?? this._config
+        });
+        updateObjectProperties(this, result);
+        return this;
+      };
+      /**
+       * Get toolset type
+       * 获取工具集类型
+       */
+      type() {
+        return this.spec?.schema?.type;
+      }
+      /**
+       * List tools (async)
+       * 异步获取工具列表，返回统一的 ToolInfo 列表
+       */
+      listToolsAsync = async (params) => {
+        const { ToolSetSchemaType: ToolSetSchemaType2 } = (init_model2(), __toCommonJS(model_exports));
+        const { ToolInfo: ToolInfo2 } = (init_model2(), __toCommonJS(model_exports));
+        if (this.type() === ToolSetSchemaType2.MCP) {
+          const mcpTools = this.status?.outputs?.tools || [];
+          return mcpTools.map((tool) => ToolInfo2.fromMCPTool(tool));
+        } else if (this.type() === ToolSetSchemaType2.OPENAPI) {
+          const apiset = await this.toApiSet(params);
+          return apiset.tools;
+        }
+        return [];
+      };
+      /**
+       * List tools (sync wrapper)
+       * 同步获取工具列表，返回统一的 ToolInfo 列表
+       */
+      listTools = (config2) => {
+        return this.listToolsAsync({ config: config2 });
+      };
+      /**
+       * Call tool (async)
+       * 异步调用工具，统一使用 ApiSet 实现
+       */
+      callToolAsync = async (name, args, config2) => {
+        const apiset = await this.toApiSet({ config: config2 });
+        const { ToolSetSchemaType: ToolSetSchemaType2 } = (init_model2(), __toCommonJS(model_exports));
+        if (this.type() === ToolSetSchemaType2.OPENAPI) {
+          const tool = apiset.getTool(name);
+          if (!tool) {
+            const openApiTools = this.status?.outputs?.openApiTools || [];
+            for (const toolMeta of openApiTools) {
+              if (!toolMeta) continue;
+              if (toolMeta.toolId === name || toolMeta.tool_id === name) {
+                name = toolMeta.toolName || toolMeta.tool_name || name;
+                break;
+              }
+            }
+          }
+        }
+        logger.debug(`Invoke tool ${name} with arguments`, args);
+        const result = await apiset.invoke(name, args, config2);
+        logger.debug(`Invoke tool ${name} got result`, result);
+        return result;
+      };
+      /**
+       * Call tool (sync wrapper)
+       * 同步调用工具，统一使用 ApiSet 实现
+       */
+      callTool = (name, args, config2) => {
+        return this.callToolAsync(name, args, config2);
+      };
+      /**
+       * Convert ToolSet to unified ApiSet object
+       * 将 ToolSet 转换为统一的 ApiSet 对象
+       */
+      toApiSet = async (params) => {
+        const { ApiSet: ApiSet2 } = (init_openapi(), __toCommonJS(openapi_exports));
+        const { ToolSetSchemaType: ToolSetSchemaType2 } = (init_model2(), __toCommonJS(model_exports));
+        if (this.type() === ToolSetSchemaType2.MCP) {
+          const { MCPToolSet: MCPToolSet2 } = (init_mcp(), __toCommonJS(mcp_exports));
+          const mcpServerConfig = this.status?.outputs?.mcpServerConfig;
+          if (!mcpServerConfig?.url) {
+            throw new Error("MCP server URL is missing.");
+          }
+          const cfg = Config.withConfigs(
+            params?.config,
+            new Config({ headers: mcpServerConfig.headers })
+          );
+          const mcpClient = new MCPToolSet2(mcpServerConfig.url, cfg);
+          const mcpTools = this.status?.outputs?.tools || [];
+          return ApiSet2.fromMCPTools({
+            tools: mcpTools,
+            mcpClient,
+            config: cfg
+          });
+        } else if (this.type() === ToolSetSchemaType2.OPENAPI) {
+          const headers = this._getOpenAPIAuthDefaults().headers;
+          const query = this._getOpenAPIAuthDefaults().query;
+          const { OpenAPI: OpenAPI2 } = (init_openapi(), __toCommonJS(openapi_exports));
+          const openapi = new OpenAPI2({
+            schema: this.spec?.schema?.detail || "{}",
+            baseUrl: this._getOpenAPIBaseUrl(),
+            headers,
+            queryParams: query,
+            config: params?.config
+          });
+          const { ToolInfo: ToolInfo2 } = (init_model2(), __toCommonJS(model_exports));
+          const tools = openapi.tools.map(
+            (t) => new ToolInfo2({
+              name: t.name,
+              description: t.description,
+              parameters: t.parameters
+            })
+          );
+          return new ApiSet2(tools, openapi, void 0, headers, query, params?.config);
+        }
+        throw new Error(`Unsupported ToolSet type: ${this.type()}`);
+      };
+      /**
+       * Get OpenAPI authentication defaults
+       * 获取 OpenAPI 认证默认值
+       */
+      _getOpenAPIAuthDefaults() {
+        const headers = {};
+        const query = {};
+        const authConfig = this.spec?.authConfig;
+        const authType = authConfig?.type;
+        if (authType === "APIKey") {
+          const key = authConfig?.apiKeyHeaderName;
+          const value = authConfig?.apiKeyValue;
+          if (key && value) {
+            {
+              headers[key] = value;
+            }
+          }
+        }
+        return { headers, query };
+      }
+      /**
+       * Get OpenAPI base URL
+       * 获取 OpenAPI 基础 URL
+       */
+      _getOpenAPIBaseUrl() {
+        const outputs = this.status?.outputs;
+        return outputs?.urls?.internetUrl || outputs?.urls?.intranetUrl;
+      }
+    };
+  }
+});
+
+// src/toolset/client.ts
+var client_exports = {};
+__export(client_exports, {
+  ToolSetClient: () => ToolSetClient
+});
+var ToolSetClient;
+var init_client = __esm({
+  "src/toolset/client.ts"() {
+    init_config();
+    init_exception();
+    init_api();
+    init_toolset();
+    ToolSetClient = class {
+      config;
+      controlApi;
+      constructor(config2) {
+        this.config = config2;
+        this.controlApi = new ToolControlAPI(config2);
+      }
+      /**
+       * Create a ToolSet
+       */
+      create = async (params) => {
+        const { input, config: config2 } = params;
+        const cfg = Config.withConfigs(this.config, config2);
+        try {
+          const authConfig = input.spec?.authConfig ? new Authorization({
+            type: input.spec.authConfig.type,
+            parameters: new AuthorizationParameters({
+              apiKeyParameter: new APIKeyAuthParameter({
+                key: input.spec.authConfig.apiKeyHeaderName,
+                value: input.spec.authConfig.apiKeyValue,
+                in: "header"
+              })
+            })
+          }) : void 0;
+          const request = new Toolset({
+            ...input,
+            spec: input.spec ? new ToolsetSpec({
+              ...input.spec,
+              schema: input.spec.schema ? new ToolsetSchema({
+                ...input.spec.schema
+              }) : void 0,
+              authConfig
+            }) : void 0
+          });
+          const result = await this.controlApi.createToolset({
+            input: request,
+            config: cfg
+          });
+          return new ToolSet(result, cfg);
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("ToolSet", input.name);
+          }
+          throw error;
+        }
+      };
+      /**
+       * Delete a ToolSet by name
+       */
+      delete = async (params) => {
+        const { name, config: config2 } = params;
+        const cfg = Config.withConfigs(this.config, config2);
+        try {
+          const result = await this.controlApi.deleteToolset({
+            name,
+            config: cfg
+          });
+          return new ToolSet(result, cfg);
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("ToolSet", name);
+          }
+          throw error;
+        }
+      };
+      /**
+       * Update a ToolSet by name
+       */
+      update = async (params) => {
+        const { name, input, config: config2 } = params;
+        const cfg = Config.withConfigs(this.config, config2);
+        try {
+          const authConfig = input.spec?.authConfig ? new Authorization({
+            type: input.spec.authConfig.type,
+            parameters: new AuthorizationParameters({
+              apiKeyParameter: new APIKeyAuthParameter({
+                key: input.spec.authConfig.apiKeyHeaderName,
+                value: input.spec.authConfig.apiKeyValue,
+                in: "header"
+              })
+            })
+          }) : void 0;
+          const request = new Toolset({
+            name,
+            ...input,
+            spec: input.spec ? new ToolsetSpec({
+              ...input.spec,
+              schema: input.spec.schema ? new ToolsetSchema({
+                ...input.spec.schema
+              }) : void 0,
+              authConfig
+            }) : void 0
+          });
+          const result = await this.controlApi.updateToolset({
+            name,
+            input: request,
+            config: cfg
+          });
+          return new ToolSet(result, cfg);
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("ToolSet", name);
+          }
+          throw error;
+        }
+      };
+      /**
+       * Get a ToolSet by name
+       */
+      get = async (params) => {
+        const { name, config: config2 } = params;
+        const cfg = Config.withConfigs(this.config, config2);
+        try {
+          const result = await this.controlApi.getToolset({
+            name,
+            config: cfg
+          });
+          return new ToolSet(result, cfg);
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("ToolSet", name);
+          }
+          throw error;
+        }
+      };
+      /**
+       * List ToolSets
+       */
+      list = async (params) => {
+        const { input, config: config2 } = params ?? {};
+        const cfg = Config.withConfigs(this.config, config2);
+        const results = await this.controlApi.listToolsets({
+          input: new ListToolsetsRequest({ ...input }),
+          config: cfg
+        });
+        return results.data?.map((result) => new ToolSet(result, cfg)) || [];
+      };
+    };
+  }
+});
+
+// src/toolset/index.ts
+init_version_check();
+init_client();
+init_toolset();
+init_openapi();
+init_model2();
+init_control();
+init_mcp();
+
+export { ApiSet, MCPSession, MCPToolSet, OpenAPI, ToolControlAPI, ToolInfo, ToolSchema, ToolSet, ToolSetClient, ToolSetSchemaType };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map