@agentrun/sdk 0.0.3 → 0.0.4

package/dist/toolset/api/index.cjs

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