wuying-agentbay-sdk 0.1.0 → 0.3.0

package/dist/index.mjs

@@ -0,0 +1,4550 @@
+
+        if (typeof OpenApi !== 'undefined' && !OpenApi.default) {
+          OpenApi.default = OpenApi;
+        }
+        
+        import { createRequire } from 'module';
+        const require = createRequire(import.meta.url);
+          (function() {
+            if (typeof OpenApi !== 'undefined' && !OpenApi.default) {
+              OpenApi.default = OpenApi;
+            }
+          })();
+        
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/dotenv/package.json
+var require_package = __commonJS({
+  "node_modules/dotenv/package.json"(exports, module) {
+    module.exports = {
+      name: "dotenv",
+      version: "16.5.0",
+      description: "Loads environment variables from .env file",
+      main: "lib/main.js",
+      types: "lib/main.d.ts",
+      exports: {
+        ".": {
+          types: "./lib/main.d.ts",
+          require: "./lib/main.js",
+          default: "./lib/main.js"
+        },
+        "./config": "./config.js",
+        "./config.js": "./config.js",
+        "./lib/env-options": "./lib/env-options.js",
+        "./lib/env-options.js": "./lib/env-options.js",
+        "./lib/cli-options": "./lib/cli-options.js",
+        "./lib/cli-options.js": "./lib/cli-options.js",
+        "./package.json": "./package.json"
+      },
+      scripts: {
+        "dts-check": "tsc --project tests/types/tsconfig.json",
+        lint: "standard",
+        pretest: "npm run lint && npm run dts-check",
+        test: "tap run --allow-empty-coverage --disable-coverage --timeout=60000",
+        "test:coverage": "tap run --show-full-coverage --timeout=60000 --coverage-report=lcov",
+        prerelease: "npm test",
+        release: "standard-version"
+      },
+      repository: {
+        type: "git",
+        url: "git://github.com/motdotla/dotenv.git"
+      },
+      homepage: "https://github.com/motdotla/dotenv#readme",
+      funding: "https://dotenvx.com",
+      keywords: [
+        "dotenv",
+        "env",
+        ".env",
+        "environment",
+        "variables",
+        "config",
+        "settings"
+      ],
+      readmeFilename: "README.md",
+      license: "BSD-2-Clause",
+      devDependencies: {
+        "@types/node": "^18.11.3",
+        decache: "^4.6.2",
+        sinon: "^14.0.1",
+        standard: "^17.0.0",
+        "standard-version": "^9.5.0",
+        tap: "^19.2.0",
+        typescript: "^4.8.4"
+      },
+      engines: {
+        node: ">=12"
+      },
+      browser: {
+        fs: false
+      }
+    };
+  }
+});
+
+// node_modules/dotenv/lib/main.js
+var require_main = __commonJS({
+  "node_modules/dotenv/lib/main.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    var fs2 = __require("fs");
+    var path3 = __require("path");
+    var os = __require("os");
+    var crypto = __require("crypto");
+    var packageJson = require_package();
+    var version = packageJson.version;
+    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+    function parse(src) {
+      const obj = {};
+      let lines = src.toString();
+      lines = lines.replace(/\r\n?/mg, "\n");
+      let match;
+      while ((match = LINE.exec(lines)) != null) {
+        const key = match[1];
+        let value = match[2] || "";
+        value = value.trim();
+        const maybeQuote = value[0];
+        value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+        if (maybeQuote === '"') {
+          value = value.replace(/\\n/g, "\n");
+          value = value.replace(/\\r/g, "\r");
+        }
+        obj[key] = value;
+      }
+      return obj;
+    }
+    __name(parse, "parse");
+    function _parseVault(options) {
+      const vaultPath = _vaultPath(options);
+      const result = DotenvModule.configDotenv({ path: vaultPath });
+      if (!result.parsed) {
+        const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+        err.code = "MISSING_DATA";
+        throw err;
+      }
+      const keys = _dotenvKey(options).split(",");
+      const length = keys.length;
+      let decrypted;
+      for (let i = 0; i < length; i++) {
+        try {
+          const key = keys[i].trim();
+          const attrs = _instructions(result, key);
+          decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+          break;
+        } catch (error) {
+          if (i + 1 >= length) {
+            throw error;
+          }
+        }
+      }
+      return DotenvModule.parse(decrypted);
+    }
+    __name(_parseVault, "_parseVault");
+    function _warn(message) {
+      console.log(`[dotenv@${version}][WARN] ${message}`);
+    }
+    __name(_warn, "_warn");
+    function _debug(message) {
+      console.log(`[dotenv@${version}][DEBUG] ${message}`);
+    }
+    __name(_debug, "_debug");
+    function _dotenvKey(options) {
+      if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+        return options.DOTENV_KEY;
+      }
+      if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+        return process.env.DOTENV_KEY;
+      }
+      return "";
+    }
+    __name(_dotenvKey, "_dotenvKey");
+    function _instructions(result, dotenvKey) {
+      let uri;
+      try {
+        uri = new URL(dotenvKey);
+      } catch (error) {
+        if (error.code === "ERR_INVALID_URL") {
+          const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        }
+        throw error;
+      }
+      const key = uri.password;
+      if (!key) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing key part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environment = uri.searchParams.get("environment");
+      if (!environment) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+      const ciphertext = result.parsed[environmentKey];
+      if (!ciphertext) {
+        const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+        err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+        throw err;
+      }
+      return { ciphertext, key };
+    }
+    __name(_instructions, "_instructions");
+    function _vaultPath(options) {
+      let possibleVaultPath = null;
+      if (options && options.path && options.path.length > 0) {
+        if (Array.isArray(options.path)) {
+          for (const filepath of options.path) {
+            if (fs2.existsSync(filepath)) {
+              possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+            }
+          }
+        } else {
+          possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+        }
+      } else {
+        possibleVaultPath = path3.resolve(process.cwd(), ".env.vault");
+      }
+      if (fs2.existsSync(possibleVaultPath)) {
+        return possibleVaultPath;
+      }
+      return null;
+    }
+    __name(_vaultPath, "_vaultPath");
+    function _resolveHome(envPath) {
+      return envPath[0] === "~" ? path3.join(os.homedir(), envPath.slice(1)) : envPath;
+    }
+    __name(_resolveHome, "_resolveHome");
+    function _configVault(options) {
+      const debug = Boolean(options && options.debug);
+      if (debug) {
+        _debug("Loading env from encrypted .env.vault");
+      }
+      const parsed = DotenvModule._parseVault(options);
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      DotenvModule.populate(processEnv, parsed, options);
+      return { parsed };
+    }
+    __name(_configVault, "_configVault");
+    function configDotenv(options) {
+      const dotenvPath = path3.resolve(process.cwd(), ".env");
+      let encoding = "utf8";
+      const debug = Boolean(options && options.debug);
+      if (options && options.encoding) {
+        encoding = options.encoding;
+      } else {
+        if (debug) {
+          _debug("No encoding is specified. UTF-8 is used by default");
+        }
+      }
+      let optionPaths = [dotenvPath];
+      if (options && options.path) {
+        if (!Array.isArray(options.path)) {
+          optionPaths = [_resolveHome(options.path)];
+        } else {
+          optionPaths = [];
+          for (const filepath of options.path) {
+            optionPaths.push(_resolveHome(filepath));
+          }
+        }
+      }
+      let lastError;
+      const parsedAll = {};
+      for (const path4 of optionPaths) {
+        try {
+          const parsed = DotenvModule.parse(fs2.readFileSync(path4, { encoding }));
+          DotenvModule.populate(parsedAll, parsed, options);
+        } catch (e) {
+          if (debug) {
+            _debug(`Failed to load ${path4} ${e.message}`);
+          }
+          lastError = e;
+        }
+      }
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      DotenvModule.populate(processEnv, parsedAll, options);
+      if (lastError) {
+        return { parsed: parsedAll, error: lastError };
+      } else {
+        return { parsed: parsedAll };
+      }
+    }
+    __name(configDotenv, "configDotenv");
+    function config(options) {
+      if (_dotenvKey(options).length === 0) {
+        return DotenvModule.configDotenv(options);
+      }
+      const vaultPath = _vaultPath(options);
+      if (!vaultPath) {
+        _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+        return DotenvModule.configDotenv(options);
+      }
+      return DotenvModule._configVault(options);
+    }
+    __name(config, "config");
+    function decrypt(encrypted, keyStr) {
+      const key = Buffer.from(keyStr.slice(-64), "hex");
+      let ciphertext = Buffer.from(encrypted, "base64");
+      const nonce = ciphertext.subarray(0, 12);
+      const authTag = ciphertext.subarray(-16);
+      ciphertext = ciphertext.subarray(12, -16);
+      try {
+        const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+        aesgcm.setAuthTag(authTag);
+        return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+      } catch (error) {
+        const isRange = error instanceof RangeError;
+        const invalidKeyLength = error.message === "Invalid key length";
+        const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+        if (isRange || invalidKeyLength) {
+          const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        } else if (decryptionFailed) {
+          const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+          err.code = "DECRYPTION_FAILED";
+          throw err;
+        } else {
+          throw error;
+        }
+      }
+    }
+    __name(decrypt, "decrypt");
+    function populate(processEnv, parsed, options = {}) {
+      const debug = Boolean(options && options.debug);
+      const override = Boolean(options && options.override);
+      if (typeof parsed !== "object") {
+        const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+        err.code = "OBJECT_REQUIRED";
+        throw err;
+      }
+      for (const key of Object.keys(parsed)) {
+        if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+          if (override === true) {
+            processEnv[key] = parsed[key];
+          }
+          if (debug) {
+            if (override === true) {
+              _debug(`"${key}" is already defined and WAS overwritten`);
+            } else {
+              _debug(`"${key}" is already defined and was NOT overwritten`);
+            }
+          }
+        } else {
+          processEnv[key] = parsed[key];
+        }
+      }
+    }
+    __name(populate, "populate");
+    var DotenvModule = {
+      configDotenv,
+      _configVault,
+      _parseVault,
+      config,
+      decrypt,
+      parse,
+      populate
+    };
+    module.exports.configDotenv = DotenvModule.configDotenv;
+    module.exports._configVault = DotenvModule._configVault;
+    module.exports._parseVault = DotenvModule._parseVault;
+    module.exports.config = DotenvModule.config;
+    module.exports.decrypt = DotenvModule.decrypt;
+    module.exports.parse = DotenvModule.parse;
+    module.exports.populate = DotenvModule.populate;
+    module.exports = DotenvModule;
+  }
+});
+
+// node_modules/dotenv/lib/env-options.js
+var require_env_options = __commonJS({
+  "node_modules/dotenv/lib/env-options.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    var options = {};
+    if (process.env.DOTENV_CONFIG_ENCODING != null) {
+      options.encoding = process.env.DOTENV_CONFIG_ENCODING;
+    }
+    if (process.env.DOTENV_CONFIG_PATH != null) {
+      options.path = process.env.DOTENV_CONFIG_PATH;
+    }
+    if (process.env.DOTENV_CONFIG_DEBUG != null) {
+      options.debug = process.env.DOTENV_CONFIG_DEBUG;
+    }
+    if (process.env.DOTENV_CONFIG_OVERRIDE != null) {
+      options.override = process.env.DOTENV_CONFIG_OVERRIDE;
+    }
+    if (process.env.DOTENV_CONFIG_DOTENV_KEY != null) {
+      options.DOTENV_KEY = process.env.DOTENV_CONFIG_DOTENV_KEY;
+    }
+    module.exports = options;
+  }
+});
+
+// node_modules/dotenv/lib/cli-options.js
+var require_cli_options = __commonJS({
+  "node_modules/dotenv/lib/cli-options.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    var re = /^dotenv_config_(encoding|path|debug|override|DOTENV_KEY)=(.+)$/;
+    module.exports = /* @__PURE__ */ __name(function optionMatcher(args) {
+      return args.reduce(function(acc, cur) {
+        const matches = cur.match(re);
+        if (matches) {
+          acc[matches[1]] = matches[2];
+        }
+        return acc;
+      }, {});
+    }, "optionMatcher");
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+
+// src/agent-bay.ts
+init_esm_shims();
+
+// src/session.ts
+init_esm_shims();
+
+// src/exceptions.ts
+init_esm_shims();
+var _AgentBayError = class _AgentBayError extends (Error.default || Error) {
+  constructor(message) {
+    super(message);
+    this.name = "AgentBayError";
+    Object.setPrototypeOf(this, _AgentBayError.prototype);
+  }
+};
+__name(_AgentBayError, "AgentBayError");
+var AgentBayError = _AgentBayError;
+var _AuthenticationError = class _AuthenticationError extends (AgentBayError.default || AgentBayError) {
+  constructor(message) {
+    super(message);
+    this.name = "AuthenticationError";
+    Object.setPrototypeOf(this, _AuthenticationError.prototype);
+  }
+};
+__name(_AuthenticationError, "AuthenticationError");
+var AuthenticationError = _AuthenticationError;
+var _APIError = class _APIError extends (AgentBayError.default || AgentBayError) {
+  constructor(message) {
+    super(message);
+    this.name = "APIError";
+    Object.setPrototypeOf(this, _APIError.prototype);
+  }
+};
+__name(_APIError, "APIError");
+var APIError = _APIError;
+var _FileError = class _FileError extends (AgentBayError.default || AgentBayError) {
+  constructor(message) {
+    super(message);
+    this.name = "FileError";
+    Object.setPrototypeOf(this, _FileError.prototype);
+  }
+};
+__name(_FileError, "FileError");
+var FileError = _FileError;
+var _CommandError = class _CommandError extends (AgentBayError.default || AgentBayError) {
+  constructor(message) {
+    super(message);
+    this.name = "CommandError";
+    Object.setPrototypeOf(this, _CommandError.prototype);
+  }
+};
+__name(_CommandError, "CommandError");
+var CommandError = _CommandError;
+
+// src/filesystem/filesystem.ts
+init_esm_shims();
+
+// src/api/models/model.ts
+init_esm_shims();
+
+// src/api/models/CreateMcpSessionResponseBodyData.ts
+init_esm_shims();
+import * as $dara from "@darabonba/typescript";
+var _CreateMcpSessionResponseBodyData = class _CreateMcpSessionResponseBodyData extends $dara.Model {
+  static names() {
+    return {
+      appInstanceId: "AppInstanceId",
+      errMsg: "ErrMsg",
+      resourceId: "ResourceId",
+      resourceUrl: "ResourceUrl",
+      sessionId: "SessionId",
+      success: "Success"
+    };
+  }
+  static types() {
+    return {
+      appInstanceId: "string",
+      errMsg: "string",
+      resourceId: "string",
+      resourceUrl: "string",
+      sessionId: "string",
+      success: "boolean"
+    };
+  }
+  validate() {
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_CreateMcpSessionResponseBodyData, "CreateMcpSessionResponseBodyData");
+var CreateMcpSessionResponseBodyData = _CreateMcpSessionResponseBodyData;
+
+// src/api/models/GetContextResponseBodyData.ts
+init_esm_shims();
+import * as $dara2 from "@darabonba/typescript";
+var _GetContextResponseBodyData = class _GetContextResponseBodyData extends $dara2.Model {
+  static names() {
+    return {
+      createTime: "CreateTime",
+      id: "Id",
+      lastUsedTime: "LastUsedTime",
+      name: "Name",
+      osType: "OsType",
+      state: "State"
+    };
+  }
+  static types() {
+    return {
+      createTime: "string",
+      id: "string",
+      lastUsedTime: "string",
+      name: "string",
+      osType: "string",
+      state: "string"
+    };
+  }
+  validate() {
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_GetContextResponseBodyData, "GetContextResponseBodyData");
+var GetContextResponseBodyData = _GetContextResponseBodyData;
+
+// src/api/models/GetLabelResponseBodyData.ts
+init_esm_shims();
+import * as $dara3 from "@darabonba/typescript";
+var _GetLabelResponseBodyData = class _GetLabelResponseBodyData extends $dara3.Model {
+  static names() {
+    return {
+      labels: "Labels"
+    };
+  }
+  static types() {
+    return {
+      labels: "string"
+    };
+  }
+  validate() {
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_GetLabelResponseBodyData, "GetLabelResponseBodyData");
+var GetLabelResponseBodyData = _GetLabelResponseBodyData;
+
+// src/api/models/GetMcpResourceResponseBodyDataDesktopInfo.ts
+init_esm_shims();
+import * as $dara4 from "@darabonba/typescript";
+var _GetMcpResourceResponseBodyDataDesktopInfo = class _GetMcpResourceResponseBodyDataDesktopInfo extends $dara4.Model {
+  static names() {
+    return {
+      appId: "AppId",
+      authCode: "AuthCode",
+      connectionProperties: "ConnectionProperties",
+      resourceId: "ResourceId",
+      resourceType: "ResourceType"
+    };
+  }
+  static types() {
+    return {
+      appId: "string",
+      authCode: "string",
+      connectionProperties: "string",
+      resourceId: "string",
+      resourceType: "string"
+    };
+  }
+  validate() {
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_GetMcpResourceResponseBodyDataDesktopInfo, "GetMcpResourceResponseBodyDataDesktopInfo");
+var GetMcpResourceResponseBodyDataDesktopInfo = _GetMcpResourceResponseBodyDataDesktopInfo;
+
+// src/api/models/GetMcpResourceResponseBodyData.ts
+init_esm_shims();
+import * as $dara5 from "@darabonba/typescript";
+var _GetMcpResourceResponseBodyData = class _GetMcpResourceResponseBodyData extends $dara5.Model {
+  static names() {
+    return {
+      desktopInfo: "DesktopInfo",
+      resourceUrl: "ResourceUrl",
+      sessionId: "SessionId"
+    };
+  }
+  static types() {
+    return {
+      desktopInfo: GetMcpResourceResponseBodyDataDesktopInfo,
+      resourceUrl: "string",
+      sessionId: "string"
+    };
+  }
+  validate() {
+    if (this.desktopInfo && typeof this.desktopInfo.validate === "function") {
+      this.desktopInfo.validate();
+    }
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_GetMcpResourceResponseBodyData, "GetMcpResourceResponseBodyData");
+var GetMcpResourceResponseBodyData = _GetMcpResourceResponseBodyData;
+
+// src/api/models/ListContextsResponseBodyData.ts
+init_esm_shims();
+import * as $dara6 from "@darabonba/typescript";
+var _ListContextsResponseBodyData = class _ListContextsResponseBodyData extends $dara6.Model {
+  static names() {
+    return {
+      createTime: "CreateTime",
+      id: "Id",
+      lastUsedTime: "LastUsedTime",
+      name: "Name",
+      osType: "OsType",
+      state: "State"
+    };
+  }
+  static types() {
+    return {
+      createTime: "string",
+      id: "string",
+      lastUsedTime: "string",
+      name: "string",
+      osType: "string",
+      state: "string"
+    };
+  }
+  validate() {
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_ListContextsResponseBodyData, "ListContextsResponseBodyData");
+var ListContextsResponseBodyData = _ListContextsResponseBodyData;
+
+// src/api/models/ListSessionResponseBodyData.ts
+init_esm_shims();
+import * as $dara7 from "@darabonba/typescript";
+var _ListSessionResponseBodyData = class _ListSessionResponseBodyData extends $dara7.Model {
+  static names() {
+    return {
+      sessionId: "SessionId"
+    };
+  }
+  static types() {
+    return {
+      sessionId: "string"
+    };
+  }
+  validate() {
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_ListSessionResponseBodyData, "ListSessionResponseBodyData");
+var ListSessionResponseBodyData = _ListSessionResponseBodyData;
+
+// src/api/models/CallMcpToolRequest.ts
+init_esm_shims();
+import * as $dara8 from "@darabonba/typescript";
+var _CallMcpToolRequest = class _CallMcpToolRequest extends $dara8.Model {
+  static names() {
+    return {
+      args: "Args",
+      authorization: "Authorization",
+      externalUserId: "ExternalUserId",
+      imageId: "ImageId",
+      name: "Name",
+      server: "Server",
+      sessionId: "SessionId",
+      tool: "Tool"
+    };
+  }
+  static types() {
+    return {
+      args: "string",
+      authorization: "string",
+      externalUserId: "string",
+      imageId: "string",
+      name: "string",
+      server: "string",
+      sessionId: "string",
+      tool: "string"
+    };
+  }
+  validate() {
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_CallMcpToolRequest, "CallMcpToolRequest");
+var CallMcpToolRequest = _CallMcpToolRequest;
+
+// src/api/models/CallMcpToolResponseBody.ts
+init_esm_shims();
+import * as $dara9 from "@darabonba/typescript";
+var _CallMcpToolResponseBody = class _CallMcpToolResponseBody extends $dara9.Model {
+  static names() {
+    return {
+      code: "Code",
+      data: "Data",
+      httpStatusCode: "HttpStatusCode",
+      message: "Message",
+      requestId: "RequestId",
+      success: "Success"
+    };
+  }
+  static types() {
+    return {
+      code: "string",
+      data: "any",
+      httpStatusCode: "number",
+      message: "string",
+      requestId: "string",
+      success: "boolean"
+    };
+  }
+  validate() {
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_CallMcpToolResponseBody, "CallMcpToolResponseBody");
+var CallMcpToolResponseBody = _CallMcpToolResponseBody;
+
+// src/api/models/CallMcpToolResponse.ts
+init_esm_shims();
+import * as $dara10 from "@darabonba/typescript";
+var _CallMcpToolResponse = class _CallMcpToolResponse extends $dara10.Model {
+  static names() {
+    return {
+      headers: "headers",
+      statusCode: "statusCode",
+      body: "body"
+    };
+  }
+  static types() {
+    return {
+      headers: { "type": "map", "keyType": "string", "valueType": "string" },
+      statusCode: "number",
+      body: CallMcpToolResponseBody
+    };
+  }
+  validate() {
+    if (this.headers) {
+      $dara10.Model.validateMap(this.headers);
+    }
+    if (this.body && typeof this.body.validate === "function") {
+      this.body.validate();
+    }
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_CallMcpToolResponse, "CallMcpToolResponse");
+var CallMcpToolResponse = _CallMcpToolResponse;
+
+// src/api/models/CreateMcpSessionRequest.ts
+init_esm_shims();
+import * as $dara11 from "@darabonba/typescript";
+var _CreateMcpSessionRequest = class _CreateMcpSessionRequest extends $dara11.Model {
+  static names() {
+    return {
+      authorization: "Authorization",
+      contextId: "ContextId",
+      externalUserId: "ExternalUserId",
+      imageId: "ImageId",
+      labels: "Labels",
+      sessionId: "SessionId"
+    };
+  }
+  static types() {
+    return {
+      authorization: "string",
+      contextId: "string",
+      externalUserId: "string",
+      imageId: "string",
+      labels: "string",
+      sessionId: "string"
+    };
+  }
+  validate() {
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_CreateMcpSessionRequest, "CreateMcpSessionRequest");
+var CreateMcpSessionRequest = _CreateMcpSessionRequest;
+
+// src/api/models/CreateMcpSessionResponseBody.ts
+init_esm_shims();
+import * as $dara12 from "@darabonba/typescript";
+var _CreateMcpSessionResponseBody = class _CreateMcpSessionResponseBody extends $dara12.Model {
+  static names() {
+    return {
+      code: "Code",
+      data: "Data",
+      httpStatusCode: "HttpStatusCode",
+      message: "Message",
+      requestId: "RequestId",
+      success: "Success"
+    };
+  }
+  static types() {
+    return {
+      code: "string",
+      data: CreateMcpSessionResponseBodyData,
+      httpStatusCode: "number",
+      message: "string",
+      requestId: "string",
+      success: "boolean"
+    };
+  }
+  validate() {
+    if (this.data && typeof this.data.validate === "function") {
+      this.data.validate();
+    }
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_CreateMcpSessionResponseBody, "CreateMcpSessionResponseBody");
+var CreateMcpSessionResponseBody = _CreateMcpSessionResponseBody;
+
+// src/api/models/CreateMcpSessionResponse.ts
+init_esm_shims();
+import * as $dara13 from "@darabonba/typescript";
+var _CreateMcpSessionResponse = class _CreateMcpSessionResponse extends $dara13.Model {
+  static names() {
+    return {
+      headers: "headers",
+      statusCode: "statusCode",
+      body: "body"
+    };
+  }
+  static types() {
+    return {
+      headers: { "type": "map", "keyType": "string", "valueType": "string" },
+      statusCode: "number",
+      body: CreateMcpSessionResponseBody
+    };
+  }
+  validate() {
+    if (this.headers) {
+      $dara13.Model.validateMap(this.headers);
+    }
+    if (this.body && typeof this.body.validate === "function") {
+      this.body.validate();
+    }
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_CreateMcpSessionResponse, "CreateMcpSessionResponse");
+var CreateMcpSessionResponse = _CreateMcpSessionResponse;
+
+// src/api/models/DeleteContextRequest.ts
+init_esm_shims();
+import * as $dara14 from "@darabonba/typescript";
+var _DeleteContextRequest = class _DeleteContextRequest extends $dara14.Model {
+  static names() {
+    return {
+      authorization: "Authorization",
+      id: "Id"
+    };
+  }
+  static types() {
+    return {
+      authorization: "string",
+      id: "string"
+    };
+  }
+  validate() {
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_DeleteContextRequest, "DeleteContextRequest");
+var DeleteContextRequest = _DeleteContextRequest;
+
+// src/api/models/DeleteContextResponseBody.ts
+init_esm_shims();
+import * as $dara15 from "@darabonba/typescript";
+var _DeleteContextResponseBody = class _DeleteContextResponseBody extends $dara15.Model {
+  static names() {
+    return {
+      code: "Code",
+      httpStatusCode: "HttpStatusCode",
+      message: "Message",
+      requestId: "RequestId",
+      success: "Success"
+    };
+  }
+  static types() {
+    return {
+      code: "string",
+      httpStatusCode: "number",
+      message: "string",
+      requestId: "string",
+      success: "boolean"
+    };
+  }
+  validate() {
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_DeleteContextResponseBody, "DeleteContextResponseBody");
+var DeleteContextResponseBody = _DeleteContextResponseBody;
+
+// src/api/models/DeleteContextResponse.ts
+init_esm_shims();
+import * as $dara16 from "@darabonba/typescript";
+var _DeleteContextResponse = class _DeleteContextResponse extends $dara16.Model {
+  static names() {
+    return {
+      headers: "headers",
+      statusCode: "statusCode",
+      body: "body"
+    };
+  }
+  static types() {
+    return {
+      headers: { "type": "map", "keyType": "string", "valueType": "string" },
+      statusCode: "number",
+      body: DeleteContextResponseBody
+    };
+  }
+  validate() {
+    if (this.headers) {
+      $dara16.Model.validateMap(this.headers);
+    }
+    if (this.body && typeof this.body.validate === "function") {
+      this.body.validate();
+    }
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_DeleteContextResponse, "DeleteContextResponse");
+var DeleteContextResponse = _DeleteContextResponse;
+
+// src/api/models/GetContextRequest.ts
+init_esm_shims();
+import * as $dara17 from "@darabonba/typescript";
+var _GetContextRequest = class _GetContextRequest extends $dara17.Model {
+  static names() {
+    return {
+      allowCreate: "AllowCreate",
+      authorization: "Authorization",
+      name: "Name"
+    };
+  }
+  static types() {
+    return {
+      allowCreate: "boolean",
+      authorization: "string",
+      name: "string"
+    };
+  }
+  validate() {
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_GetContextRequest, "GetContextRequest");
+var GetContextRequest = _GetContextRequest;
+
+// src/api/models/GetContextResponseBody.ts
+init_esm_shims();
+import * as $dara18 from "@darabonba/typescript";
+var _GetContextResponseBody = class _GetContextResponseBody extends $dara18.Model {
+  static names() {
+    return {
+      code: "Code",
+      data: "Data",
+      httpStatusCode: "HttpStatusCode",
+      message: "Message",
+      requestId: "RequestId",
+      success: "Success"
+    };
+  }
+  static types() {
+    return {
+      code: "string",
+      data: GetContextResponseBodyData,
+      httpStatusCode: "number",
+      message: "string",
+      requestId: "string",
+      success: "boolean"
+    };
+  }
+  validate() {
+    if (this.data && typeof this.data.validate === "function") {
+      this.data.validate();
+    }
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_GetContextResponseBody, "GetContextResponseBody");
+var GetContextResponseBody = _GetContextResponseBody;
+
+// src/api/models/GetContextResponse.ts
+init_esm_shims();
+import * as $dara19 from "@darabonba/typescript";
+var _GetContextResponse = class _GetContextResponse extends $dara19.Model {
+  static names() {
+    return {
+      headers: "headers",
+      statusCode: "statusCode",
+      body: "body"
+    };
+  }
+  static types() {
+    return {
+      headers: { "type": "map", "keyType": "string", "valueType": "string" },
+      statusCode: "number",
+      body: GetContextResponseBody
+    };
+  }
+  validate() {
+    if (this.headers) {
+      $dara19.Model.validateMap(this.headers);
+    }
+    if (this.body && typeof this.body.validate === "function") {
+      this.body.validate();
+    }
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_GetContextResponse, "GetContextResponse");
+var GetContextResponse = _GetContextResponse;
+
+// src/api/models/GetLabelRequest.ts
+init_esm_shims();
+import * as $dara20 from "@darabonba/typescript";
+var _GetLabelRequest = class _GetLabelRequest extends $dara20.Model {
+  static names() {
+    return {
+      authorization: "Authorization",
+      maxResults: "MaxResults",
+      nextToken: "NextToken",
+      sessionId: "SessionId"
+    };
+  }
+  static types() {
+    return {
+      authorization: "string",
+      maxResults: "number",
+      nextToken: "string",
+      sessionId: "string"
+    };
+  }
+  validate() {
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_GetLabelRequest, "GetLabelRequest");
+var GetLabelRequest = _GetLabelRequest;
+
+// src/api/models/GetLabelResponseBody.ts
+init_esm_shims();
+import * as $dara21 from "@darabonba/typescript";
+var _GetLabelResponseBody = class _GetLabelResponseBody extends $dara21.Model {
+  static names() {
+    return {
+      code: "Code",
+      data: "Data",
+      httpStatusCode: "HttpStatusCode",
+      maxResults: "MaxResults",
+      message: "Message",
+      nextToken: "NextToken",
+      requestId: "RequestId",
+      success: "Success",
+      totalCount: "TotalCount"
+    };
+  }
+  static types() {
+    return {
+      code: "string",
+      data: GetLabelResponseBodyData,
+      httpStatusCode: "number",
+      maxResults: "number",
+      message: "string",
+      nextToken: "string",
+      requestId: "string",
+      success: "boolean",
+      totalCount: "number"
+    };
+  }
+  validate() {
+    if (this.data && typeof this.data.validate === "function") {
+      this.data.validate();
+    }
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_GetLabelResponseBody, "GetLabelResponseBody");
+var GetLabelResponseBody = _GetLabelResponseBody;
+
+// src/api/models/GetLabelResponse.ts
+init_esm_shims();
+import * as $dara22 from "@darabonba/typescript";
+var _GetLabelResponse = class _GetLabelResponse extends $dara22.Model {
+  static names() {
+    return {
+      headers: "headers",
+      statusCode: "statusCode",
+      body: "body"
+    };
+  }
+  static types() {
+    return {
+      headers: { "type": "map", "keyType": "string", "valueType": "string" },
+      statusCode: "number",
+      body: GetLabelResponseBody
+    };
+  }
+  validate() {
+    if (this.headers) {
+      $dara22.Model.validateMap(this.headers);
+    }
+    if (this.body && typeof this.body.validate === "function") {
+      this.body.validate();
+    }
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_GetLabelResponse, "GetLabelResponse");
+var GetLabelResponse = _GetLabelResponse;
+
+// src/api/models/GetLinkRequest.ts
+init_esm_shims();
+import * as $dara23 from "@darabonba/typescript";
+var _GetLinkRequest = class _GetLinkRequest extends $dara23.Model {
+  static names() {
+    return {
+      authorization: "Authorization",
+      sessionId: "SessionId"
+    };
+  }
+  static types() {
+    return {
+      authorization: "string",
+      sessionId: "string"
+    };
+  }
+  validate() {
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_GetLinkRequest, "GetLinkRequest");
+var GetLinkRequest = _GetLinkRequest;
+
+// src/api/models/GetLinkResponseBody.ts
+init_esm_shims();
+import * as $dara24 from "@darabonba/typescript";
+var _GetLinkResponseBody = class _GetLinkResponseBody extends $dara24.Model {
+  static names() {
+    return {
+      code: "Code",
+      data: "Data",
+      httpStatusCode: "HttpStatusCode",
+      message: "Message",
+      requestId: "RequestId",
+      success: "Success"
+    };
+  }
+  static types() {
+    return {
+      code: "string",
+      data: "string",
+      httpStatusCode: "number",
+      message: "string",
+      requestId: "string",
+      success: "boolean"
+    };
+  }
+  validate() {
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_GetLinkResponseBody, "GetLinkResponseBody");
+var GetLinkResponseBody = _GetLinkResponseBody;
+
+// src/api/models/GetLinkResponse.ts
+init_esm_shims();
+import * as $dara25 from "@darabonba/typescript";
+var _GetLinkResponse = class _GetLinkResponse extends $dara25.Model {
+  static names() {
+    return {
+      headers: "headers",
+      statusCode: "statusCode",
+      body: "body"
+    };
+  }
+  static types() {
+    return {
+      headers: { "type": "map", "keyType": "string", "valueType": "string" },
+      statusCode: "number",
+      body: GetLinkResponseBody
+    };
+  }
+  validate() {
+    if (this.headers) {
+      $dara25.Model.validateMap(this.headers);
+    }
+    if (this.body && typeof this.body.validate === "function") {
+      this.body.validate();
+    }
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_GetLinkResponse, "GetLinkResponse");
+var GetLinkResponse = _GetLinkResponse;
+
+// src/api/models/GetMcpResourceRequest.ts
+init_esm_shims();
+import * as $dara26 from "@darabonba/typescript";
+var _GetMcpResourceRequest = class _GetMcpResourceRequest extends $dara26.Model {
+  static names() {
+    return {
+      authorization: "Authorization",
+      sessionId: "SessionId"
+    };
+  }
+  static types() {
+    return {
+      authorization: "string",
+      sessionId: "string"
+    };
+  }
+  validate() {
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_GetMcpResourceRequest, "GetMcpResourceRequest");
+var GetMcpResourceRequest = _GetMcpResourceRequest;
+
+// src/api/models/GetMcpResourceResponseBody.ts
+init_esm_shims();
+import * as $dara27 from "@darabonba/typescript";
+var _GetMcpResourceResponseBody = class _GetMcpResourceResponseBody extends $dara27.Model {
+  static names() {
+    return {
+      code: "Code",
+      data: "Data",
+      httpStatusCode: "HttpStatusCode",
+      message: "Message",
+      requestId: "RequestId",
+      success: "Success"
+    };
+  }
+  static types() {
+    return {
+      code: "string",
+      data: GetMcpResourceResponseBodyData,
+      httpStatusCode: "number",
+      message: "string",
+      requestId: "string",
+      success: "boolean"
+    };
+  }
+  validate() {
+    if (this.data && typeof this.data.validate === "function") {
+      this.data.validate();
+    }
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_GetMcpResourceResponseBody, "GetMcpResourceResponseBody");
+var GetMcpResourceResponseBody = _GetMcpResourceResponseBody;
+
+// src/api/models/GetMcpResourceResponse.ts
+init_esm_shims();
+import * as $dara28 from "@darabonba/typescript";
+var _GetMcpResourceResponse = class _GetMcpResourceResponse extends $dara28.Model {
+  static names() {
+    return {
+      headers: "headers",
+      statusCode: "statusCode",
+      body: "body"
+    };
+  }
+  static types() {
+    return {
+      headers: { "type": "map", "keyType": "string", "valueType": "string" },
+      statusCode: "number",
+      body: GetMcpResourceResponseBody
+    };
+  }
+  validate() {
+    if (this.headers) {
+      $dara28.Model.validateMap(this.headers);
+    }
+    if (this.body && typeof this.body.validate === "function") {
+      this.body.validate();
+    }
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_GetMcpResourceResponse, "GetMcpResourceResponse");
+var GetMcpResourceResponse = _GetMcpResourceResponse;
+
+// src/api/models/ListContextsRequest.ts
+init_esm_shims();
+import * as $dara29 from "@darabonba/typescript";
+var _ListContextsRequest = class _ListContextsRequest extends $dara29.Model {
+  static names() {
+    return {
+      authorization: "Authorization",
+      maxResults: "MaxResults",
+      nextToken: "NextToken"
+    };
+  }
+  static types() {
+    return {
+      authorization: "string",
+      maxResults: "number",
+      nextToken: "string"
+    };
+  }
+  validate() {
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_ListContextsRequest, "ListContextsRequest");
+var ListContextsRequest = _ListContextsRequest;
+
+// src/api/models/ListContextsResponseBody.ts
+init_esm_shims();
+import * as $dara30 from "@darabonba/typescript";
+var _ListContextsResponseBody = class _ListContextsResponseBody extends $dara30.Model {
+  static names() {
+    return {
+      code: "Code",
+      data: "Data",
+      httpStatusCode: "HttpStatusCode",
+      maxResults: "MaxResults",
+      message: "Message",
+      nextToken: "NextToken",
+      requestId: "RequestId",
+      success: "Success",
+      totalCount: "TotalCount"
+    };
+  }
+  static types() {
+    return {
+      code: "string",
+      data: { "type": "array", "itemType": ListContextsResponseBodyData },
+      httpStatusCode: "number",
+      maxResults: "number",
+      message: "string",
+      nextToken: "string",
+      requestId: "string",
+      success: "boolean",
+      totalCount: "number"
+    };
+  }
+  validate() {
+    if (Array.isArray(this.data)) {
+      $dara30.Model.validateArray(this.data);
+    }
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_ListContextsResponseBody, "ListContextsResponseBody");
+var ListContextsResponseBody = _ListContextsResponseBody;
+
+// src/api/models/ListContextsResponse.ts
+init_esm_shims();
+import * as $dara31 from "@darabonba/typescript";
+var _ListContextsResponse = class _ListContextsResponse extends $dara31.Model {
+  static names() {
+    return {
+      headers: "headers",
+      statusCode: "statusCode",
+      body: "body"
+    };
+  }
+  static types() {
+    return {
+      headers: { "type": "map", "keyType": "string", "valueType": "string" },
+      statusCode: "number",
+      body: ListContextsResponseBody
+    };
+  }
+  validate() {
+    if (this.headers) {
+      $dara31.Model.validateMap(this.headers);
+    }
+    if (this.body && typeof this.body.validate === "function") {
+      this.body.validate();
+    }
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_ListContextsResponse, "ListContextsResponse");
+var ListContextsResponse = _ListContextsResponse;
+
+// src/api/models/ListSessionRequest.ts
+init_esm_shims();
+import * as $dara32 from "@darabonba/typescript";
+var _ListSessionRequest = class _ListSessionRequest extends $dara32.Model {
+  static names() {
+    return {
+      authorization: "Authorization",
+      labels: "Labels",
+      maxResults: "MaxResults",
+      nextToken: "NextToken"
+    };
+  }
+  static types() {
+    return {
+      authorization: "string",
+      labels: "string",
+      maxResults: "number",
+      nextToken: "string"
+    };
+  }
+  validate() {
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_ListSessionRequest, "ListSessionRequest");
+var ListSessionRequest = _ListSessionRequest;
+
+// src/api/models/ListSessionResponseBody.ts
+init_esm_shims();
+import * as $dara33 from "@darabonba/typescript";
+var _ListSessionResponseBody = class _ListSessionResponseBody extends $dara33.Model {
+  static names() {
+    return {
+      code: "Code",
+      data: "Data",
+      httpStatusCode: "HttpStatusCode",
+      maxResults: "MaxResults",
+      message: "Message",
+      nextToken: "NextToken",
+      requestId: "RequestId",
+      success: "Success",
+      totalCount: "TotalCount"
+    };
+  }
+  static types() {
+    return {
+      code: "string",
+      data: { "type": "array", "itemType": ListSessionResponseBodyData },
+      httpStatusCode: "number",
+      maxResults: "number",
+      message: "string",
+      nextToken: "string",
+      requestId: "string",
+      success: "boolean",
+      totalCount: "number"
+    };
+  }
+  validate() {
+    if (Array.isArray(this.data)) {
+      $dara33.Model.validateArray(this.data);
+    }
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_ListSessionResponseBody, "ListSessionResponseBody");
+var ListSessionResponseBody = _ListSessionResponseBody;
+
+// src/api/models/ListSessionResponse.ts
+init_esm_shims();
+import * as $dara34 from "@darabonba/typescript";
+var _ListSessionResponse = class _ListSessionResponse extends $dara34.Model {
+  static names() {
+    return {
+      headers: "headers",
+      statusCode: "statusCode",
+      body: "body"
+    };
+  }
+  static types() {
+    return {
+      headers: { "type": "map", "keyType": "string", "valueType": "string" },
+      statusCode: "number",
+      body: ListSessionResponseBody
+    };
+  }
+  validate() {
+    if (this.headers) {
+      $dara34.Model.validateMap(this.headers);
+    }
+    if (this.body && typeof this.body.validate === "function") {
+      this.body.validate();
+    }
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_ListSessionResponse, "ListSessionResponse");
+var ListSessionResponse = _ListSessionResponse;
+
+// src/api/models/ModifyContextRequest.ts
+init_esm_shims();
+import * as $dara35 from "@darabonba/typescript";
+var _ModifyContextRequest = class _ModifyContextRequest extends $dara35.Model {
+  static names() {
+    return {
+      authorization: "Authorization",
+      id: "Id",
+      name: "Name"
+    };
+  }
+  static types() {
+    return {
+      authorization: "string",
+      id: "string",
+      name: "string"
+    };
+  }
+  validate() {
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_ModifyContextRequest, "ModifyContextRequest");
+var ModifyContextRequest = _ModifyContextRequest;
+
+// src/api/models/ModifyContextResponseBody.ts
+init_esm_shims();
+import * as $dara36 from "@darabonba/typescript";
+var _ModifyContextResponseBody = class _ModifyContextResponseBody extends $dara36.Model {
+  static names() {
+    return {
+      code: "Code",
+      httpStatusCode: "HttpStatusCode",
+      message: "Message",
+      requestId: "RequestId",
+      success: "Success"
+    };
+  }
+  static types() {
+    return {
+      code: "string",
+      httpStatusCode: "number",
+      message: "string",
+      requestId: "string",
+      success: "boolean"
+    };
+  }
+  validate() {
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_ModifyContextResponseBody, "ModifyContextResponseBody");
+var ModifyContextResponseBody = _ModifyContextResponseBody;
+
+// src/api/models/ModifyContextResponse.ts
+init_esm_shims();
+import * as $dara37 from "@darabonba/typescript";
+var _ModifyContextResponse = class _ModifyContextResponse extends $dara37.Model {
+  static names() {
+    return {
+      headers: "headers",
+      statusCode: "statusCode",
+      body: "body"
+    };
+  }
+  static types() {
+    return {
+      headers: { "type": "map", "keyType": "string", "valueType": "string" },
+      statusCode: "number",
+      body: ModifyContextResponseBody
+    };
+  }
+  validate() {
+    if (this.headers) {
+      $dara37.Model.validateMap(this.headers);
+    }
+    if (this.body && typeof this.body.validate === "function") {
+      this.body.validate();
+    }
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_ModifyContextResponse, "ModifyContextResponse");
+var ModifyContextResponse = _ModifyContextResponse;
+
+// src/api/models/ReleaseMcpSessionRequest.ts
+init_esm_shims();
+import * as $dara38 from "@darabonba/typescript";
+var _ReleaseMcpSessionRequest = class _ReleaseMcpSessionRequest extends $dara38.Model {
+  static names() {
+    return {
+      authorization: "Authorization",
+      sessionId: "SessionId"
+    };
+  }
+  static types() {
+    return {
+      authorization: "string",
+      sessionId: "string"
+    };
+  }
+  validate() {
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_ReleaseMcpSessionRequest, "ReleaseMcpSessionRequest");
+var ReleaseMcpSessionRequest = _ReleaseMcpSessionRequest;
+
+// src/api/models/ReleaseMcpSessionResponseBody.ts
+init_esm_shims();
+import * as $dara39 from "@darabonba/typescript";
+var _ReleaseMcpSessionResponseBody = class _ReleaseMcpSessionResponseBody extends $dara39.Model {
+  static names() {
+    return {
+      code: "Code",
+      httpStatusCode: "HttpStatusCode",
+      message: "Message",
+      requestId: "RequestId",
+      success: "Success"
+    };
+  }
+  static types() {
+    return {
+      code: "string",
+      httpStatusCode: "number",
+      message: "string",
+      requestId: "string",
+      success: "boolean"
+    };
+  }
+  validate() {
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_ReleaseMcpSessionResponseBody, "ReleaseMcpSessionResponseBody");
+var ReleaseMcpSessionResponseBody = _ReleaseMcpSessionResponseBody;
+
+// src/api/models/ReleaseMcpSessionResponse.ts
+init_esm_shims();
+import * as $dara40 from "@darabonba/typescript";
+var _ReleaseMcpSessionResponse = class _ReleaseMcpSessionResponse extends $dara40.Model {
+  static names() {
+    return {
+      headers: "headers",
+      statusCode: "statusCode",
+      body: "body"
+    };
+  }
+  static types() {
+    return {
+      headers: { "type": "map", "keyType": "string", "valueType": "string" },
+      statusCode: "number",
+      body: ReleaseMcpSessionResponseBody
+    };
+  }
+  validate() {
+    if (this.headers) {
+      $dara40.Model.validateMap(this.headers);
+    }
+    if (this.body && typeof this.body.validate === "function") {
+      this.body.validate();
+    }
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_ReleaseMcpSessionResponse, "ReleaseMcpSessionResponse");
+var ReleaseMcpSessionResponse = _ReleaseMcpSessionResponse;
+
+// src/api/models/SetLabelRequest.ts
+init_esm_shims();
+import * as $dara41 from "@darabonba/typescript";
+var _SetLabelRequest = class _SetLabelRequest extends $dara41.Model {
+  static names() {
+    return {
+      authorization: "Authorization",
+      labels: "Labels",
+      sessionId: "SessionId"
+    };
+  }
+  static types() {
+    return {
+      authorization: "string",
+      labels: "string",
+      sessionId: "string"
+    };
+  }
+  validate() {
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_SetLabelRequest, "SetLabelRequest");
+var SetLabelRequest = _SetLabelRequest;
+
+// src/api/models/SetLabelResponseBody.ts
+init_esm_shims();
+import * as $dara42 from "@darabonba/typescript";
+var _SetLabelResponseBody = class _SetLabelResponseBody extends $dara42.Model {
+  static names() {
+    return {
+      code: "Code",
+      httpStatusCode: "HttpStatusCode",
+      message: "Message",
+      requestId: "RequestId",
+      success: "Success"
+    };
+  }
+  static types() {
+    return {
+      code: "string",
+      httpStatusCode: "number",
+      message: "string",
+      requestId: "string",
+      success: "boolean"
+    };
+  }
+  validate() {
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_SetLabelResponseBody, "SetLabelResponseBody");
+var SetLabelResponseBody = _SetLabelResponseBody;
+
+// src/api/models/SetLabelResponse.ts
+init_esm_shims();
+import * as $dara43 from "@darabonba/typescript";
+var _SetLabelResponse = class _SetLabelResponse extends $dara43.Model {
+  static names() {
+    return {
+      headers: "headers",
+      statusCode: "statusCode",
+      body: "body"
+    };
+  }
+  static types() {
+    return {
+      headers: { "type": "map", "keyType": "string", "valueType": "string" },
+      statusCode: "number",
+      body: SetLabelResponseBody
+    };
+  }
+  validate() {
+    if (this.headers) {
+      $dara43.Model.validateMap(this.headers);
+    }
+    if (this.body && typeof this.body.validate === "function") {
+      this.body.validate();
+    }
+    super.validate();
+  }
+  constructor(map) {
+    super(map);
+  }
+};
+__name(_SetLabelResponse, "SetLabelResponse");
+var SetLabelResponse = _SetLabelResponse;
+
+// src/utils/logger.ts
+init_esm_shims();
+function log(message, ...args) {
+  process.stdout.write(message + "\n");
+  if (args.length > 0) {
+    for (const arg of args) {
+      if (typeof arg === "object") {
+        process.stdout.write(JSON.stringify(arg, null, 2) + "\n");
+      } else {
+        process.stdout.write(String(arg) + "\n");
+      }
+    }
+  }
+}
+__name(log, "log");
+function logError(message, error) {
+  process.stderr.write(`ERROR: ${message}
+`);
+  if (error) {
+    if (error instanceof Error) {
+      process.stderr.write(`${error.message}
+`);
+    } else if (typeof error === "object") {
+      process.stderr.write(JSON.stringify(error, null, 2) + "\n");
+    } else {
+      process.stderr.write(String(error) + "\n");
+    }
+  }
+}
+__name(logError, "logError");
+
+// src/filesystem/filesystem.ts
+var DEFAULT_CHUNK_SIZE = 60 * 1024;
+var FILE_OPERATIONS = {
+  "read_file": true,
+  "write_file": true,
+  "read_multiple_files": true
+};
+function isFileOperation(toolName) {
+  return FILE_OPERATIONS[toolName] === true;
+}
+__name(isFileOperation, "isFileOperation");
+function truncateContentForLogging(args) {
+  const truncatedArgs = { ...args };
+  if (typeof truncatedArgs.content === "string") {
+    const contentLength = truncatedArgs.content.length;
+    truncatedArgs.content = `[Content length: ${contentLength} bytes]`;
+  }
+  if (Array.isArray(truncatedArgs.paths) && truncatedArgs.paths.length > 3) {
+    truncatedArgs.paths = `[${truncatedArgs.paths.length} paths, first few: ${truncatedArgs.paths[0]}, ${truncatedArgs.paths[1]}, ${truncatedArgs.paths[2]}, ...]`;
+  }
+  return truncatedArgs;
+}
+__name(truncateContentForLogging, "truncateContentForLogging");
+function parseFileInfo(fileInfoStr) {
+  const result = {
+    name: "",
+    path: "",
+    size: 0,
+    isDirectory: false,
+    modTime: "",
+    mode: ""
+  };
+  const lines = fileInfoStr.split("\n");
+  for (const line of lines) {
+    if (line.includes(":")) {
+      const [key, value] = line.split(":", 2).map((part) => part.trim());
+      switch (key) {
+        case "name":
+          result.name = value;
+          break;
+        case "path":
+          result.path = value;
+          break;
+        case "size":
+          result.size = parseInt(value, 10);
+          break;
+        case "isDirectory":
+          result.isDirectory = value === "true";
+          break;
+        case "modTime":
+          result.modTime = value;
+          break;
+        case "mode":
+          result.mode = value;
+          break;
+        case "owner":
+          result.owner = value;
+          break;
+        case "group":
+          result.group = value;
+          break;
+      }
+    }
+  }
+  return result;
+}
+__name(parseFileInfo, "parseFileInfo");
+function parseDirectoryListing(text) {
+  const result = [];
+  const lines = text.split("\n");
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+    if (trimmedLine === "") {
+      continue;
+    }
+    if (trimmedLine.startsWith("[DIR]")) {
+      result.push({
+        isDirectory: true,
+        name: trimmedLine.replace("[DIR]", "").trim()
+      });
+    } else if (trimmedLine.startsWith("[FILE]")) {
+      result.push({
+        isDirectory: false,
+        name: trimmedLine.replace("[FILE]", "").trim()
+      });
+    }
+  }
+  return result;
+}
+__name(parseDirectoryListing, "parseDirectoryListing");
+var _FileSystem = class _FileSystem {
+  /**
+   * Initialize a FileSystem object.
+   * 
+   * @param session - The Session instance that this FileSystem belongs to.
+   */
+  constructor(session) {
+    this.session = session;
+  }
+  /**
+   * Helper method to call MCP tools and handle common response processing
+   * 
+   * @param toolName - Name of the MCP tool to call
+   * @param args - Arguments to pass to the tool
+   * @param defaultErrorMsg - Default error message if specific error details are not available
+   * @returns A CallMcpToolResult with the response data
+   * @throws APIError if the call fails
+   */
+  async callMcpTool(toolName, args, defaultErrorMsg) {
+    try {
+      let loggableArgs = args;
+      if (isFileOperation(toolName)) {
+        loggableArgs = truncateContentForLogging(args);
+      }
+      const argsJSON = JSON.stringify(args);
+      const loggableArgsJSON = JSON.stringify(loggableArgs);
+      const callToolRequest = new CallMcpToolRequest({
+        authorization: `Bearer ${this.session.getAPIKey()}`,
+        sessionId: this.session.getSessionId(),
+        name: toolName,
+        args: argsJSON
+      });
+      log(`API Call: CallMcpTool - ${toolName}`);
+      log(`Request: SessionId=${this.session.getSessionId()}, Args=${loggableArgsJSON}`);
+      const response = await this.session.getClient().callMcpTool(callToolRequest);
+      if (isFileOperation(toolName)) {
+        log(`Response from CallMcpTool - ${toolName} - status: ${response.statusCode}`);
+        if (response.body?.data) {
+          const data2 = response.body.data;
+          if (data2.isError === true) {
+            log(`Response contains error: ${data2.isError}`);
+          } else {
+            log("Response successful, content length info provided separately");
+            if (Array.isArray(data2.content) && data2.content.length > 0) {
+              let totalSize = 0;
+              for (const item of data2.content) {
+                if (item && typeof item === "object" && item.text && typeof item.text === "string") {
+                  totalSize += item.text.length;
+                }
+              }
+              log(`Content size: ${totalSize} bytes`);
+            }
+          }
+        }
+      } else {
+        const sanitizedBody = { ...response.body };
+        if (sanitizedBody.data && typeof sanitizedBody.data === "object") {
+          const sanitizedData = { ...sanitizedBody.data };
+          if (Array.isArray(sanitizedData.content)) {
+            sanitizedData.content = `[Array with ${sanitizedData.content.length} items]`;
+          }
+          sanitizedBody.data = sanitizedData;
+        }
+        log(`Response from CallMcpTool - ${toolName}:`, sanitizedBody);
+      }
+      if (!response.body?.data) {
+        throw new Error("Invalid response data format");
+      }
+      const data = response.body.data;
+      const result = {
+        data,
+        statusCode: response.statusCode || 0,
+        isError: false
+      };
+      if (data.isError === true) {
+        result.isError = true;
+        const contentArray = data.content;
+        if (contentArray && contentArray.length > 0) {
+          result.content = contentArray;
+          if (contentArray[0]?.text) {
+            result.errorMsg = contentArray[0].text;
+            throw new Error(contentArray[0].text);
+          }
+        }
+        throw new Error(defaultErrorMsg);
+      }
+      if (Array.isArray(data.content)) {
+        result.content = data.content;
+        if (result.content.length > 0) {
+          const textParts = [];
+          for (const item of result.content) {
+            if (item && typeof item === "object" && item.text && typeof item.text === "string") {
+              textParts.push(item.text);
+            }
+          }
+          result.textContent = textParts.join("\n");
+        }
+      }
+      return result;
+    } catch (error) {
+      logError(`Error calling CallMcpTool - ${toolName}:`, error);
+      throw new APIError(`Failed to call ${toolName}: ${error}`);
+    }
+  }
+  /**
+   * Creates a new directory at the specified path.
+   * 
+   * @param path - Path to the directory to create.
+   * @returns The extracted text content from the API response
+   * @throws APIError if the operation fails.
+   */
+  async createDirectory(path3) {
+    const args = {
+      path: path3
+    };
+    const result = await this.callMcpTool("create_directory", args, "Failed to create directory");
+    return result.textContent || "";
+  }
+  /**
+   * Edits a file by replacing occurrences of oldText with newText.
+   * 
+   * @param path - Path to the file to edit.
+   * @param edits - Array of edit operations, each containing oldText and newText.
+   * @param dryRun - Optional: If true, preview changes without applying them.
+   * @returns The extracted text content from the API response
+   * @throws APIError if the operation fails.
+   */
+  async editFile(path3, edits, dryRun = false) {
+    const args = {
+      path: path3,
+      edits,
+      dryRun
+    };
+    const result = await this.callMcpTool("edit_file", args, "Failed to edit file");
+    return result.textContent || "";
+  }
+  /**
+   * Gets information about a file or directory.
+   * 
+   * @param path - Path to the file or directory to inspect.
+   * @returns The extracted text content from the API response
+   * @throws APIError if the operation fails.
+   */
+  async getFileInfo(path3) {
+    const args = {
+      path: path3
+    };
+    const result = await this.callMcpTool("get_file_info", args, "Failed to get file info");
+    if (!result.textContent) {
+      throw new APIError("Empty response from get_file_info");
+    }
+    return parseFileInfo(result.textContent);
+  }
+  /**
+   * Lists the contents of a directory.
+   * 
+   * @param path - Path to the directory to list.
+   * @returns Array of directory entries with properties like name, isDirectory
+   * @throws APIError if the operation fails.
+   */
+  async listDirectory(path3) {
+    const args = {
+      path: path3
+    };
+    const result = await this.callMcpTool("list_directory", args, "Failed to list directory");
+    if (!result.textContent) {
+      return [];
+    }
+    return parseDirectoryListing(result.textContent);
+  }
+  /**
+   * Moves a file or directory from source to destination.
+   * 
+   * @param source - Path to the source file or directory.
+   * @param destination - Path to the destination file or directory.
+   * @returns The extracted text content from the API response
+   * @throws APIError if the operation fails.
+   */
+  async moveFile(source, destination) {
+    const args = {
+      source,
+      destination
+    };
+    const result = await this.callMcpTool("move_file", args, "Failed to move file");
+    return result.textContent || "";
+  }
+  /**
+   * Reads the content of a file.
+   * 
+   * @param path - Path to the file to read.
+   * @param offset - Optional: Line offset to start reading from.
+   * @param length - Optional: Number of lines to read. If 0, reads the entire file.
+   * @returns The extracted text content from the API response
+   * @throws APIError if the operation fails.
+   */
+  async readFile(path3, offset = 0, length = 0) {
+    const args = {
+      path: path3
+    };
+    if (offset > 0) {
+      args.offset = offset;
+    }
+    if (length > 0) {
+      args.length = length;
+    }
+    const result = await this.callMcpTool("read_file", args, "Failed to read file");
+    return result.textContent || "";
+  }
+  /**
+   * Reads the content of multiple files.
+   * 
+   * @param paths - Array of file paths to read.
+   * @returns The extracted text content from the API response
+   * @throws APIError if the operation fails.
+   */
+  async readMultipleFiles(paths) {
+    const args = {
+      paths
+    };
+    const result = await this.callMcpTool("read_multiple_files", args, "Failed to read multiple files");
+    if (!result.textContent) {
+      return {};
+    }
+    const fileContents = {};
+    const lines = result.textContent.split("\n");
+    let currentPath = "";
+    let currentContent = [];
+    for (const line of lines) {
+      const colonIndex = line.indexOf(":");
+      if (colonIndex > 0 && currentPath === "" && !line.substring(0, colonIndex).includes(" ")) {
+        const path3 = line.substring(0, colonIndex).trim();
+        currentPath = path3;
+        if (line.length > colonIndex + 1) {
+          const contentStart = line.substring(colonIndex + 1).trim();
+          if (contentStart) {
+            currentContent.push(contentStart);
+          }
+        }
+      } else if (line === "---") {
+        if (currentPath) {
+          fileContents[currentPath] = currentContent.join("\n");
+          currentPath = "";
+          currentContent = [];
+        }
+      } else if (currentPath) {
+        currentContent.push(line);
+      }
+    }
+    if (currentPath) {
+      fileContents[currentPath] = currentContent.join("\n");
+    }
+    for (const path3 in fileContents) {
+      fileContents[path3] = fileContents[path3].replace(/\n+$/, "");
+    }
+    return fileContents;
+  }
+  /**
+   * Searches for files in a directory that match a pattern.
+   * 
+   * @param path - Path to the directory to search in.
+   * @param pattern - Pattern to search for. Supports glob patterns.
+   * @param excludePatterns - Optional: Array of patterns to exclude.
+   * @returns Array of search results with properties like path
+   * @throws APIError if the operation fails.
+   */
+  async searchFiles(path3, pattern, excludePatterns = []) {
+    const args = {
+      path: path3,
+      pattern
+    };
+    if (excludePatterns.length > 0) {
+      args.exclude_patterns = excludePatterns;
+    }
+    const result = await this.callMcpTool("search_files", args, "Failed to search files");
+    if (!result.textContent) {
+      return [];
+    }
+    return result.textContent.split("\n").map((line) => line.trim()).filter((line) => line !== "");
+  }
+  /**
+   * Writes content to a file.
+   * 
+   * @param path - Path to the file to write.
+   * @param content - Content to write to the file.
+   * @param mode - Optional: Write mode. One of "overwrite", "append", or "create_new". Default is "overwrite".
+   * @returns The extracted text content from the API response
+   * @throws APIError if the operation fails.
+   */
+  async writeFile(path3, content, mode = "overwrite") {
+    const validModes = ["overwrite", "append", "create_new"];
+    if (!validModes.includes(mode)) {
+      throw new APIError(`Invalid mode: ${mode}. Must be one of ${validModes.join(", ")}`);
+    }
+    const args = {
+      path: path3,
+      content,
+      mode
+    };
+    const result = await this.callMcpTool("write_file", args, "Failed to write file");
+    return result.textContent || "";
+  }
+  /**
+   * Reads a large file in chunks to handle size limitations of the underlying API.
+   * It automatically splits the read operation into multiple requests of chunkSize bytes each.
+   * 
+   * @param path - Path to the file to read.
+   * @param chunkSize - Optional: Size of each chunk in bytes. Default is 60KB.
+   * @returns The complete file content as a string
+   * @throws APIError if the operation fails.
+   */
+  async readLargeFile(path3, chunkSize = DEFAULT_CHUNK_SIZE) {
+    const fileInfo = await this.getFileInfo(path3);
+    const fileSize = fileInfo.size;
+    if (fileSize === 0) {
+      throw new APIError("Couldn't determine file size");
+    }
+    let result = "";
+    let offset = 0;
+    log(`ReadLargeFile: Starting chunked read of ${path3} (total size: ${fileSize} bytes, chunk size: ${chunkSize} bytes)`);
+    let chunkCount = 0;
+    while (offset < fileSize) {
+      let length = chunkSize;
+      if (offset + length > fileSize) {
+        length = fileSize - offset;
+      }
+      log(`ReadLargeFile: Reading chunk ${chunkCount + 1} (${length} bytes at offset ${offset}/${fileSize})`);
+      try {
+        const chunk = await this.readFile(path3, offset, length);
+        result += chunk;
+        offset += length;
+        chunkCount++;
+      } catch (error) {
+        logError(`Error reading chunk at offset ${offset}: ${error}`);
+        throw new APIError(`Error reading chunk at offset ${offset}: ${error}`);
+      }
+    }
+    log(`ReadLargeFile: Successfully read ${path3} in ${chunkCount} chunks (total: ${fileSize} bytes)`);
+    return result;
+  }
+  /**
+   * Writes a large file in chunks to handle size limitations of the underlying API.
+   * It automatically splits the write operation into multiple requests of chunkSize bytes each.
+   * 
+   * @param path - Path to the file to write.
+   * @param content - Content to write to the file.
+   * @param chunkSize - Optional: Size of each chunk in bytes. Default is 60KB.
+   * @returns True if the operation was successful
+   * @throws APIError if the operation fails.
+   */
+  async writeLargeFile(path3, content, chunkSize = DEFAULT_CHUNK_SIZE) {
+    const contentLen = content.length;
+    log(`WriteLargeFile: Starting chunked write to ${path3} (total size: ${contentLen} bytes, chunk size: ${chunkSize} bytes)`);
+    if (contentLen <= chunkSize) {
+      log(`WriteLargeFile: Content size (${contentLen} bytes) is smaller than chunk size, using normal WriteFile`);
+      await this.writeFile(path3, content, "overwrite");
+      return true;
+    }
+    const firstChunkEnd = Math.min(chunkSize, contentLen);
+    log(`WriteLargeFile: Writing first chunk (0-${firstChunkEnd} bytes) with overwrite mode`);
+    await this.writeFile(path3, content.substring(0, firstChunkEnd), "overwrite");
+    let chunkCount = 1;
+    for (let offset = firstChunkEnd; offset < contentLen; ) {
+      const end = Math.min(offset + chunkSize, contentLen);
+      log(`WriteLargeFile: Writing chunk ${chunkCount + 1} (${offset}-${end} bytes) with append mode`);
+      await this.writeFile(path3, content.substring(offset, end), "append");
+      offset = end;
+      chunkCount++;
+    }
+    log(`WriteLargeFile: Successfully wrote ${path3} in ${chunkCount} chunks (total: ${contentLen} bytes)`);
+    return true;
+  }
+};
+__name(_FileSystem, "FileSystem");
+var FileSystem = _FileSystem;
+
+// src/command/command.ts
+init_esm_shims();
+var _Command = class _Command {
+  /**
+   * Initialize a Command object.
+   * 
+   * @param session - The Session instance that this Command belongs to.
+   */
+  constructor(session) {
+    this.session = session;
+  }
+  /**
+   * Helper method to call MCP tools and handle common response processing
+   * 
+   * @param toolName - Name of the MCP tool to call
+   * @param args - Arguments to pass to the tool
+   * @param defaultErrorMsg - Default error message if specific error details are not available
+   * @returns A CallMcpToolResult with the response data
+   * @throws APIError if the call fails
+   */
+  async callMcpTool(toolName, args, defaultErrorMsg) {
+    try {
+      const argsJSON = JSON.stringify(args);
+      const callToolRequest = new CallMcpToolRequest({
+        authorization: `Bearer ${this.session.getAPIKey()}`,
+        sessionId: this.session.getSessionId(),
+        name: toolName,
+        args: argsJSON
+      });
+      log(`API Call: CallMcpTool - ${toolName}`);
+      log(`Request: SessionId=${this.session.getSessionId()}, Args=${argsJSON}`);
+      const response = await this.session.getClient().callMcpTool(callToolRequest);
+      log(`Response from CallMcpTool - ${toolName}:`, response.body);
+      if (!response.body?.data) {
+        throw new Error("Invalid response data format");
+      }
+      const data = response.body.data;
+      const result = {
+        data,
+        statusCode: response.statusCode || 0,
+        isError: false
+      };
+      if (data.isError === true) {
+        result.isError = true;
+        const contentArray = data.content;
+        if (contentArray && contentArray.length > 0) {
+          result.content = contentArray;
+          if (contentArray[0]?.text) {
+            result.errorMsg = contentArray[0].text;
+            throw new Error(contentArray[0].text);
+          }
+        }
+        throw new Error(defaultErrorMsg);
+      }
+      if (Array.isArray(data.content)) {
+        result.content = data.content;
+        if (result.content.length > 0) {
+          const textParts = [];
+          for (const item of result.content) {
+            if (item && typeof item === "object" && item.text && typeof item.text === "string") {
+              textParts.push(item.text);
+            }
+          }
+          result.textContent = textParts.join("\n");
+        }
+      }
+      return result;
+    } catch (error) {
+      logError(`Error calling CallMcpTool - ${toolName}:`, error);
+      throw new APIError(`Failed to call ${toolName}: ${error}`);
+    }
+  }
+  /**
+   * Helper method to parse JSON string or return a simple object with output
+   */
+  parseCommandResult(text) {
+    try {
+      return JSON.parse(text);
+    } catch (error) {
+      return { output: text };
+    }
+  }
+  /**
+   * Execute a command in the cloud environment with a specified timeout.
+   * 
+   * @param command - The command to execute.
+   * @param timeoutMs - The timeout for the command execution in milliseconds. Default is 1000ms.
+   * @returns A string containing the command output
+   */
+  async executeCommand(command, timeoutMs = 1e3) {
+    const args = {
+      command,
+      timeout_ms: timeoutMs
+    };
+    const result = await this.callMcpTool("shell", args, "Failed to execute command");
+    return result.textContent || "";
+  }
+  /**
+   * Helper method to parse JSON string or return a simple object with output
+   */
+  parseCodeExecutionResult(text) {
+    try {
+      return JSON.parse(text);
+    } catch (error) {
+      return { output: text };
+    }
+  }
+  /**
+   * Execute code in the specified language with a timeout.
+   * 
+   * @param code - The code to execute.
+   * @param language - The programming language of the code. Must be either 'python' or 'javascript'.
+   * @param timeoutS - The timeout for the code execution in seconds. Default is 300s.
+   * @returns A string containing the code execution output
+   * @throws APIError if the code execution fails or if an unsupported language is specified.
+   */
+  async runCode(code, language, timeoutS = 300) {
+    if (language !== "python" && language !== "javascript") {
+      throw new Error(`Unsupported language: ${language}. Supported languages are 'python' and 'javascript'`);
+    }
+    const args = {
+      code,
+      language,
+      timeout_s: timeoutS
+    };
+    const result = await this.callMcpTool("run_code", args, "Failed to execute code");
+    return result.textContent || "";
+  }
+};
+__name(_Command, "Command");
+var Command = _Command;
+
+// src/oss/index.ts
+init_esm_shims();
+
+// src/oss/oss.ts
+init_esm_shims();
+
+// src/api/index.ts
+init_esm_shims();
+
+// src/api/client.ts
+init_esm_shims();
+import * as $dara44 from "@darabonba/typescript";
+import { OpenApiUtil, $OpenApiUtil } from "@alicloud/openapi-core";
+import * as OpenApiDefault from "@alicloud/openapi-core";
+var OpenApi = OpenApiDefault.default || OpenApiDefault;
+var _Client = class _Client extends (OpenApi.default || OpenApi) {
+  constructor(config) {
+    super(config);
+    this._signatureAlgorithm = "v2";
+    this._endpointRule = "";
+    this.checkConfig(config);
+    this._endpoint = this.getEndpoint("wuyingai", this._regionId, this._endpointRule, this._network, this._suffix, this._endpointMap, this._endpoint);
+  }
+  getEndpoint(productId, regionId, endpointRule, network, suffix, endpointMap, endpoint) {
+    if (!$dara44.isNull(endpoint)) {
+      return endpoint;
+    }
+    if (!$dara44.isNull(endpointMap) && !$dara44.isNull(endpointMap[regionId])) {
+      return endpointMap[regionId];
+    }
+    return OpenApiUtil.getEndpointRules(productId, regionId, endpointRule, network, suffix);
+  }
+  /**
+   * 调用mcp工具
+   * 
+   * @param request - CallMcpToolRequest
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns CallMcpToolResponse
+   */
+  async callMcpToolWithOptions(request, runtime) {
+    request.validate();
+    let body = {};
+    if (!$dara44.isNull(request.args)) {
+      body["Args"] = request.args;
+    }
+    if (!$dara44.isNull(request.authorization)) {
+      body["Authorization"] = request.authorization;
+    }
+    if (!$dara44.isNull(request.externalUserId)) {
+      body["ExternalUserId"] = request.externalUserId;
+    }
+    if (!$dara44.isNull(request.imageId)) {
+      body["ImageId"] = request.imageId;
+    }
+    if (!$dara44.isNull(request.name)) {
+      body["Name"] = request.name;
+    }
+    if (!$dara44.isNull(request.server)) {
+      body["Server"] = request.server;
+    }
+    if (!$dara44.isNull(request.sessionId)) {
+      body["SessionId"] = request.sessionId;
+    }
+    if (!$dara44.isNull(request.tool)) {
+      body["Tool"] = request.tool;
+    }
+    let req = new $OpenApiUtil.OpenApiRequest({
+      body: OpenApiUtil.parseToMap(body)
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "CallMcpTool",
+      version: "2025-05-06",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "Anonymous",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json"
+    });
+    return $dara44.cast(await this.callApi(params, req, runtime), new CallMcpToolResponse({}));
+  }
+  /**
+   * 调用mcp工具
+   * 
+   * @param request - CallMcpToolRequest
+   * @returns CallMcpToolResponse
+   */
+  async callMcpTool(request) {
+    let runtime = new $dara44.RuntimeOptions({});
+    return await this.callMcpToolWithOptions(request, runtime);
+  }
+  /**
+   * 创建 mcp session
+   * 
+   * @param request - CreateMcpSessionRequest
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns CreateMcpSessionResponse
+   */
+  async createMcpSessionWithOptions(request, runtime) {
+    request.validate();
+    let body = {};
+    if (!$dara44.isNull(request.authorization)) {
+      body["Authorization"] = request.authorization;
+    }
+    if (!$dara44.isNull(request.contextId)) {
+      body["ContextId"] = request.contextId;
+    }
+    if (!$dara44.isNull(request.externalUserId)) {
+      body["ExternalUserId"] = request.externalUserId;
+    }
+    if (!$dara44.isNull(request.imageId)) {
+      body["ImageId"] = request.imageId;
+    }
+    if (!$dara44.isNull(request.labels)) {
+      body["Labels"] = request.labels;
+    }
+    if (!$dara44.isNull(request.sessionId)) {
+      body["SessionId"] = request.sessionId;
+    }
+    if (!$dara44.isNull(request.imageId)) {
+      body["ImageId"] = request.imageId;
+    }
+    let req = new $OpenApiUtil.OpenApiRequest({
+      body: OpenApiUtil.parseToMap(body)
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "CreateMcpSession",
+      version: "2025-05-06",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "Anonymous",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json"
+    });
+    return $dara44.cast(await this.callApi(params, req, runtime), new CreateMcpSessionResponse({}));
+  }
+  /**
+   * 创建 mcp session
+   * 
+   * @param request - CreateMcpSessionRequest
+   * @returns CreateMcpSessionResponse
+   */
+  async createMcpSession(request) {
+    let runtime = new $dara44.RuntimeOptions({});
+    return await this.createMcpSessionWithOptions(request, runtime);
+  }
+  /**
+   * 删除持久化上下文
+   * 
+   * @param request - DeleteContextRequest
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns DeleteContextResponse
+   */
+  async deleteContextWithOptions(request, runtime) {
+    request.validate();
+    let body = {};
+    if (!$dara44.isNull(request.authorization)) {
+      body["Authorization"] = request.authorization;
+    }
+    if (!$dara44.isNull(request.id)) {
+      body["Id"] = request.id;
+    }
+    let req = new $OpenApiUtil.OpenApiRequest({
+      body: OpenApiUtil.parseToMap(body)
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "DeleteContext",
+      version: "2025-05-06",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "Anonymous",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json"
+    });
+    return $dara44.cast(await this.callApi(params, req, runtime), new DeleteContextResponse({}));
+  }
+  /**
+   * 删除持久化上下文
+   * 
+   * @param request - DeleteContextRequest
+   * @returns DeleteContextResponse
+   */
+  async deleteContext(request) {
+    let runtime = new $dara44.RuntimeOptions({});
+    return await this.deleteContextWithOptions(request, runtime);
+  }
+  /**
+   * 获取上下文
+   * 
+   * @param request - GetContextRequest
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns GetContextResponse
+   */
+  async getContextWithOptions(request, runtime) {
+    request.validate();
+    let body = {};
+    if (!$dara44.isNull(request.allowCreate)) {
+      body["AllowCreate"] = request.allowCreate;
+    }
+    if (!$dara44.isNull(request.authorization)) {
+      body["Authorization"] = request.authorization;
+    }
+    if (!$dara44.isNull(request.name)) {
+      body["Name"] = request.name;
+    }
+    let req = new $OpenApiUtil.OpenApiRequest({
+      body: OpenApiUtil.parseToMap(body)
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "GetContext",
+      version: "2025-05-06",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "Anonymous",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json"
+    });
+    return $dara44.cast(await this.callApi(params, req, runtime), new GetContextResponse({}));
+  }
+  /**
+   * 获取上下文
+   * 
+   * @param request - GetContextRequest
+   * @returns GetContextResponse
+   */
+  async getContext(request) {
+    let runtime = new $dara44.RuntimeOptions({});
+    return await this.getContextWithOptions(request, runtime);
+  }
+  /**
+   * 获取标签
+   * 
+   * @param request - GetLabelRequest
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns GetLabelResponse
+   */
+  async getLabelWithOptions(request, runtime) {
+    request.validate();
+    let body = {};
+    if (!$dara44.isNull(request.authorization)) {
+      body["Authorization"] = request.authorization;
+    }
+    if (!$dara44.isNull(request.maxResults)) {
+      body["MaxResults"] = request.maxResults;
+    }
+    if (!$dara44.isNull(request.nextToken)) {
+      body["NextToken"] = request.nextToken;
+    }
+    if (!$dara44.isNull(request.sessionId)) {
+      body["SessionId"] = request.sessionId;
+    }
+    let req = new $OpenApiUtil.OpenApiRequest({
+      body: OpenApiUtil.parseToMap(body)
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "GetLabel",
+      version: "2025-05-06",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "Anonymous",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json"
+    });
+    return $dara44.cast(await this.callApi(params, req, runtime), new GetLabelResponse({}));
+  }
+  /**
+   * 获取标签
+   * 
+   * @param request - GetLabelRequest
+   * @returns GetLabelResponse
+   */
+  async getLabel(request) {
+    let runtime = new $dara44.RuntimeOptions({});
+    return await this.getLabelWithOptions(request, runtime);
+  }
+  /**
+   * 获取特定端口的转发链接
+   * 
+   * @param request - GetLinkRequest
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns GetLinkResponse
+   */
+  async getLinkWithOptions(request, runtime) {
+    request.validate();
+    let body = {};
+    if (!$dara44.isNull(request.authorization)) {
+      body["Authorization"] = request.authorization;
+    }
+    if (!$dara44.isNull(request.sessionId)) {
+      body["SessionId"] = request.sessionId;
+    }
+    let req = new $OpenApiUtil.OpenApiRequest({
+      body: OpenApiUtil.parseToMap(body)
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "GetLink",
+      version: "2025-05-06",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "Anonymous",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json"
+    });
+    return $dara44.cast(await this.callApi(params, req, runtime), new GetLinkResponse({}));
+  }
+  /**
+   * 获取特定端口的转发链接
+   * 
+   * @param request - GetLinkRequest
+   * @returns GetLinkResponse
+   */
+  async getLink(request) {
+    let runtime = new $dara44.RuntimeOptions({});
+    return await this.getLinkWithOptions(request, runtime);
+  }
+  /**
+   * 获取mcp资源信息
+   * 
+   * @param request - GetMcpResourceRequest
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns GetMcpResourceResponse
+   */
+  async getMcpResourceWithOptions(request, runtime) {
+    request.validate();
+    let body = {};
+    if (!$dara44.isNull(request.authorization)) {
+      body["Authorization"] = request.authorization;
+    }
+    if (!$dara44.isNull(request.sessionId)) {
+      body["SessionId"] = request.sessionId;
+    }
+    let req = new $OpenApiUtil.OpenApiRequest({
+      body: OpenApiUtil.parseToMap(body)
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "GetMcpResource",
+      version: "2025-05-06",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "Anonymous",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json"
+    });
+    return $dara44.cast(await this.callApi(params, req, runtime), new GetMcpResourceResponse({}));
+  }
+  /**
+   * 获取mcp资源信息
+   * 
+   * @param request - GetMcpResourceRequest
+   * @returns GetMcpResourceResponse
+   */
+  async getMcpResource(request) {
+    let runtime = new $dara44.RuntimeOptions({});
+    return await this.getMcpResourceWithOptions(request, runtime);
+  }
+  /**
+   * 获取上下文列表
+   * 
+   * @param request - ListContextsRequest
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns ListContextsResponse
+   */
+  async listContextsWithOptions(request, runtime) {
+    request.validate();
+    let body = {};
+    if (!$dara44.isNull(request.authorization)) {
+      body["Authorization"] = request.authorization;
+    }
+    if (!$dara44.isNull(request.maxResults)) {
+      body["MaxResults"] = request.maxResults;
+    }
+    if (!$dara44.isNull(request.nextToken)) {
+      body["NextToken"] = request.nextToken;
+    }
+    let req = new $OpenApiUtil.OpenApiRequest({
+      body: OpenApiUtil.parseToMap(body)
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "ListContexts",
+      version: "2025-05-06",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "Anonymous",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json"
+    });
+    return $dara44.cast(await this.callApi(params, req, runtime), new ListContextsResponse({}));
+  }
+  /**
+   * 获取上下文列表
+   * 
+   * @param request - ListContextsRequest
+   * @returns ListContextsResponse
+   */
+  async listContexts(request) {
+    let runtime = new $dara44.RuntimeOptions({});
+    return await this.listContextsWithOptions(request, runtime);
+  }
+  /**
+   * 根据Lable查询Session列表
+   * 
+   * @param request - ListSessionRequest
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns ListSessionResponse
+   */
+  async listSessionWithOptions(request, runtime) {
+    request.validate();
+    let body = {};
+    if (!$dara44.isNull(request.authorization)) {
+      body["Authorization"] = request.authorization;
+    }
+    if (!$dara44.isNull(request.labels)) {
+      body["Labels"] = request.labels;
+    }
+    if (!$dara44.isNull(request.maxResults)) {
+      body["MaxResults"] = request.maxResults;
+    }
+    if (!$dara44.isNull(request.nextToken)) {
+      body["NextToken"] = request.nextToken;
+    }
+    let req = new $OpenApiUtil.OpenApiRequest({
+      body: OpenApiUtil.parseToMap(body)
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "ListSession",
+      version: "2025-05-06",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "Anonymous",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json"
+    });
+    return $dara44.cast(await this.callApi(params, req, runtime), new ListSessionResponse({}));
+  }
+  /**
+   * 根据Lable查询Session列表
+   * 
+   * @param request - ListSessionRequest
+   * @returns ListSessionResponse
+   */
+  async listSession(request) {
+    let runtime = new $dara44.RuntimeOptions({});
+    return await this.listSessionWithOptions(request, runtime);
+  }
+  /**
+   * 修改上下文
+   * 
+   * @param request - ModifyContextRequest
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns ModifyContextResponse
+   */
+  async modifyContextWithOptions(request, runtime) {
+    request.validate();
+    let body = {};
+    if (!$dara44.isNull(request.authorization)) {
+      body["Authorization"] = request.authorization;
+    }
+    if (!$dara44.isNull(request.id)) {
+      body["Id"] = request.id;
+    }
+    if (!$dara44.isNull(request.name)) {
+      body["Name"] = request.name;
+    }
+    let req = new $OpenApiUtil.OpenApiRequest({
+      body: OpenApiUtil.parseToMap(body)
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "ModifyContext",
+      version: "2025-05-06",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "Anonymous",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json"
+    });
+    return $dara44.cast(await this.callApi(params, req, runtime), new ModifyContextResponse({}));
+  }
+  /**
+   * 修改上下文
+   * 
+   * @param request - ModifyContextRequest
+   * @returns ModifyContextResponse
+   */
+  async modifyContext(request) {
+    let runtime = new $dara44.RuntimeOptions({});
+    return await this.modifyContextWithOptions(request, runtime);
+  }
+  /**
+   * 释放 mcp session
+   * 
+   * @param request - ReleaseMcpSessionRequest
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns ReleaseMcpSessionResponse
+   */
+  async releaseMcpSessionWithOptions(request, runtime) {
+    request.validate();
+    let body = {};
+    if (!$dara44.isNull(request.authorization)) {
+      body["Authorization"] = request.authorization;
+    }
+    if (!$dara44.isNull(request.sessionId)) {
+      body["SessionId"] = request.sessionId;
+    }
+    let req = new $OpenApiUtil.OpenApiRequest({
+      body: OpenApiUtil.parseToMap(body)
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "ReleaseMcpSession",
+      version: "2025-05-06",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "Anonymous",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json"
+    });
+    return $dara44.cast(await this.callApi(params, req, runtime), new ReleaseMcpSessionResponse({}));
+  }
+  /**
+   * 释放 mcp session
+   * 
+   * @param request - ReleaseMcpSessionRequest
+   * @returns ReleaseMcpSessionResponse
+   */
+  async releaseMcpSession(request) {
+    let runtime = new $dara44.RuntimeOptions({});
+    return await this.releaseMcpSessionWithOptions(request, runtime);
+  }
+  /**
+   * 设置标签
+   * 
+   * @param request - SetLabelRequest
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns SetLabelResponse
+   */
+  async setLabelWithOptions(request, runtime) {
+    request.validate();
+    let body = {};
+    if (!$dara44.isNull(request.authorization)) {
+      body["Authorization"] = request.authorization;
+    }
+    if (!$dara44.isNull(request.labels)) {
+      body["Labels"] = request.labels;
+    }
+    if (!$dara44.isNull(request.sessionId)) {
+      body["SessionId"] = request.sessionId;
+    }
+    let req = new $OpenApiUtil.OpenApiRequest({
+      body: OpenApiUtil.parseToMap(body)
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "SetLabel",
+      version: "2025-05-06",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "Anonymous",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json"
+    });
+    return $dara44.cast(await this.callApi(params, req, runtime), new SetLabelResponse({}));
+  }
+  /**
+   * 设置标签
+   * 
+   * @param request - SetLabelRequest
+   * @returns SetLabelResponse
+   */
+  async setLabel(request) {
+    let runtime = new $dara44.RuntimeOptions({});
+    return await this.setLabelWithOptions(request, runtime);
+  }
+};
+__name(_Client, "Client");
+var Client = _Client;
+
+// src/oss/oss.ts
+var _Oss = class _Oss {
+  /**
+   * Initialize an Oss object.
+   *
+   * @param session - The Session instance that this Oss belongs to.
+   */
+  constructor(session) {
+    this.session = session;
+  }
+  /**
+   * Helper method to call MCP tools and handle common response processing
+   *
+   * @param toolName - Name of the MCP tool to call
+   * @param args - Arguments to pass to the tool
+   * @param defaultErrorMsg - Default error message if specific error details are not available
+   * @returns A CallMcpToolResult with the response data
+   * @throws APIError if the call fails
+   */
+  async callMcpTool(toolName, args, defaultErrorMsg) {
+    try {
+      const callToolRequest = new CallMcpToolRequest({
+        authorization: `Bearer ${this.session.getAPIKey()}`,
+        sessionId: this.session.getSessionId(),
+        name: toolName,
+        args: JSON.stringify(args)
+      });
+      log(`API Call: CallMcpTool - ${toolName}`);
+      log(`Request: SessionId=${this.session.getSessionId()}, Args=${JSON.stringify(args)}`);
+      const response = await this.session.getClient().callMcpTool(callToolRequest);
+      log(`Response from CallMcpTool - ${toolName}:`, response.body);
+      if (!response.body?.data) {
+        throw new Error("Invalid response data format");
+      }
+      const data = response.body.data;
+      const result = {
+        data,
+        statusCode: response.statusCode || 0,
+        isError: false
+      };
+      if (data.isError === true) {
+        result.isError = true;
+        const contentArray = data.content;
+        if (contentArray && contentArray.length > 0) {
+          result.content = contentArray;
+          if (contentArray[0]?.text) {
+            result.errorMsg = contentArray[0].text;
+            throw new Error(contentArray[0].text);
+          }
+        }
+        throw new Error(defaultErrorMsg);
+      }
+      if (Array.isArray(data.content)) {
+        result.content = data.content;
+        if (result.content.length > 0) {
+          const textParts = [];
+          for (const item of result.content) {
+            if (item && typeof item === "object" && item.text && typeof item.text === "string") {
+              textParts.push(item.text);
+            }
+          }
+          result.textContent = textParts.join("\n");
+        }
+      }
+      return result;
+    } catch (error) {
+      logError(`Error calling CallMcpTool - ${toolName}:`, error);
+      throw new APIError(`Failed to call ${toolName}: ${error}`);
+    }
+  }
+  /**
+   * Initialize OSS environment variables with the specified credentials.
+   *
+   * @param accessKeyId - The Access Key ID for OSS authentication.
+   * @param accessKeySecret - The Access Key Secret for OSS authentication.
+   * @param securityToken - The security token for OSS authentication.
+   * @param endpoint - The OSS service endpoint. If not specified, the default is used.
+   * @param region - The OSS region. If not specified, the default is used.
+   * @returns The extracted text content from the API response
+   */
+  async envInit(accessKeyId, accessKeySecret, securityToken, endpoint, region) {
+    const args = {
+      access_key_id: accessKeyId,
+      access_key_secret: accessKeySecret,
+      security_token: securityToken
+    };
+    if (endpoint) {
+      args.endpoint = endpoint;
+    }
+    if (region) {
+      args.region = region;
+    }
+    const result = await this.callMcpTool("oss_env_init", args, "error initializing OSS environment");
+    return result.textContent || "";
+  }
+  /**
+   * Create an OSS client with the provided credentials.
+   *
+   * @param accessKeyId - The Access Key ID for OSS authentication.
+   * @param accessKeySecret - The Access Key Secret for OSS authentication.
+   * @param endpoint - The OSS service endpoint. If not specified, the default is used.
+   * @param region - The OSS region. If not specified, the default is used.
+   * @returns The extracted text content from the API response
+   */
+  async createClient(accessKeyId, accessKeySecret, endpoint, region) {
+    const args = {
+      access_key_id: accessKeyId,
+      access_key_secret: accessKeySecret
+    };
+    if (endpoint) {
+      args.endpoint = endpoint;
+    }
+    if (region) {
+      args.region = region;
+    }
+    const result = await this.callMcpTool("oss_client_create", args, "error creating OSS client");
+    return result.textContent || "";
+  }
+  /**
+   * Upload a local file or directory to OSS.
+   *
+   * @param bucket - OSS bucket name.
+   * @param object - Object key in OSS.
+   * @param path - Local file or directory path to upload.
+   * @returns The extracted text content from the API response
+   */
+  async upload(bucket, object, path3) {
+    const args = {
+      bucket,
+      object,
+      path: path3
+    };
+    const result = await this.callMcpTool("oss_upload", args, "error uploading to OSS");
+    return result.textContent || "";
+  }
+  /**
+   * Upload a local file or directory to OSS using a pre-signed URL.
+   *
+   * @param url - Pre-signed URL for anonymous upload.
+   * @param path - Local file or directory path to upload.
+   * @returns The extracted text content from the API response
+   */
+  async uploadAnonymous(url, path3) {
+    const args = {
+      url,
+      path: path3
+    };
+    const result = await this.callMcpTool("oss_upload_annon", args, "error uploading anonymously");
+    return result.textContent || "";
+  }
+  /**
+   * Download an object from OSS to a local file or directory.
+   *
+   * @param bucket - OSS bucket name.
+   * @param object - Object key in OSS.
+   * @param path - Local file or directory path to save the downloaded content.
+   * @returns The extracted text content from the API response
+   */
+  async download(bucket, object, path3) {
+    const args = {
+      bucket,
+      object,
+      path: path3
+    };
+    const result = await this.callMcpTool("oss_download", args, "error downloading from OSS");
+    return result.textContent || "";
+  }
+  /**
+   * Download an object from OSS using a pre-signed URL.
+   *
+   * @param url - Pre-signed URL for anonymous download.
+   * @param path - Local file or directory path to save the downloaded content.
+   * @returns The extracted text content from the API response
+   */
+  async downloadAnonymous(url, path3) {
+    const args = {
+      url,
+      path: path3
+    };
+    const result = await this.callMcpTool("oss_download_annon", args, "error downloading anonymously");
+    return result.textContent || "";
+  }
+};
+__name(_Oss, "Oss");
+var Oss = _Oss;
+
+// src/application/application.ts
+init_esm_shims();
+var _Application = class _Application {
+  /**
+   * Creates a new Application instance.
+   * @param session The session object that provides access to the AgentBay API.
+   */
+  constructor(session) {
+    this.session = session;
+  }
+  /**
+   * Helper method to call MCP tools and handle common response processing
+   * 
+   * @param toolName - Name of the MCP tool to call
+   * @param args - Arguments to pass to the tool
+   * @param defaultErrorMsg - Default error message if specific error details are not available
+   * @returns A CallMcpToolResult with the response data
+   * @throws APIError if the call fails
+   */
+  async callMcpTool(toolName, args, defaultErrorMsg) {
+    try {
+      const argsJSON = JSON.stringify(args);
+      const request = new CallMcpToolRequest({
+        authorization: `Bearer ${this.session.getAPIKey()}`,
+        sessionId: this.session.getSessionId(),
+        name: toolName,
+        args: argsJSON
+      });
+      log(`API Call: CallMcpTool - ${toolName}`);
+      log(`Request: SessionId=${request.sessionId}, Args=${request.args}`);
+      const client = this.session.getClient();
+      const response = await client.callMcpTool(request);
+      if (response && response.body) {
+        log(`Response from CallMcpTool - ${toolName}:`, response.body);
+      }
+      if (!response.body?.data) {
+        throw new Error("Invalid response data format");
+      }
+      const data = response.body.data;
+      const result = {
+        data,
+        statusCode: response.statusCode || 0,
+        isError: false
+      };
+      if (data.isError === true) {
+        result.isError = true;
+        const contentArray = data.content;
+        if (contentArray && contentArray.length > 0) {
+          result.content = contentArray;
+          if (contentArray[0]?.text) {
+            result.errorMsg = contentArray[0].text;
+            throw new Error(contentArray[0].text);
+          }
+        }
+        throw new Error(defaultErrorMsg);
+      }
+      if (Array.isArray(data.content)) {
+        result.content = data.content;
+        if (result.content.length > 0) {
+          const textParts = [];
+          for (const item of result.content) {
+            if (item && typeof item === "object" && item.text && typeof item.text === "string") {
+              textParts.push(item.text);
+            }
+          }
+          result.textContent = textParts.join("\n");
+        }
+      }
+      return result;
+    } catch (error) {
+      logError(`Error calling CallMcpTool - ${toolName}:`, error);
+      throw new APIError(`Failed to call ${toolName}: ${error}`);
+    }
+  }
+  /**
+   * Helper method to parse JSON string into objects
+   */
+  parseJSON(jsonString) {
+    try {
+      return JSON.parse(jsonString);
+    } catch (error) {
+      throw new Error(`Failed to parse JSON: ${error}`);
+    }
+  }
+  /**
+   * Retrieves a list of installed applications.
+   * @param startMenu Whether to include applications from the start menu. Defaults to true.
+   * @param desktop Whether to include applications from the desktop. Defaults to true.
+   * @param ignoreSystemApps Whether to ignore system applications. Defaults to true.
+   * @returns Array of InstalledApp objects
+   * @throws Error if the operation fails.
+   */
+  async getInstalledApps(startMenu = true, desktop = true, ignoreSystemApps = true) {
+    const args = {
+      start_menu: startMenu,
+      desktop,
+      ignore_system_apps: ignoreSystemApps
+    };
+    const result = await this.callMcpTool("get_installed_apps", args, "Failed to get installed apps");
+    if (!result.textContent) {
+      return [];
+    }
+    return this.parseJSON(result.textContent);
+  }
+  /**
+   * Starts an application with the given command and optional working directory.
+   * @param startCmd The command to start the application.
+   * @param workDirectory The working directory for the application. Defaults to an empty string.
+   * @returns Array of Process objects representing the started processes
+   * @throws Error if the operation fails.
+   */
+  async startApp(startCmd, workDirectory = "") {
+    const args = {
+      start_cmd: startCmd
+    };
+    if (workDirectory) {
+      args.work_directory = workDirectory;
+    }
+    const result = await this.callMcpTool("start_app", args, "Failed to start app");
+    if (!result.textContent) {
+      return [];
+    }
+    return this.parseJSON(result.textContent);
+  }
+  /**
+   * Stops an application by process name.
+   * @param pname The name of the process to stop.
+   * @throws Error if the operation fails.
+   */
+  async stopAppByPName(pname) {
+    const args = {
+      pname
+    };
+    await this.callMcpTool("stop_app_by_pname", args, "Failed to stop app by pname");
+  }
+  /**
+   * Stops an application by process ID.
+   * @param pid The ID of the process to stop.
+   * @throws Error if the operation fails.
+   */
+  async stopAppByPID(pid) {
+    const args = {
+      pid
+    };
+    await this.callMcpTool("stop_app_by_pid", args, "Failed to stop app by pid");
+  }
+  /**
+   * Stops an application by stop command.
+   * @param stopCmd The command to stop the application.
+   * @throws Error if the operation fails.
+   */
+  async stopAppByCmd(stopCmd) {
+    const args = {
+      stop_cmd: stopCmd
+    };
+    await this.callMcpTool("stop_app_by_cmd", args, "Failed to stop app by command");
+  }
+  /**
+   * Lists all currently visible applications.
+   * @returns Array of Process objects representing the visible processes
+   * @throws Error if the operation fails.
+   */
+  async listVisibleApps() {
+    const args = {};
+    const result = await this.callMcpTool("list_visible_apps", args, "Failed to list visible apps");
+    if (!result.textContent) {
+      return [];
+    }
+    return this.parseJSON(result.textContent);
+  }
+};
+__name(_Application, "Application");
+var Application = _Application;
+
+// src/window/window.ts
+init_esm_shims();
+var _WindowManager = class _WindowManager {
+  /**
+   * Creates a new WindowManager instance.
+   * @param session The session object that provides access to the AgentBay API.
+   */
+  constructor(session) {
+    this.session = session;
+  }
+  /**
+   * Helper method to call MCP tools and handle common response processing
+   * 
+   * @param toolName - Name of the MCP tool to call
+   * @param args - Arguments to pass to the tool
+   * @param defaultErrorMsg - Default error message if specific error details are not available
+   * @returns A CallMcpToolResult with the response data
+   * @throws APIError if the call fails
+   */
+  async callMcpTool(toolName, args, defaultErrorMsg) {
+    try {
+      const argsJSON = JSON.stringify(args);
+      const request = new CallMcpToolRequest({
+        authorization: `Bearer ${this.session.getAPIKey()}`,
+        sessionId: this.session.getSessionId(),
+        name: toolName,
+        args: argsJSON
+      });
+      log(`API Call: CallMcpTool - ${toolName}`);
+      log(`Request: SessionId=${request.sessionId}, Args=${request.args}`);
+      const response = await this.session.getClient().callMcpTool(request);
+      if (response && response.body) {
+        log(`Response from CallMcpTool - ${toolName}:`, response.body);
+      }
+      if (!response.body?.data) {
+        throw new Error("Invalid response data format");
+      }
+      const data = response.body.data;
+      const result = {
+        data,
+        statusCode: response.statusCode || 0,
+        isError: false
+      };
+      if (data.isError === true) {
+        result.isError = true;
+        const contentArray = data.content;
+        if (contentArray && contentArray.length > 0) {
+          result.content = contentArray;
+          if (contentArray[0]?.text) {
+            result.errorMsg = contentArray[0].text;
+            throw new Error(contentArray[0].text);
+          }
+        }
+        throw new Error(defaultErrorMsg);
+      }
+      if (Array.isArray(data.content)) {
+        result.content = data.content;
+        if (result.content.length > 0) {
+          const textParts = [];
+          for (const item of result.content) {
+            if (item && typeof item === "object" && item.text && typeof item.text === "string") {
+              textParts.push(item.text);
+            }
+          }
+          result.textContent = textParts.join("\n");
+        }
+      }
+      return result;
+    } catch (error) {
+      logError(`Error calling CallMcpTool - ${toolName}:`, error);
+      throw new APIError(`Failed to call ${toolName}: ${error}`);
+    }
+  }
+  /**
+   * Helper method to parse JSON string into Window objects
+   * @param jsonStr - JSON string to parse
+   * @returns Array of Window objects or single Window object
+   */
+  parseWindowsFromJSON(jsonStr) {
+    try {
+      const parsed = JSON.parse(jsonStr);
+      return Array.isArray(parsed) ? parsed : [parsed];
+    } catch (error) {
+      throw new Error(`Failed to parse window data: ${error}`);
+    }
+  }
+  /**
+   * Lists all root windows in the system.
+   * @returns Array of Window objects
+   * @throws Error if the operation fails.
+   */
+  async listRootWindows() {
+    const args = {};
+    const result = await this.callMcpTool("list_root_windows", args, "Failed to list root windows");
+    if (!result.textContent) {
+      return [];
+    }
+    return this.parseWindowsFromJSON(result.textContent);
+  }
+  /**
+   * Gets the currently active window.
+   * @returns Window object or null if no active window
+   * @throws Error if the operation fails.
+   */
+  async getActiveWindow() {
+    const args = {};
+    const result = await this.callMcpTool("get_active_window", args, "Failed to get active window");
+    if (!result.textContent) {
+      return null;
+    }
+    const windows = this.parseWindowsFromJSON(result.textContent);
+    return windows.length > 0 ? windows[0] : null;
+  }
+  /**
+   * Activates a window by ID.
+   * @param windowId The ID of the window to activate.
+   * @throws Error if the operation fails.
+   */
+  async activateWindow(windowId) {
+    const args = {
+      window_id: windowId
+    };
+    await this.callMcpTool("activate_window", args, "Failed to activate window");
+  }
+  /**
+   * Maximizes a window by ID.
+   * @param windowId The ID of the window to maximize.
+   * @throws Error if the operation fails.
+   */
+  async maximizeWindow(windowId) {
+    const args = {
+      window_id: windowId
+    };
+    await this.callMcpTool("maximize_window", args, "Failed to maximize window");
+  }
+  /**
+   * Minimizes a window by ID.
+   * @param windowId The ID of the window to minimize.
+   * @throws Error if the operation fails.
+   */
+  async minimizeWindow(windowId) {
+    const args = {
+      window_id: windowId
+    };
+    await this.callMcpTool("minimize_window", args, "Failed to minimize window");
+  }
+  /**
+   * Restores a window by ID.
+   * @param windowId The ID of the window to restore.
+   * @throws Error if the operation fails.
+   */
+  async restoreWindow(windowId) {
+    const args = {
+      window_id: windowId
+    };
+    await this.callMcpTool("restore_window", args, "Failed to restore window");
+  }
+  /**
+   * Closes a window by ID.
+   * @param windowId The ID of the window to close.
+   * @throws Error if the operation fails.
+   */
+  async closeWindow(windowId) {
+    const args = {
+      window_id: windowId
+    };
+    await this.callMcpTool("close_window", args, "Failed to close window");
+  }
+  /**
+   * Sets a window to fullscreen by ID.
+   * @param windowId The ID of the window to set to fullscreen.
+   * @throws Error if the operation fails.
+   */
+  async fullscreenWindow(windowId) {
+    const args = {
+      window_id: windowId
+    };
+    await this.callMcpTool("fullscreen_window", args, "Failed to set window to fullscreen");
+  }
+  /**
+   * Resizes a window by ID.
+   * @param windowId The ID of the window to resize.
+   * @param width The new width of the window.
+   * @param height The new height of the window.
+   * @throws Error if the operation fails.
+   */
+  async resizeWindow(windowId, width, height) {
+    const args = {
+      window_id: windowId,
+      width,
+      height
+    };
+    await this.callMcpTool("resize_window", args, "Failed to resize window");
+  }
+  /**
+   * Enables or disables focus mode.
+   * @param on Whether to enable focus mode.
+   * @throws Error if the operation fails.
+   */
+  async focusMode(on) {
+    const args = {
+      on
+    };
+    await this.callMcpTool("focus_mode", args, "Failed to set focus mode");
+  }
+};
+__name(_WindowManager, "WindowManager");
+var WindowManager = _WindowManager;
+
+// src/ui/ui.ts
+init_esm_shims();
+var KeyCode = {
+  HOME: 3,
+  BACK: 4,
+  VOLUME_UP: 24,
+  VOLUME_DOWN: 25,
+  POWER: 26,
+  MENU: 82
+};
+var _UI = class _UI {
+  /**
+   * Initialize a UI object.
+   * 
+   * @param session - The Session instance that this UI belongs to.
+   */
+  constructor(session) {
+    this.session = session;
+  }
+  /**
+   * Helper method to call MCP tools and handle common response processing
+   * 
+   * @param toolName - Name of the MCP tool to call
+   * @param args - Arguments to pass to the tool
+   * @param defaultErrorMsg - Default error message if specific error details are not available
+   * @returns A CallMcpToolResult with the response data
+   * @throws APIError if the call fails
+   */
+  async callMcpTool(toolName, args, defaultErrorMsg) {
+    try {
+      const argsJSON = JSON.stringify(args);
+      const callToolRequest = new CallMcpToolRequest({
+        authorization: `Bearer ${this.session.getAPIKey()}`,
+        sessionId: this.session.getSessionId(),
+        name: toolName,
+        args: argsJSON
+      });
+      log(`API Call: CallMcpTool - ${toolName}`);
+      log(`Request: SessionId=${this.session.getSessionId()}, Args=${argsJSON}`);
+      const response = await this.session.getClient().callMcpTool(callToolRequest);
+      log(`Response from CallMcpTool - ${toolName}:`, response.body);
+      if (!response.body?.data) {
+        throw new Error("Invalid response data format");
+      }
+      const data = response.body.data;
+      const result = {
+        data,
+        statusCode: response.statusCode || 0,
+        isError: false
+      };
+      if (data.isError === true) {
+        result.isError = true;
+        const contentArray = data.content;
+        if (contentArray && contentArray.length > 0) {
+          result.content = contentArray;
+          if (contentArray[0]?.text) {
+            result.errorMsg = contentArray[0].text;
+            throw new Error(contentArray[0].text);
+          }
+        }
+        throw new Error(defaultErrorMsg);
+      }
+      if (Array.isArray(data.content)) {
+        result.content = data.content;
+        if (result.content.length > 0) {
+          const textParts = [];
+          for (const item of result.content) {
+            if (item && typeof item === "object" && item.text && typeof item.text === "string") {
+              textParts.push(item.text);
+            }
+          }
+          result.textContent = textParts.join("\n");
+        }
+      }
+      return result;
+    } catch (error) {
+      logError(`Error calling CallMcpTool - ${toolName}:`, error);
+      throw new APIError(`Failed to call ${toolName}: ${error}`);
+    }
+  }
+  /**
+   * Retrieves all clickable UI elements within the specified timeout.
+   * 
+   * @param timeoutMs - The timeout in milliseconds. Default is 2000ms.
+   * @returns An array of UIElement objects
+   * @throws Error if the operation fails.
+   */
+  async getClickableUIElements(timeoutMs = 2e3) {
+    const args = {
+      timeout_ms: timeoutMs
+    };
+    const result = await this.callMcpTool("get_clickable_ui_elements", args, "Failed to get clickable UI elements");
+    if (!result.textContent) {
+      return [];
+    }
+    try {
+      return JSON.parse(result.textContent);
+    } catch (error) {
+      logError("Failed to parse clickable UI elements:", error);
+      throw new APIError(`Failed to parse clickable UI elements: ${error}`);
+    }
+  }
+  /**
+   * Retrieves all UI elements within the specified timeout.
+   * 
+   * @param timeoutMs - The timeout in milliseconds. Default is 2000ms.
+   * @returns An array of UIElement objects
+   * @throws Error if the operation fails.
+   */
+  async getAllUIElements(timeoutMs = 2e3) {
+    const args = {
+      timeout_ms: timeoutMs
+    };
+    const result = await this.callMcpTool("get_all_ui_elements", args, "Failed to get all UI elements");
+    if (!result.textContent) {
+      return [];
+    }
+    try {
+      return JSON.parse(result.textContent);
+    } catch (error) {
+      logError("Failed to parse all UI elements:", error);
+      throw new APIError(`Failed to parse all UI elements: ${error}`);
+    }
+  }
+  /**
+   * Sends a key press event.
+   * 
+   * @param key - The key code to send.
+   * @returns The extracted text content from the API response
+   * @throws Error if the operation fails.
+   */
+  async sendKey(key) {
+    const args = {
+      key
+    };
+    const result = await this.callMcpTool("send_key", args, "Failed to send key");
+    return result.textContent || "";
+  }
+  /**
+   * Inputs text into the active field.
+   * 
+   * @param text - The text to input.
+   * @returns The extracted text content from the API response
+   * @throws Error if the operation fails.
+   */
+  async inputText(text) {
+    const args = {
+      text
+    };
+    const result = await this.callMcpTool("input_text", args, "Failed to input text");
+    return result.textContent || "";
+  }
+  /**
+   * Performs a swipe gesture on the screen.
+   * 
+   * @param startX - The starting X coordinate.
+   * @param startY - The starting Y coordinate.
+   * @param endX - The ending X coordinate.
+   * @param endY - The ending Y coordinate.
+   * @param durationMs - The duration of the swipe in milliseconds. Default is 300ms.
+   * @returns The extracted text content from the API response
+   * @throws Error if the operation fails.
+   */
+  async swipe(startX, startY, endX, endY, durationMs = 300) {
+    const args = {
+      start_x: startX,
+      start_y: startY,
+      end_x: endX,
+      end_y: endY,
+      duration_ms: durationMs
+    };
+    const result = await this.callMcpTool("swipe", args, "Failed to perform swipe");
+    return result.textContent || "";
+  }
+  /**
+   * Performs a click at the specified coordinates.
+   * 
+   * @param x - The X coordinate.
+   * @param y - The Y coordinate.
+   * @param button - The mouse button to click. Default is 'left'.
+   * @returns The extracted text content from the API response
+   * @throws Error if the operation fails.
+   */
+  async click(x, y, button = "left") {
+    const args = {
+      x,
+      y,
+      button
+    };
+    const result = await this.callMcpTool("click", args, "Failed to perform click");
+    return result.textContent || "";
+  }
+  /**
+   * Takes a screenshot of the current screen.
+   * 
+   * @returns The extracted text content from the API response (usually a base64-encoded image)
+   * @throws Error if the operation fails.
+   */
+  async screenshot() {
+    const args = {};
+    const result = await this.callMcpTool("system_screenshot", args, "Failed to take screenshot");
+    return result.textContent || "";
+  }
+};
+__name(_UI, "UI");
+var UI = _UI;
+
+// src/session.ts
+var _Session = class _Session {
+  /**
+   * Initialize a Session object.
+   *
+   * @param agentBay - The AgentBay instance that created this session.
+   * @param sessionId - The ID of this session.
+   */
+  constructor(agentBay, sessionId) {
+    this.resourceUrl = "";
+    this.agentBay = agentBay;
+    this.sessionId = sessionId;
+    this.client = agentBay.getClient();
+    log(`Session created with ID: ${sessionId}`);
+    this.filesystem = new FileSystem(this);
+    this.command = new Command(this);
+    this.oss = new Oss(this);
+    this.Application = new Application(this);
+    this.window = new WindowManager(this);
+    this.ui = new UI(this);
+  }
+  /**
+   * Get information about this session.
+   *
+   * @returns Session information.
+   */
+  // async get_info(): Promise<Record<string, any>> {
+  //   // TODO: Implement the API call to get session info
+  //   try {
+  //     const response = await this.client.get(this.baseUrl);
+  //     return response.data;
+  //   } catch (error) {
+  //     throw new APIError(`Failed to get session info: ${error}`);
+  //   }
+  // }
+  /**
+   * Delete this session.
+   *
+   * @returns True if the session was successfully deleted.
+   */
+  async delete() {
+    try {
+      const releaseSessionRequest = new ReleaseMcpSessionRequest({
+        authorization: `Bearer ${this.getAPIKey()}`,
+        sessionId: this.sessionId
+      });
+      console.log("API Call delete: ReleaseMcpSession", this.sessionId);
+      log("API Call: ReleaseMcpSession");
+      log(`Request: SessionId=${this.sessionId}`);
+      const response = await this.client.releaseMcpSession(releaseSessionRequest);
+      log(`Response from ReleaseMcpSession:`, response.body);
+      this.agentBay.removeSession(this.sessionId);
+      return true;
+    } catch (error) {
+      logError("Error calling ReleaseMcpSession:", error);
+      throw new APIError(`Failed to delete session: ${error}`);
+    }
+  }
+  /**
+   * Sets the labels for this session.
+   *
+   * @param labels - The labels to set for the session.
+   * @throws APIError if the operation fails.
+   */
+  async setLabels(labels) {
+    try {
+      const labelsJSON = JSON.stringify(labels);
+      const request = new SetLabelRequest({
+        authorization: `Bearer ${this.getAPIKey()}`,
+        sessionId: this.sessionId,
+        labels: labelsJSON
+      });
+      log("API Call: SetLabel");
+      log(`Request: SessionId=${this.sessionId}, Labels=${labelsJSON}`);
+      const response = await this.client.setLabel(request);
+      log(`Response from SetLabel:`, response.body);
+    } catch (error) {
+      logError("Error calling SetLabel:", error);
+      throw new APIError(`Failed to set labels for session: ${error}`);
+    }
+  }
+  /**
+   * Gets the labels for this session.
+   *
+   * @returns The labels for the session.
+   * @throws APIError if the operation fails.
+   */
+  async getLabels() {
+    try {
+      const request = new GetLabelRequest({
+        authorization: `Bearer ${this.getAPIKey()}`,
+        sessionId: this.sessionId
+      });
+      log("API Call: GetLabel");
+      log(`Request: SessionId=${this.sessionId}`);
+      const response = await this.client.getLabel(request);
+      console.log(`Response from GetLabel: ${JSON.stringify(response)}`);
+      log(`Response from GetLabel:`, response.body);
+      const labelsJSON = response.body?.data?.labels;
+      if (labelsJSON) {
+        return JSON.parse(labelsJSON);
+      }
+      return {};
+    } catch (error) {
+      logError("Error calling GetLabel:", error);
+      throw new APIError(`Failed to get labels for session: ${error}`);
+    }
+  }
+  /**
+   * Get the API key.
+   *
+   * @returns The API key.
+   */
+  getAPIKey() {
+    return this.agentBay.getAPIKey();
+  }
+  /**
+   * Get the client.
+   *
+   * @returns The client.
+   */
+  getClient() {
+    return this.client;
+  }
+  /**
+   * Get the session ID.
+   *
+   * @returns The session ID.
+   */
+  getSessionId() {
+    return this.sessionId;
+  }
+  /**
+   * Gets information about this session.
+   *
+   * @returns Information about the session.
+   * @throws APIError if the operation fails.
+   */
+  async info() {
+    try {
+      const request = new GetMcpResourceRequest({
+        authorization: `Bearer ${this.getAPIKey()}`,
+        sessionId: this.sessionId
+      });
+      log("API Call: GetMcpResource");
+      log(`Request: SessionId=${this.sessionId}`);
+      const response = await this.client.getMcpResource(request);
+      log(`Response from GetMcpResource:`, response.body);
+      const sessionInfo = {
+        sessionId: response.body?.data?.sessionId || "",
+        resourceUrl: response.body?.data?.resourceUrl || ""
+      };
+      if (response.body?.data?.resourceUrl) {
+        this.resourceUrl = response.body.data.resourceUrl;
+      }
+      if (response.body?.data?.desktopInfo) {
+        const desktopInfo = response.body.data.desktopInfo;
+        sessionInfo.appId = desktopInfo.appId;
+        sessionInfo.authCode = desktopInfo.authCode;
+        sessionInfo.connectionProperties = desktopInfo.connectionProperties;
+        sessionInfo.resourceId = desktopInfo.resourceId;
+        sessionInfo.resourceType = desktopInfo.resourceType;
+      }
+      return sessionInfo;
+    } catch (error) {
+      logError("Error calling GetMcpResource:", error);
+      throw new APIError(`Failed to get session info for session ${this.sessionId}: ${error}`);
+    }
+  }
+  /**
+   * Gets the link for this session.
+   *
+   * @returns The link for the session.
+   * @throws APIError if the operation fails.
+   */
+  async getLink() {
+    try {
+      const request = new GetLinkRequest({
+        authorization: `Bearer ${this.getAPIKey()}`,
+        sessionId: this.sessionId
+      });
+      log("API Call: GetLink");
+      log(`Request: SessionId=${this.sessionId}`);
+      const response = await this.client.getLink(request);
+      log(`Response from GetLink:`, response.body);
+      if (response.body?.data) {
+        return response.body.data;
+      }
+      return "";
+    } catch (error) {
+      logError("Error calling GetLink:", error);
+      throw new APIError(`Failed to get link for session ${this.sessionId}: ${error}`);
+    }
+  }
+};
+__name(_Session, "Session");
+var Session = _Session;
+
+// src/context.ts
+init_esm_shims();
+var _Context = class _Context {
+  /**
+   * Initialize a Context object.
+   * 
+   * @param id - The unique identifier of the context.
+   * @param name - The name of the context.
+   * @param state - The current state of the context.
+   * @param createdAt - Date and time when the Context was created.
+   * @param lastUsedAt - Date and time when the Context was last used.
+   * @param osType - The operating system type this context is bound to.
+   */
+  constructor(id, name, state = "available", createdAt, lastUsedAt, osType) {
+    this.id = id;
+    this.name = name;
+    this.state = state;
+    this.createdAt = createdAt;
+    this.lastUsedAt = lastUsedAt;
+    this.osType = osType;
+  }
+};
+__name(_Context, "Context");
+var Context = _Context;
+var _ContextService = class _ContextService {
+  /**
+   * Initialize the ContextService.
+   * 
+   * @param agentBay - The AgentBay instance.
+   */
+  constructor(agentBay) {
+    this.agentBay = agentBay;
+  }
+  /**
+   * Lists all available contexts.
+   * 
+   * @returns A list of Context objects.
+   */
+  async list() {
+    try {
+      const request = new ListContextsRequest({
+        authorization: `Bearer ${this.agentBay.getAPIKey()}`
+      });
+      log("API Call: ListContexts");
+      log("Request: No parameters");
+      const response = await this.agentBay.getClient().listContexts(request);
+      log(`Response from ListContexts:`, response.body);
+      const contexts = [];
+      if (response.body?.data) {
+        for (const contextData of response.body.data) {
+          contexts.push(new Context(
+            contextData.id || "",
+            contextData.name || "",
+            contextData.state || "available",
+            contextData.createTime,
+            contextData.lastUsedTime,
+            contextData.osType
+          ));
+        }
+      }
+      return contexts;
+    } catch (error) {
+      logError("Error calling ListContexts:", error);
+      throw new APIError(`Failed to list contexts: ${error}`);
+    }
+  }
+  /**
+   * Gets a context by name. Optionally creates it if it doesn't exist.
+   * 
+   * @param name - The name of the context to get.
+   * @param create - Whether to create the context if it doesn't exist.
+   * @returns The Context object if found or created, null if not found and create is false.
+   */
+  async get(name, create = false) {
+    try {
+      const request = new GetContextRequest({
+        name,
+        allowCreate: create ? "true" : "false",
+        authorization: `Bearer ${this.agentBay.getAPIKey()}`
+      });
+      log("API Call: GetContext");
+      log(`Request: Name=${name}, AllowCreate=${create}`);
+      const response = await this.agentBay.getClient().getContext(request);
+      log(`Response from GetContext:`, response.body);
+      const contextId = response.body?.data?.id;
+      if (!contextId) {
+        return null;
+      }
+      const contexts = await this.list();
+      for (const context of contexts) {
+        if (context.id === contextId) {
+          return context;
+        }
+      }
+      return new Context(contextId, name);
+    } catch (error) {
+      logError("Error calling GetContext:", error);
+      throw new APIError(`Failed to get context ${name}: ${error}`);
+    }
+  }
+  /**
+   * Creates a new context with the given name.
+   * 
+   * @param name - The name for the new context.
+   * @returns The created Context object.
+   */
+  async create(name) {
+    const context = await this.get(name, true);
+    if (!context) {
+      throw new APIError(`Failed to create context ${name}`);
+    }
+    return context;
+  }
+  /**
+   * Updates the specified context.
+   * 
+   * @param context - The Context object to update.
+   * @returns The updated Context object.
+   */
+  async update(context) {
+    try {
+      const request = new ModifyContextRequest({
+        id: context.id,
+        name: context.name,
+        authorization: `Bearer ${this.agentBay.getAPIKey()}`
+      });
+      log("API Call: ModifyContext");
+      log(`Request: Id=${context.id}, Name=${context.name}`);
+      const response = await this.agentBay.getClient().modifyContext(request);
+      log(`Response from ModifyContext:`, response.body);
+      return context;
+    } catch (error) {
+      logError("Error calling ModifyContext:", error);
+      throw new APIError(`Failed to update context ${context.id}: ${error}`);
+    }
+  }
+  /**
+   * Deletes the specified context.
+   * 
+   * @param context - The Context object to delete.
+   */
+  async delete(context) {
+    try {
+      const request = new DeleteContextRequest({
+        id: context.id,
+        authorization: `Bearer ${this.agentBay.getAPIKey()}`
+      });
+      log("API Call: DeleteContext");
+      log(`Request: Id=${context.id}`);
+      const response = await this.agentBay.getClient().deleteContext(request);
+      log(`Response from DeleteContext:`, response.body);
+    } catch (error) {
+      logError("Error calling DeleteContext:", error);
+      throw new APIError(`Failed to delete context ${context.id}: ${error}`);
+    }
+  }
+};
+__name(_ContextService, "ContextService");
+var ContextService = _ContextService;
+
+// src/agent-bay.ts
+import { $OpenApiUtil as $OpenApiUtil2 } from "@alicloud/openapi-core";
+
+// src/config.ts
+init_esm_shims();
+import * as fs from "fs";
+import * as path2 from "path";
+
+// node_modules/dotenv/config.js
+init_esm_shims();
+(function() {
+  require_main().config(
+    Object.assign(
+      {},
+      require_env_options(),
+      require_cli_options()(process.argv)
+    )
+  );
+})();
+
+// src/config.ts
+function defaultConfig() {
+  return {
+    region_id: "cn-shanghai",
+    endpoint: "wuyingai.cn-shanghai.aliyuncs.com",
+    timeout_ms: 3e5
+  };
+}
+__name(defaultConfig, "defaultConfig");
+function loadConfig() {
+  let configPath = process.env.AGENTBAY_CONFIG_PATH;
+  if (!configPath) {
+    try {
+      let dirPath = process.cwd();
+      let found = false;
+      for (let i = 0; i < 10; i++) {
+        const possibleConfigPath = path2.join(dirPath, ".config.json");
+        if (fs.existsSync(possibleConfigPath)) {
+          configPath = possibleConfigPath;
+          found = true;
+          log(`Found config file at: ${possibleConfigPath}`);
+          break;
+        }
+        const parentDir = path2.dirname(dirPath);
+        if (parentDir === dirPath) {
+          break;
+        }
+        dirPath = parentDir;
+      }
+      if (!found) {
+        log("Warning: Configuration file not found, using default values");
+        return defaultConfig();
+      }
+    } catch (error) {
+      log(`Warning: Failed to search for configuration file: ${error}, using default values`);
+      return defaultConfig();
+    }
+  }
+  try {
+    if (!configPath) {
+      log("Warning: Configuration file path is undefined, using default values");
+      return defaultConfig();
+    }
+    const data = fs.readFileSync(configPath, "utf8");
+    const config = JSON.parse(data);
+    if (process.env.AGENTBAY_REGION_ID) {
+      config.region_id = process.env.AGENTBAY_REGION_ID;
+    }
+    if (process.env.AGENTBAY_ENDPOINT) {
+      config.endpoint = process.env.AGENTBAY_ENDPOINT;
+    }
+    return config;
+  } catch (error) {
+    log(`Warning: Failed to read configuration file: ${error}, using default values`);
+    return defaultConfig();
+  }
+}
+__name(loadConfig, "loadConfig");
+
+// src/agent-bay.ts
+var _AgentBay = class _AgentBay {
+  /**
+   * Initialize the AgentBay client.
+   * 
+   * @param options - Configuration options
+   * @param options.apiKey - API key for authentication. If not provided, will look for AGENTBAY_API_KEY environment variable.
+   */
+  constructor(options = {}) {
+    this.sessions = /* @__PURE__ */ new Map();
+    this.apiKey = options.apiKey || process.env.AGENTBAY_API_KEY || "";
+    if (!this.apiKey) {
+      throw new AuthenticationError(
+        "API key is required. Provide it as a parameter or set the AGENTBAY_API_KEY environment variable."
+      );
+    }
+    const configData = loadConfig();
+    this.regionId = configData.region_id;
+    this.endpoint = configData.endpoint;
+    const config = new $OpenApiUtil2.Config({
+      regionId: this.regionId,
+      endpoint: this.endpoint
+    });
+    config.readTimeout = configData.timeout_ms;
+    config.connectTimeout = configData.timeout_ms;
+    try {
+      this.client = new Client(config);
+      this.context = new ContextService(this);
+    } catch (error) {
+      logError(`Failed to constructor:`, error);
+      throw new AuthenticationError(`Failed to constructor: ${error}`);
+    }
+  }
+  /**
+   * Create a new session in the AgentBay cloud environment.
+   * 
+   * @param options - Optional parameters for creating the session
+   * @param options.contextId - ID of the context to bind to the session
+   * @param options.labels - Custom labels for the session
+   * @returns A new Session object.
+   */
+  async create(options = {}) {
+    try {
+      const createSessionRequest = new CreateMcpSessionRequest({
+        authorization: "Bearer " + this.apiKey,
+        imageId: options.imageId
+      });
+      if (options.contextId) {
+        createSessionRequest.contextId = options.contextId;
+      }
+      if (options.labels) {
+        createSessionRequest.labels = JSON.stringify(options.labels);
+      }
+      log("API Call: CreateMcpSession");
+      log(`Request: ${options.contextId ? `ContextId=${options.contextId}, ` : ""}${options.labels ? `Labels=${JSON.stringify(options.labels)}, ` : ""}${options.imageId ? `ImageId=${options.imageId}` : ""}`);
+      const response = await this.client.createMcpSession(createSessionRequest);
+      log(`Response from CreateMcpSession:`, response.body);
+      const sessionId = response.body?.data?.sessionId;
+      if (!sessionId) {
+        throw new APIError("Invalid session ID in response");
+      }
+      const resourceUrl = response.body?.data?.resourceUrl;
+      const session = new Session(this, sessionId);
+      if (resourceUrl) {
+        session.resourceUrl = resourceUrl;
+      }
+      this.sessions.set(session.sessionId, session);
+      return session;
+    } catch (error) {
+      logError("Error calling CreateMcpSession:", error);
+      throw new APIError(`Failed to create session: ${error}`);
+    }
+  }
+  /**
+   * List all available sessions.
+   * 
+   * @returns A list of session objects.
+   */
+  list() {
+    return Array.from(this.sessions.values());
+  }
+  /**
+   * List sessions filtered by the provided labels.
+   * It returns sessions that match all the specified labels.
+   * 
+   * @param labels - The labels to filter by.
+   * @returns A list of session objects that match the labels.
+   */
+  async listByLabels(labels) {
+    try {
+      const labelsJSON = JSON.stringify(labels);
+      const listSessionRequest = new ListSessionRequest({
+        authorization: `Bearer ${this.apiKey}`,
+        labels: labelsJSON
+      });
+      log("API Call: ListSession");
+      log(`Request: Labels=${labelsJSON}`);
+      const response = await this.client.listSession(listSessionRequest);
+      log(`Response from ListSession:`, response.body);
+      const sessions = [];
+      if (response.body?.data) {
+        for (const sessionData of response.body.data) {
+          if (sessionData.sessionId) {
+            const session = new Session(this, sessionData.sessionId);
+            sessions.push(session);
+            this.sessions.set(sessionData.sessionId, session);
+          }
+        }
+      }
+      return sessions;
+    } catch (error) {
+      logError("Error calling ListSession:", error);
+      throw new APIError(`Failed to list sessions by labels: ${error}`);
+    }
+  }
+  /**
+   * Delete a session by ID.
+   * 
+   * @param sessionId - The ID of the session to delete.
+   * @returns True if the session was successfully deleted.
+   */
+  async delete(session) {
+    const getSession = this.sessions.get(session.sessionId);
+    if (!getSession) {
+      throw new Error(`Session with ID ${session.sessionId} not found`);
+    }
+    try {
+      await session.delete();
+      return true;
+    } catch (error) {
+      throw new APIError(`Failed to delete session: ${error}`);
+    }
+  }
+  /**
+   * 
+   * @param sessionId - The ID of the session to remove.
+   */
+  removeSession(sessionId) {
+    this.sessions.delete(sessionId);
+  }
+  // For internal use by the Session class
+  getClient() {
+    return this.client;
+  }
+  getAPIKey() {
+    return this.apiKey;
+  }
+};
+__name(_AgentBay, "AgentBay");
+var AgentBay = _AgentBay;
+export {
+  APIError,
+  AgentBay,
+  AgentBayError,
+  Application,
+  AuthenticationError,
+  CallMcpToolRequest,
+  CallMcpToolResponse,
+  CallMcpToolResponseBody,
+  Client,
+  Command,
+  CommandError,
+  Context,
+  ContextService,
+  CreateMcpSessionRequest,
+  CreateMcpSessionResponse,
+  CreateMcpSessionResponseBody,
+  CreateMcpSessionResponseBodyData,
+  DeleteContextRequest,
+  DeleteContextResponse,
+  DeleteContextResponseBody,
+  FileError,
+  FileSystem,
+  GetContextRequest,
+  GetContextResponse,
+  GetContextResponseBody,
+  GetContextResponseBodyData,
+  GetLabelRequest,
+  GetLabelResponse,
+  GetLabelResponseBody,
+  GetLabelResponseBodyData,
+  GetLinkRequest,
+  GetLinkResponse,
+  GetLinkResponseBody,
+  GetMcpResourceRequest,
+  GetMcpResourceResponse,
+  GetMcpResourceResponseBody,
+  GetMcpResourceResponseBodyData,
+  GetMcpResourceResponseBodyDataDesktopInfo,
+  KeyCode,
+  ListContextsRequest,
+  ListContextsResponse,
+  ListContextsResponseBody,
+  ListContextsResponseBodyData,
+  ListSessionRequest,
+  ListSessionResponse,
+  ListSessionResponseBody,
+  ListSessionResponseBodyData,
+  ModifyContextRequest,
+  ModifyContextResponse,
+  ModifyContextResponseBody,
+  Oss,
+  ReleaseMcpSessionRequest,
+  ReleaseMcpSessionResponse,
+  ReleaseMcpSessionResponseBody,
+  Session,
+  SetLabelRequest,
+  SetLabelResponse,
+  SetLabelResponseBody,
+  UI
+};
+//# sourceMappingURL=index.mjs.map
+