@cloudbase/cloudbase-mcp 2.8.0 → 2.10.0

package/dist/index.cjs

@@ -1726,7 +1726,7 @@ function registerEnvTools(server) {
                     // Get CLAUDE.md prompt content (skip for CodeBuddy IDE)
                     let promptContent = "";
                     const currentIde = server.ide || process.env.INTEGRATION_IDE;
-                    if (currentIde !== "CodeBuddy") {
+                    if (currentIde !== "CodeBuddy" && process.env.CLOUDBASE_GUIDE_PROMPT !== "false") {
                         try {
                             promptContent = await (0, rag_js_1.getClaudePrompt)();
                         }
@@ -1829,7 +1829,7 @@ function registerEnvTools(server) {
                         });
                         // Use commonService to call DescribeEnvs with filter parameters
                         // Filter parameters match the reference conditions provided by user
-                        result = await cloudbaseList.commonService("tcb").call({
+                        result = await cloudbaseList.commonService("tcb", "2018-06-08").call({
                             Action: "DescribeEnvs",
                             Param: {
                                 EnvTypes: ["weda", "baas"], // Include weda and baas (normal) environments
@@ -1912,7 +1912,7 @@ function registerEnvTools(server) {
             let responseText = JSON.stringify(result, null, 2);
             // For info action, append CLAUDE.md prompt content (skip for CodeBuddy IDE)
             const currentIde = server.ide || process.env.INTEGRATION_IDE;
-            if (action === "info" && currentIde !== "CodeBuddy") {
+            if (action === "info" && currentIde !== "CodeBuddy" && process.env.CLOUDBASE_GUIDE_PROMPT !== "false") {
                 try {
                     const promptContent = await (0, rag_js_1.getClaudePrompt)();
                     if (promptContent) {
@@ -23837,7 +23837,10 @@ async function getCloudBaseManager(options = {}) {
         return createCloudBaseManagerWithOptions(cloudBaseOptions);
     }
     try {
-        const loginState = await (0, auth_js_1.getLoginState)();
+        // Get region from environment variable for auth URL
+        // Note: At this point, cloudBaseOptions is undefined (checked above), so only use env var
+        const region = process.env.TCB_REGION;
+        const loginState = await (0, auth_js_1.getLoginState)({ region });
         const { envId: loginEnvId, secretId, secretKey, token } = loginState;
         let finalEnvId;
         if (requireEnvId) {
@@ -23862,12 +23865,17 @@ async function getCloudBaseManager(options = {}) {
         }
         // envId priority: envManager.cachedEnvId > envManager.getEnvId() > loginState.envId > undefined
         // Note: envManager.cachedEnvId has highest priority as it reflects user's latest environment switch
+        // Region priority: process.env.TCB_REGION > undefined (use SDK default)
+        // At this point, cloudBaseOptions is undefined (checked above), so only use env var if present
+        // Reuse region variable declared above (line 259) for CloudBase initialization
         const manager = new manager_node_1.default({
             secretId,
             secretKey,
             envId: finalEnvId || loginEnvId,
             token,
             proxy: process.env.http_proxy,
+            region,
+            // REGION 国际站需要指定 region
         });
         return manager;
     }
@@ -23877,15 +23885,18 @@ async function getCloudBaseManager(options = {}) {
     }
 }
 /**
- * 使用传入的 CloudBase 配置创建 manager，不使用缓存
- * @param cloudBaseOptions 传入的 CloudBase 配置选项
- * @returns CloudBase manager 实例
+ * Create a manager with the provided CloudBase options, without using cache
+ * @param cloudBaseOptions Provided CloudBase options
+ * @returns CloudBase manager instance
  */
 function createCloudBaseManagerWithOptions(cloudBaseOptions) {
-    (0, logger_js_1.debug)('使用传入的 CloudBase 配置创建 manager:', cloudBaseOptions);
+    (0, logger_js_1.debug)('Create manager with provided CloudBase options:', cloudBaseOptions);
+    // Region priority: cloudBaseOptions.region > process.env.TCB_REGION > undefined (use SDK default)
+    const region = cloudBaseOptions.region ?? process.env.TCB_REGION ?? undefined;
     const manager = new manager_node_1.default({
         ...cloudBaseOptions,
         proxy: cloudBaseOptions.proxy || process.env.http_proxy,
+        region
     });
     return manager;
 }
@@ -24095,9 +24106,14 @@ async function _promptAndSetEnvironmentId(autoSelectSingle, options) {
     }
     // 1. 确保用户已登录
     (0, logger_js_1.debug)("[interactive] Step 1: Checking login state...");
+    // Get region from server options or environment variable for auth URL
+    // Note: serverCloudBaseOptions will be declared later (line 282), so we get it here first
+    const serverCloudBaseOptionsForAuth = server?.cloudBaseOptions;
+    const region = serverCloudBaseOptionsForAuth?.region || process.env.TCB_REGION;
     const loginState = await (0, auth_js_1.getLoginState)({
         fromCloudBaseLoginPage: options?.loginFromCloudBaseLoginPage,
         ignoreEnvVars: options?.ignoreEnvVars,
+        region,
     });
     (0, logger_js_1.debug)("[interactive] Login state:", {
         hasLoginState: !!loginState,
@@ -24129,6 +24145,14 @@ async function _promptAndSetEnvironmentId(autoSelectSingle, options) {
         cloudBaseOptions: serverCloudBaseOptions,
     });
     (0, logger_js_1.debug)("[interactive] CloudBase manager obtained");
+    // If envId is already set, return directly
+    const envId = serverCloudBaseOptions?.envId || process.env.CLOUDBASE_ENV_ID;
+    if (envId) {
+        return {
+            selectedEnvId: envId,
+            cancelled: false,
+        };
+    }
     // Step 2.1: Check and initialize TCB service if needed
     // Check if retry is requested (from interactive server session data)
     // Ensure server is resolved if it's a Promise (CLI mode)
@@ -24202,7 +24226,7 @@ async function _promptAndSetEnvironmentId(autoSelectSingle, options) {
     let queryEnvSuccess = false;
     let queryEnvError;
     try {
-        // Use commonService to call DescribeEnvs with filter parameters
+        // Use Service to call DescribeEnvs with filter parameters
         // Filter parameters match the reference conditions provided by user
         const queryParams = {
             EnvTypes: ["weda", "baas"], // Include weda and baas (normal) environments
@@ -24210,7 +24234,7 @@ async function _promptAndSetEnvironmentId(autoSelectSingle, options) {
             Channels: ["dcloud", "iotenable", "tem", "scene_module"], // Filter special channels
         };
         (0, logger_js_1.debug)("[interactive] DescribeEnvs params:", queryParams);
-        envResult = await cloudbase.commonService("tcb").call({
+        envResult = await cloudbase.commonService("tcb", "2018-06-08").call({
             Action: "DescribeEnvs",
             Param: queryParams,
         });
@@ -24338,7 +24362,7 @@ async function _promptAndSetEnvironmentId(autoSelectSingle, options) {
                     // Sometimes creation is async and env might not be immediately available
                     (0, logger_js_1.debug)("[interactive] Verifying created environment exists in list...");
                     try {
-                        const verifyResult = await cloudbase.commonService("tcb").call({
+                        const verifyResult = await cloudbase.commonService("tcb", "2018-06-08").call({
                             Action: "DescribeEnvs",
                             Param: {
                                 EnvTypes: ["weda", "baas"],
@@ -24523,6 +24547,15 @@ async function _promptAndSetEnvironmentId(autoSelectSingle, options) {
         accountInfo.uin = String(loginState.uin);
         (0, logger_js_1.debug)("[interactive] Using UIN from loginState:", { uin: accountInfo.uin });
     }
+    // Attach region from server options or environment variable fallback
+    // Reuse serverCloudBaseOptions declared earlier (line 278)
+    const currentServerCloudBaseOptions = server?.cloudBaseOptions;
+    if (currentServerCloudBaseOptions?.region) {
+        accountInfo.region = currentServerCloudBaseOptions.region;
+    }
+    else if (process.env.TCB_REGION) {
+        accountInfo.region = process.env.TCB_REGION;
+    }
     // Report display_env_selection event
     await telemetry_js_1.telemetryReporter.report('toolkit_env_setup', {
         step: 'display_env_selection',
@@ -33396,7 +33429,7 @@ async function checkAndInitTcbService(cloudbase, context) {
             uin: newContext.uin,
             tcbServiceChecked: newContext.tcbServiceChecked
         });
-        const checkResult = await cloudbase.commonService("tcb").call({
+        const checkResult = await cloudbase.commonService("tcb", "2018-06-08").call({
             Action: "CheckTcbService",
             Param: {}
         });
@@ -33417,7 +33450,7 @@ async function checkAndInitTcbService(cloudbase, context) {
             (0, logger_js_1.debug)('[env-setup] TCB service not initialized, attempting to initialize...');
             (0, logger_js_1.debug)('[env-setup] InitTcb params:', { Source: "qcloud", Channel: "mcp" });
             try {
-                const initResult = await cloudbase.commonService("tcb").call({
+                const initResult = await cloudbase.commonService("tcb", "2018-06-08").call({
                     Action: "InitTcb",
                     Param: {
                         Source: "qcloud",
@@ -33505,7 +33538,7 @@ async function checkAndCreateFreeEnv(cloudbase, context) {
         (0, logger_js_1.debug)('[env-setup] DescribeUserPromotionalActivity params:', {
             Names: ["NewUser", "ReturningUser", "BaasFree"]
         });
-        const activityResult = await cloudbase.commonService("tcb").call({
+        const activityResult = await cloudbase.commonService("tcb", "2018-06-08").call({
             Action: "DescribeUserPromotionalActivity",
             Param: {
                 Names: ["NewUser", "ReturningUser", "BaasFree"]
@@ -33556,7 +33589,7 @@ async function checkAndCreateFreeEnv(cloudbase, context) {
                 Source: "qcloud"
             };
             (0, logger_js_1.debug)('[env-setup] CreateFreeEnvByActivity params:', createParams);
-            const createResult = await cloudbase.commonService("tcb").call({
+            const createResult = await cloudbase.commonService("tcb", "2018-06-08").call({
                 Action: "CreateFreeEnvByActivity",
                 Param: createParams
             });
@@ -33701,7 +33734,9 @@ async function checkAndCreateFreeEnv(cloudbase, context) {
  */
 async function getUinForTelemetry() {
     try {
-        const loginState = await (0, auth_js_1.getLoginState)();
+        // Get region from environment variable for auth URL
+        const region = process.env.TCB_REGION;
+        const loginState = await (0, auth_js_1.getLoginState)({ region });
         // Try to extract UIN from loginState
         // Note: actual field name may vary, adjust based on actual response
         return loginState.uin || undefined;
@@ -35538,90 +35573,70 @@ function registerSecurityRuleTools(server) {
         },
     }, async ({ resourceType, resourceId }) => {
         const envId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
-        try {
-            const cloudbase = await getManager();
-            let result;
-            if (resourceType === "noSqlDatabase") {
-                // 查询数据库安全规则
-                result = await cloudbase.commonService().call({
-                    Action: "DescribeSafeRule",
-                    Param: {
-                        CollectionName: resourceId,
-                        EnvId: envId,
-                    },
-                });
-                (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-            }
-            else if (resourceType === "function") {
-                // 查询云函数安全规则
-                result = await cloudbase.commonService().call({
-                    Action: "DescribeSecurityRule",
-                    Param: {
-                        ResourceType: "FUNCTION",
-                        EnvId: envId,
-                    },
-                });
-                (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-            }
-            else if (resourceType === "storage") {
-                // 查询存储安全规则
-                result = await cloudbase.commonService().call({
-                    Action: "DescribeStorageSafeRule",
-                    Param: {
-                        Bucket: resourceId,
-                        EnvId: envId,
-                    },
-                });
-                (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-            }
-            else if (resourceType === "sqlDatabase") {
-                // TODO: 考虑是否有支持指定其他 instance、schema 的需求
-                const instanceId = "default";
-                const schema = envId;
-                const tableName = resourceId;
-                result = await cloudbase.commonService("lowcode").call({
-                    Action: "DescribeDataSourceBasicPolicy",
-                    Param: {
-                        EnvId: envId,
-                        ResourceType: "table",
-                        ResourceId: `${instanceId}#${schema}#${tableName}`,
-                        RoleIdentityList: ["allUser"],
-                    },
-                });
-                (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-            }
-            else {
-                throw new Error(`不支持的资源类型: ${resourceType}`);
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: true,
-                            aclTag: result.AclTag,
-                            rule: result.Rule ?? null,
-                            raw: result,
-                            message: "安全规则读取成功",
-                        }, null, 2),
-                    },
-                ],
-            };
+        const cloudbase = await getManager();
+        let result;
+        if (resourceType === "noSqlDatabase") {
+            result = await cloudbase.commonService().call({
+                Action: "DescribeSafeRule",
+                Param: {
+                    CollectionName: resourceId,
+                    EnvId: envId,
+                },
+            });
+            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
         }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: error.message,
-                            message: "安全规则读取失败",
-                        }, null, 2),
-                    },
-                ],
-            };
+        else if (resourceType === "function") {
+            result = await cloudbase.commonService().call({
+                Action: "DescribeSecurityRule",
+                Param: {
+                    ResourceType: "FUNCTION",
+                    EnvId: envId,
+                },
+            });
+            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+        }
+        else if (resourceType === "storage") {
+            result = await cloudbase.commonService().call({
+                Action: "DescribeStorageSafeRule",
+                Param: {
+                    Bucket: resourceId,
+                    EnvId: envId,
+                },
+            });
+            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
         }
+        else if (resourceType === "sqlDatabase") {
+            const instanceId = "default";
+            const schema = envId;
+            const tableName = resourceId;
+            result = await cloudbase.commonService("lowcode").call({
+                Action: "DescribeDataSourceBasicPolicy",
+                Param: {
+                    EnvId: envId,
+                    ResourceType: "table",
+                    ResourceId: `${instanceId}#${schema}#${tableName}`,
+                    RoleIdentityList: ["allUser"],
+                },
+            });
+            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+        }
+        else {
+            throw new Error(`不支持的资源类型: ${resourceType}`);
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        aclTag: result.AclTag,
+                        rule: result.Rule ?? null,
+                        raw: result,
+                        message: "安全规则读取成功",
+                    }, null, 2),
+                },
+            ],
+        };
     });
     // 写入安全规则 Tool
     server.registerTool?.(exports.WRITE_SECURITY_RULE, {
@@ -35648,154 +35663,138 @@ function registerSecurityRuleTools(server) {
             category: "security-rule",
         },
     }, async ({ resourceType, resourceId, aclTag, rule }) => {
-        try {
-            const cloudbase = await getManager();
-            const envId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
-            let result;
-            if (resourceType === "noSqlDatabase") {
-                if (aclTag === "CUSTOM") {
-                    if (!rule)
-                        throw new Error("noSQL 数据库自定义安全规则（CUSTOM）必须提供 rule 字段");
-                    result = await cloudbase.commonService().call({
-                        Action: "ModifySafeRule",
-                        Param: {
-                            CollectionName: resourceId,
-                            EnvId: envId,
-                            AclTag: aclTag,
-                            Rule: rule,
-                        },
-                    });
-                    (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-                }
-                else {
-                    result = await cloudbase.commonService().call({
-                        Action: "ModifyDatabaseACL",
-                        Param: {
-                            CollectionName: resourceId,
-                            EnvId: envId,
-                            AclTag: aclTag,
-                        },
-                    });
-                    (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-                }
-            }
-            else if (resourceType === "function") {
-                if (aclTag !== "CUSTOM")
-                    throw new Error("云函数安全规则仅支持 CUSTOM 权限类别");
+        const cloudbase = await getManager();
+        const envId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+        let result;
+        if (resourceType === "noSqlDatabase") {
+            if (aclTag === "CUSTOM") {
                 if (!rule)
-                    throw new Error("云函数自定义安全规则（CUSTOM）必须提供 rule 字段");
+                    throw new Error("noSQL 数据库自定义安全规则（CUSTOM）必须提供 rule 字段");
                 result = await cloudbase.commonService().call({
-                    Action: "ModifySecurityRule",
+                    Action: "ModifySafeRule",
                     Param: {
-                        AclTag: aclTag,
+                        CollectionName: resourceId,
                         EnvId: envId,
-                        ResourceType: "FUNCTION",
+                        AclTag: aclTag,
                         Rule: rule,
                     },
                 });
                 (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
             }
-            else if (resourceType === "storage") {
-                if (aclTag === "CUSTOM") {
-                    if (!rule)
-                        throw new Error("存储自定义安全规则（CUSTOM）必须提供 rule 字段");
-                    result = await cloudbase.commonService().call({
-                        Action: "ModifyStorageSafeRule",
-                        Param: {
-                            Bucket: resourceId,
-                            EnvId: envId,
-                            AclTag: aclTag,
-                            Rule: rule,
-                        },
-                    });
-                    (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-                }
-                else {
-                    result = await cloudbase.commonService().call({
-                        Action: "ModifyStorageSafeRule",
-                        Param: {
-                            Bucket: resourceId,
-                            EnvId: envId,
-                            AclTag: aclTag,
-                        },
-                    });
-                    (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-                }
+            else {
+                result = await cloudbase.commonService().call({
+                    Action: "ModifyDatabaseACL",
+                    Param: {
+                        CollectionName: resourceId,
+                        EnvId: envId,
+                        AclTag: aclTag,
+                    },
+                });
+                (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
             }
-            else if (resourceType === "sqlDatabase") {
-                if (aclTag === "CUSTOM") {
-                    throw new Error("SQL 数据库不支持自定义安全规则（CUSTOM）");
-                }
-                const schema = envId;
-                const tableName = resourceId;
-                const instanceId = "default";
-                const resource = `${instanceId}#${schema}#${tableName}`;
-                const resourceType = "table";
-                const effect = "allow";
-                const policyList = [
-                    "allUser",
-                    "anonymousUser",
-                    "externalUser",
-                    "internalUser",
-                ].map((roleIdentity) => ({
-                    RoleIdentity: roleIdentity,
-                    ResourceType: resourceType,
-                    ResourceId: resource,
-                    RowPermission: [],
-                    Effect: effect,
-                }));
-                policyList[0].RowPermission = getRowPermission(aclTag);
-                result = await cloudbase.commonService("lowcode").call({
-                    Action: "BatchCreateResourcePolicy",
+        }
+        else if (resourceType === "function") {
+            if (aclTag !== "CUSTOM")
+                throw new Error("云函数安全规则仅支持 CUSTOM 权限类别");
+            if (!rule)
+                throw new Error("云函数自定义安全规则（CUSTOM）必须提供 rule 字段");
+            result = await cloudbase.commonService().call({
+                Action: "ModifySecurityRule",
+                Param: {
+                    AclTag: aclTag,
+                    EnvId: envId,
+                    ResourceType: "FUNCTION",
+                    Rule: rule,
+                },
+            });
+            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+        }
+        else if (resourceType === "storage") {
+            if (aclTag === "CUSTOM") {
+                if (!rule)
+                    throw new Error("存储自定义安全规则（CUSTOM）必须提供 rule 字段");
+                result = await cloudbase.commonService().call({
+                    Action: "ModifyStorageSafeRule",
                     Param: {
+                        Bucket: resourceId,
                         EnvId: envId,
-                        PolicyList: policyList,
+                        AclTag: aclTag,
+                        Rule: rule,
                     },
                 });
                 (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-                function getRowPermission(policy) {
-                    return {
-                        READONLY: [
-                            { Key: "all", Value: "r" },
-                            { Key: "me", Value: "rw" },
-                        ],
-                        PRIVATE: [{ Key: "me", Value: "rw" }],
-                        ADMINWRITE: [{ Key: "all", Value: "r" }],
-                        ADMINONLY: [],
-                    }[policy];
-                }
             }
             else {
-                throw new Error(`不支持的资源类型: ${resourceType}`);
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: true,
-                            requestId: result.RequestId,
-                            raw: result,
-                            message: "安全规则写入成功",
-                        }, null, 2),
+                result = await cloudbase.commonService().call({
+                    Action: "ModifyStorageSafeRule",
+                    Param: {
+                        Bucket: resourceId,
+                        EnvId: envId,
+                        AclTag: aclTag,
                     },
-                ],
-            };
+                });
+                (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+            }
         }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: error.message,
-                            message: "安全规则写入失败",
-                        }, null, 2),
-                    },
-                ],
-            };
+        else if (resourceType === "sqlDatabase") {
+            if (aclTag === "CUSTOM") {
+                throw new Error("SQL 数据库不支持自定义安全规则（CUSTOM）");
+            }
+            const schema = envId;
+            const tableName = resourceId;
+            const instanceId = "default";
+            const resource = `${instanceId}#${schema}#${tableName}`;
+            const resourceType = "table";
+            const effect = "allow";
+            const policyList = [
+                "allUser",
+                "anonymousUser",
+                "externalUser",
+                "internalUser",
+            ].map((roleIdentity) => ({
+                RoleIdentity: roleIdentity,
+                ResourceType: resourceType,
+                ResourceId: resource,
+                RowPermission: [],
+                Effect: effect,
+            }));
+            policyList[0].RowPermission = getRowPermission(aclTag);
+            result = await cloudbase.commonService("lowcode").call({
+                Action: "BatchCreateResourcePolicy",
+                Param: {
+                    EnvId: envId,
+                    PolicyList: policyList,
+                },
+            });
+            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+            function getRowPermission(policy) {
+                return {
+                    READONLY: [
+                        { Key: "all", Value: "r" },
+                        { Key: "me", Value: "rw" },
+                    ],
+                    PRIVATE: [{ Key: "me", Value: "rw" }],
+                    ADMINWRITE: [{ Key: "all", Value: "r" }],
+                    ADMINONLY: [],
+                }[policy];
+            }
         }
+        else {
+            throw new Error(`不支持的资源类型: ${resourceType}`);
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        requestId: result.RequestId,
+                        raw: result,
+                        message: "安全规则写入成功",
+                    }, null, 2),
+                },
+            ],
+        };
     });
 }
 
@@ -38068,64 +38067,44 @@ function registerDownloadTools(server) {
             category: "download"
         }
     }, async ({ url, relativePath }) => {
-        try {
-            // 验证相对路径安全性
-            if (!isPathSafe(relativePath)) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                success: false,
-                                error: "不安全的相对路径",
-                                message: "相对路径包含路径遍历操作（../）或绝对路径，出于安全考虑已拒绝",
-                                suggestion: "请使用项目根目录下的相对路径，例如：'assets/images/logo.png'"
-                            }, null, 2)
-                        }
-                    ]
-                };
-            }
-            // 计算最终下载路径
-            const targetPath = calculateDownloadPath(relativePath);
-            const projectRoot = getProjectRoot();
-            console.log(`📁 项目根目录: ${projectRoot}`);
-            console.log(`📁 相对路径: ${relativePath}`);
-            console.log(`📁 最终路径: ${targetPath}`);
-            // 下载文件到指定路径
-            const result = await downloadFileToPath(url, targetPath);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: true,
-                            filePath: result.filePath,
-                            relativePath: relativePath,
-                            contentType: result.contentType,
-                            fileSize: result.fileSize,
-                            projectRoot: projectRoot,
-                            message: "文件下载成功到指定路径",
-                            note: `文件已保存到项目目录: ${relativePath}`
-                        }, null, 2)
-                    }
-                ]
-            };
-        }
-        catch (error) {
+        if (!isPathSafe(relativePath)) {
             return {
                 content: [
                     {
                         type: "text",
                         text: JSON.stringify({
                             success: false,
-                            error: error.message,
-                            message: "文件下载失败",
-                            suggestion: "请检查相对路径是否正确，确保不包含 ../ 等路径遍历操作"
+                            error: "不安全的相对路径",
+                            message: "相对路径包含路径遍历操作（../）或绝对路径，出于安全考虑已拒绝",
+                            suggestion: "请使用项目根目录下的相对路径，例如：'assets/images/logo.png'"
                         }, null, 2)
                     }
                 ]
             };
         }
+        const targetPath = calculateDownloadPath(relativePath);
+        const projectRoot = getProjectRoot();
+        console.log(`📁 项目根目录: ${projectRoot}`);
+        console.log(`📁 相对路径: ${relativePath}`);
+        console.log(`📁 最终路径: ${targetPath}`);
+        const result = await downloadFileToPath(url, targetPath);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        filePath: result.filePath,
+                        relativePath: relativePath,
+                        contentType: result.contentType,
+                        fileSize: result.fileSize,
+                        projectRoot: projectRoot,
+                        message: "文件下载成功到指定路径",
+                        note: `文件已保存到项目目录: ${relativePath}`
+                    }, null, 2)
+                }
+            ]
+        };
     });
 }
 
@@ -40381,52 +40360,35 @@ function registerSQLDatabaseTools(server) {
             category: CATEGORY,
         },
     }, async ({ sql }) => {
-        try {
-            const cloudbase = await getManager();
-            const envId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
-            // TODO: 考虑是否有支持指定其他 instance、schema 的需求
-            const schemaId = envId;
-            const instanceId = "default";
-            const result = await cloudbase.commonService("tcb").call({
-                Action: "RunSql",
-                Param: {
+        const cloudbase = await getManager();
+        const envId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+        const schemaId = envId;
+        const instanceId = "default";
+        const result = await cloudbase.commonService("tcb", "2018-06-08").call({
+            Action: "RunSql",
+            Param: {
+                EnvId: envId,
+                Sql: sql,
+                DbInstance: {
                     EnvId: envId,
-                    Sql: sql,
-                    DbInstance: {
-                        EnvId: envId,
-                        InstanceId: instanceId,
-                        Schema: schemaId,
-                    },
+                    InstanceId: instanceId,
+                    Schema: schemaId,
                 },
-            });
-            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: true,
-                            message: "SQL query executed successfully",
-                            result,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: error.message,
-                            message: "SQL query execution failed",
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
+            },
+        });
+        (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        message: "SQL query executed successfully",
+                        result,
+                    }, null, 2),
+                },
+            ],
+        };
     });
     // executeWriteSQL
     server.registerTool?.("executeWriteSQL", {
@@ -40445,52 +40407,35 @@ function registerSQLDatabaseTools(server) {
             category: CATEGORY,
         },
     }, async ({ sql }) => {
-        try {
-            const cloudbase = await getManager();
-            const envId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
-            // TODO: 考虑是否有支持指定其他 instance、schema 的需求
-            const schemaId = envId;
-            const instanceId = "default";
-            const result = await cloudbase.commonService("tcb").call({
-                Action: "RunSql",
-                Param: {
+        const cloudbase = await getManager();
+        const envId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+        const schemaId = envId;
+        const instanceId = "default";
+        const result = await cloudbase.commonService("tcb", "2018-06-08").call({
+            Action: "RunSql",
+            Param: {
+                EnvId: envId,
+                Sql: sql,
+                DbInstance: {
                     EnvId: envId,
-                    Sql: sql,
-                    DbInstance: {
-                        EnvId: envId,
-                        InstanceId: instanceId,
-                        Schema: schemaId,
-                    },
+                    InstanceId: instanceId,
+                    Schema: schemaId,
                 },
-            });
-            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: true,
-                            message: `SQL statement executed successfully. If you just created a table, make sure to check its security rule is set to a proper value by using \`${security_rule_js_1.WRITE_SECURITY_RULE}\` and \`${security_rule_js_1.READ_SECURITY_RULE}\` tools.`,
-                            result,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: error.message,
-                            message: "SQL statement execution failed",
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
+            },
+        });
+        (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        message: `SQL statement executed successfully. If you just created a table, make sure to check its security rule is set to a proper value by using \`${security_rule_js_1.WRITE_SECURITY_RULE}\` and \`${security_rule_js_1.READ_SECURITY_RULE}\` tools.`,
+                        result,
+                    }, null, 2),
+                },
+            ],
+        };
     });
 }
 
@@ -89128,12 +89073,12 @@ function registerFunctionTools(server) {
     // getFunctionList - 获取云函数列表或详情(推荐)
     server.registerTool?.("getFunctionList", {
         title: "查询云函数列表或详情",
-        description: "获取云函数列表或单个函数详情，通过 action 参数区分操作类型",
+        description: "获取云函数列表或单个函数详情。通过 action 参数区分操作类型：list=获取函数列表（默认，无需额外参数），detail=获取函数详情（需要提供 name 参数指定函数名称）",
         inputSchema: {
-            action: zod_1.z.enum(["list", "detail"]).optional().describe("操作类型：list=获取函数列表（默认），detail=获取函数详情"),
+            action: zod_1.z.enum(["list", "detail"]).optional().describe("操作类型：list=获取函数列表（默认，无需额外参数），detail=获取函数详情（需要提供 name 参数）"),
             limit: zod_1.z.number().optional().describe("范围（list 操作时使用）"),
             offset: zod_1.z.number().optional().describe("偏移（list 操作时使用）"),
-            name: zod_1.z.string().optional().describe("函数名称（detail 操作时必需）"),
+            name: zod_1.z.string().optional().describe("要查询的函数名称。当 action='detail' 时，此参数为必填项，必须提供已存在的函数名称。可通过 action='list' 操作获取可用的函数名称列表"),
             codeSecret: zod_1.z.string().optional().describe("代码保护密钥（detail 操作时使用）")
         },
         annotations: {
@@ -89373,17 +89318,30 @@ function registerFunctionTools(server) {
         }
     }, async ({ name, params }) => {
         // 使用闭包中的 cloudBaseOptions
-        const cloudbase = await getManager();
-        const result = await cloudbase.functions.invokeFunction(name, params);
-        (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(result, null, 2)
-                }
-            ]
-        };
+        try {
+            const cloudbase = await getManager();
+            const result = await cloudbase.functions.invokeFunction(name, params);
+            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result, null, 2)
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            const errorMessage = (error instanceof Error ? error.message : String(error));
+            if (errorMessage.includes("Function not found") ||
+                errorMessage.includes("函数不存在")) {
+                throw new Error(`${errorMessage}\n\n` +
+                    `Tip: "invokeFunction" can only call deployed cloud functions. ` +
+                    `For database operations (such as creating collections), ` +
+                    `please use the appropriate database tools instead.`);
+            }
+            throw error;
+        }
     });
     // getFunctionLogs - 获取云函数日志（新版，参数直接展开）
     server.registerTool?.("getFunctionLogs", {
@@ -102398,6 +102356,7 @@ const invite_code_js_1 = __webpack_require__(44760);
 const security_rule_js_1 = __webpack_require__(7862);
 const cloud_mode_js_1 = __webpack_require__(89684);
 const logger_js_1 = __webpack_require__(13039);
+const tencet_cloud_js_1 = __webpack_require__(95018);
 const tool_wrapper_js_1 = __webpack_require__(71363);
 // 默认插件列表
 const DEFAULT_PLUGINS = [
@@ -102417,7 +102376,11 @@ const DEFAULT_PLUGINS = [
     "capi",
 ];
 function registerDatabase(server) {
-    (0, databaseNoSQL_js_1.registerDatabaseTools)(server);
+    // Skip NoSQL database tools for international region (Singapore) as it doesn't support NoSQL DB
+    const region = server.cloudBaseOptions?.region || process.env.TCB_REGION;
+    if (!(0, tencet_cloud_js_1.isInternationalRegion)(region)) {
+        (0, databaseNoSQL_js_1.registerDatabaseTools)(server);
+    }
     (0, databaseSQL_js_1.registerSQLDatabaseTools)(server);
     (0, dataModel_js_1.registerDataModelTools)(server);
 }
@@ -108819,12 +108782,12 @@ function registerDataModelTools(server) {
     // 数据模型查询工具
     server.registerTool?.("manageDataModel", {
         title: "数据模型管理",
-        description: "数据模型查询工具，支持查询和列表数据模型（只读操作）。list操作返回基础信息（不含Schema），get操作返回详细信息（含简化的Schema，包括字段列表、格式、关联关系等），docs操作生成SDK使用文档",
+        description: "数据模型查询工具，支持查询和列表数据模型（只读操作）。通过 action 参数区分操作类型：list=获取模型列表（不含Schema，可选 names 参数过滤），get=查询单个模型详情（含Schema字段列表、格式、关联关系等，需要提供 name 参数），docs=生成SDK使用文档（需要提供 name 参数）",
         inputSchema: {
             action: zod_1.z
                 .enum(["get", "list", "docs"])
-                .describe("操作类型：get=查询单个模型（含Schema字段列表、格式、关联关系），list=获取模型列表（不含Schema），docs=生成SDK使用文档"),
-            name: zod_1.z.string().optional().describe("模型名称（get操作时必填）"),
+                .describe("操作类型：get=查询单个模型（含Schema字段列表、格式、关联关系，需要提供 name 参数），list=获取模型列表（不含Schema，可选 names 参数过滤），docs=生成SDK使用文档（需要提供 name 参数）"),
+            name: zod_1.z.string().optional().describe("要查询的数据模型名称。当 action='get' 或 action='docs' 时，此参数为必填项，必须提供已存在的数据模型名称。可通过 action='list' 操作获取可用的模型名称列表"),
             names: zod_1.z
                 .array(zod_1.z.string())
                 .optional()
@@ -108836,289 +108799,271 @@ function registerDataModelTools(server) {
             category: "database",
         },
     }, async ({ action, name, names, }) => {
-        try {
-            const cloudbase = await getManager();
-            let currentEnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
-            let result;
-            switch (action) {
-                case "get":
-                    if (!name) {
-                        throw new Error("获取数据模型需要提供模型名称");
-                    }
-                    try {
-                        result = await cloudbase.commonService("lowcode").call({
-                            Action: "DescribeBasicDataSource",
-                            Param: {
-                                EnvId: currentEnvId,
-                                Name: name,
-                            },
-                        });
-                        (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-                        // 只保留基础字段，过滤掉冗余信息，并简化Schema
-                        let simplifiedSchema = null;
-                        // 解析并简化Schema
-                        if (result.Data.Schema) {
-                            try {
-                                const schema = JSON.parse(result.Data.Schema);
-                                const properties = schema.properties || {};
-                                // 提取用户定义的字段（排除系统字段）
-                                const userFields = Object.keys(properties)
-                                    .filter((key) => !properties[key]["x-system"]) // 排除系统字段
-                                    .map((key) => {
-                                    const field = properties[key];
-                                    return parseFieldStructure(field, key, schema);
-                                });
-                                // 提取关联关系
-                                const relations = userFields
-                                    .filter((field) => field.linkage)
-                                    .map((field) => ({
-                                    field: field.name,
-                                    type: field.format,
-                                    title: field.title,
-                                    targetModel: field.linkage.parentDataSourceName,
-                                    foreignKey: field.linkage.parentFieldKey,
-                                    displayField: field.linkage.parentFieldTitle,
-                                }));
-                                simplifiedSchema = {
-                                    userFields,
-                                    relations,
-                                    totalFields: Object.keys(properties).length,
-                                    userFieldsCount: userFields.length,
-                                };
-                            }
-                            catch (e) {
-                                simplifiedSchema = { error: "Schema解析失败" };
-                            }
+        const cloudbase = await getManager();
+        let currentEnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+        let result;
+        switch (action) {
+            case "get":
+                if (!name) {
+                    throw new Error("获取数据模型需要提供模型名称");
+                }
+                try {
+                    result = await cloudbase.commonService("lowcode").call({
+                        Action: "DescribeBasicDataSource",
+                        Param: {
+                            EnvId: currentEnvId,
+                            Name: name,
+                        },
+                    });
+                    (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+                    // 只保留基础字段，过滤掉冗余信息，并简化Schema
+                    let simplifiedSchema = null;
+                    // 解析并简化Schema
+                    if (result.Data.Schema) {
+                        try {
+                            const schema = JSON.parse(result.Data.Schema);
+                            const properties = schema.properties || {};
+                            // 提取用户定义的字段（排除系统字段）
+                            const userFields = Object.keys(properties)
+                                .filter((key) => !properties[key]["x-system"]) // 排除系统字段
+                                .map((key) => {
+                                const field = properties[key];
+                                return parseFieldStructure(field, key, schema);
+                            });
+                            // 提取关联关系
+                            const relations = userFields
+                                .filter((field) => field.linkage)
+                                .map((field) => ({
+                                field: field.name,
+                                type: field.format,
+                                title: field.title,
+                                targetModel: field.linkage.parentDataSourceName,
+                                foreignKey: field.linkage.parentFieldKey,
+                                displayField: field.linkage.parentFieldTitle,
+                            }));
+                            simplifiedSchema = {
+                                userFields,
+                                relations,
+                                totalFields: Object.keys(properties).length,
+                                userFieldsCount: userFields.length,
+                            };
                         }
-                        // 尝试生成Mermaid图表
-                        let mermaidDiagram = null;
-                        if (result.Data.Schema &&
-                            jsonSchemaToMermaid &&
-                            simplifiedSchema &&
-                            !simplifiedSchema.error) {
-                            try {
-                                const mainSchema = JSON.parse(result.Data.Schema);
-                                const schemasMap = {
-                                    [name]: mainSchema,
-                                };
-                                // 获取关联模型的 schema
-                                if (simplifiedSchema.relations &&
-                                    simplifiedSchema.relations.length > 0) {
-                                    const relatedModelNames = [
-                                        ...new Set(simplifiedSchema.relations.map((rel) => rel.targetModel)),
-                                    ];
-                                    for (const relatedModelName of relatedModelNames) {
-                                        try {
-                                            const relatedResult = await cloudbase
-                                                .commonService("lowcode")
-                                                .call({
-                                                Action: "DescribeBasicDataSource",
-                                                Param: {
-                                                    EnvId: currentEnvId,
-                                                    Name: relatedModelName,
-                                                },
-                                            });
-                                            if (relatedResult.Data && relatedResult.Data.Schema) {
-                                                schemasMap[relatedModelName] = JSON.parse(relatedResult.Data.Schema);
-                                            }
-                                        }
-                                        catch (e) {
-                                            console.warn(`获取关联模型 ${relatedModelName} 的 schema 失败:`, e);
+                        catch (e) {
+                            simplifiedSchema = { error: "Schema解析失败" };
+                        }
+                    }
+                    // 尝试生成Mermaid图表
+                    let mermaidDiagram = null;
+                    if (result.Data.Schema &&
+                        jsonSchemaToMermaid &&
+                        simplifiedSchema &&
+                        !simplifiedSchema.error) {
+                        try {
+                            const mainSchema = JSON.parse(result.Data.Schema);
+                            const schemasMap = {
+                                [name]: mainSchema,
+                            };
+                            // 获取关联模型的 schema
+                            if (simplifiedSchema.relations &&
+                                simplifiedSchema.relations.length > 0) {
+                                const relatedModelNames = [
+                                    ...new Set(simplifiedSchema.relations.map((rel) => rel.targetModel)),
+                                ];
+                                for (const relatedModelName of relatedModelNames) {
+                                    try {
+                                        const relatedResult = await cloudbase
+                                            .commonService("lowcode")
+                                            .call({
+                                            Action: "DescribeBasicDataSource",
+                                            Param: {
+                                                EnvId: currentEnvId,
+                                                Name: relatedModelName,
+                                            },
+                                        });
+                                        if (relatedResult.Data && relatedResult.Data.Schema) {
+                                            schemasMap[relatedModelName] = JSON.parse(relatedResult.Data.Schema);
                                         }
                                     }
+                                    catch (e) {
+                                        console.warn(`获取关联模型 ${relatedModelName} 的 schema 失败:`, e);
+                                    }
                                 }
-                                // 调用 jsonSchemaToMermaid，传入正确的参数格式
-                                mermaidDiagram = jsonSchemaToMermaid(schemasMap);
-                            }
-                            catch (e) {
-                                console.warn("生成Mermaid图表失败:", e);
                             }
+                            // 调用 jsonSchemaToMermaid，传入正确的参数格式
+                            mermaidDiagram = jsonSchemaToMermaid(schemasMap);
                         }
-                        const simplifiedModel = {
-                            DbInstanceType: result.Data.DbInstanceType,
-                            Title: result.Data.Title,
-                            Description: result.Data.Description,
-                            Name: result.Data.Name,
-                            UpdatedAt: result.Data.UpdatedAt,
-                            Schema: simplifiedSchema,
-                            mermaid: mermaidDiagram,
-                        };
+                        catch (e) {
+                            console.warn("生成Mermaid图表失败:", e);
+                        }
+                    }
+                    const simplifiedModel = {
+                        DbInstanceType: result.Data.DbInstanceType,
+                        Title: result.Data.Title,
+                        Description: result.Data.Description,
+                        Name: result.Data.Name,
+                        UpdatedAt: result.Data.UpdatedAt,
+                        Schema: simplifiedSchema,
+                        mermaid: mermaidDiagram,
+                    };
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({
+                                    success: true,
+                                    action: "get",
+                                    data: simplifiedModel,
+                                    message: "获取数据模型成功",
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    if (error.original?.Code === "ResourceNotFound") {
                         return {
                             content: [
                                 {
                                     type: "text",
                                     text: JSON.stringify({
-                                        success: true,
+                                        success: false,
                                         action: "get",
-                                        data: simplifiedModel,
-                                        message: "获取数据模型成功",
+                                        error: "ResourceNotFound",
+                                        message: `数据模型 ${name} 不存在`,
                                     }, null, 2),
                                 },
                             ],
                         };
                     }
-                    catch (error) {
-                        if (error.original?.Code === "ResourceNotFound") {
-                            return {
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: JSON.stringify({
-                                            success: false,
-                                            action: "get",
-                                            error: "ResourceNotFound",
-                                            message: `数据模型 ${name} 不存在`,
-                                        }, null, 2),
-                                    },
-                                ],
-                            };
-                        }
-                        throw error;
-                    }
-                case "list":
-                    // 构建请求参数
-                    const listParams = {
-                        EnvId: currentEnvId,
-                        PageIndex: 1,
-                        PageSize: 1000,
-                        QuerySystemModel: true, // 查询系统模型
-                        QueryConnector: 0, // 0 表示数据模型
-                    };
-                    // 只有当 names 参数存在且不为空时才添加过滤条件
-                    if (names && names.length > 0) {
-                        listParams.DataSourceNames = names;
-                    }
+                    throw error;
+                }
+            case "list":
+                // 构建请求参数
+                const listParams = {
+                    EnvId: currentEnvId,
+                    PageIndex: 1,
+                    PageSize: 1000,
+                    QuerySystemModel: true, // 查询系统模型
+                    QueryConnector: 0, // 0 表示数据模型
+                };
+                // 只有当 names 参数存在且不为空时才添加过滤条件
+                if (names && names.length > 0) {
+                    listParams.DataSourceNames = names;
+                }
+                result = await cloudbase.commonService("lowcode").call({
+                    Action: "DescribeDataSourceList",
+                    Param: listParams,
+                });
+                (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+                const models = result.Data?.Rows || [];
+                // 只保留基础字段，list操作不返回Schema
+                const simplifiedModels = models.map((model) => ({
+                    DbInstanceType: model.DbInstanceType,
+                    Title: model.Title,
+                    Description: model.Description,
+                    Name: model.Name,
+                    UpdatedAt: model.UpdatedAt,
+                }));
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                action: "list",
+                                data: simplifiedModels,
+                                count: simplifiedModels.length,
+                                message: "获取数据模型列表成功",
+                            }, null, 2),
+                        },
+                    ],
+                };
+            case "docs":
+                if (!name) {
+                    throw new Error("生成SDK文档需要提供模型名称");
+                }
+                try {
+                    // 先获取模型信息
                     result = await cloudbase.commonService("lowcode").call({
-                        Action: "DescribeDataSourceList",
-                        Param: listParams,
+                        Action: "DescribeBasicDataSource",
+                        Param: {
+                            EnvId: currentEnvId,
+                            Name: name,
+                        },
                     });
                     (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-                    const models = result.Data?.Rows || [];
-                    // 只保留基础字段，list操作不返回Schema
-                    const simplifiedModels = models.map((model) => ({
-                        DbInstanceType: model.DbInstanceType,
-                        Title: model.Title,
-                        Description: model.Description,
-                        Name: model.Name,
-                        UpdatedAt: model.UpdatedAt,
-                    }));
+                    if (!result.Data) {
+                        throw new Error(`数据模型 ${name} 不存在`);
+                    }
+                    // 解析Schema获取字段信息
+                    let userFields = [];
+                    let relations = [];
+                    if (result.Data.Schema) {
+                        try {
+                            const schema = JSON.parse(result.Data.Schema);
+                            const properties = schema.properties || {};
+                            // 提取用户定义的字段
+                            userFields = Object.keys(properties)
+                                .filter((key) => !properties[key]["x-system"])
+                                .map((key) => {
+                                const field = properties[key];
+                                return parseFieldStructure(field, key, schema);
+                            });
+                            // 提取关联关系
+                            relations = userFields
+                                .filter((field) => field.linkage)
+                                .map((field) => ({
+                                field: field.name,
+                                type: field.format,
+                                title: field.title,
+                                targetModel: field.linkage.parentDataSourceName,
+                                foreignKey: field.linkage.parentFieldKey,
+                                displayField: field.linkage.parentFieldTitle,
+                            }));
+                        }
+                        catch (e) {
+                            // Schema解析失败，使用空数组
+                            console.error("Schema解析失败", e);
+                        }
+                    }
+                    // 生成SDK使用文档
+                    const docs = generateSDKDocs(result.Data.Name, result.Data.Title, userFields, relations);
                     return {
                         content: [
                             {
                                 type: "text",
                                 text: JSON.stringify({
                                     success: true,
-                                    action: "list",
-                                    data: simplifiedModels,
-                                    count: simplifiedModels.length,
-                                    message: "获取数据模型列表成功",
+                                    action: "docs",
+                                    modelName: name,
+                                    modelTitle: result.Data.Title,
+                                    docs,
+                                    message: "SDK使用文档生成成功",
                                 }, null, 2),
                             },
                         ],
                     };
-                case "docs":
-                    if (!name) {
-                        throw new Error("生成SDK文档需要提供模型名称");
-                    }
-                    try {
-                        // 先获取模型信息
-                        result = await cloudbase.commonService("lowcode").call({
-                            Action: "DescribeBasicDataSource",
-                            Param: {
-                                EnvId: currentEnvId,
-                                Name: name,
-                            },
-                        });
-                        (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-                        if (!result.Data) {
-                            throw new Error(`数据模型 ${name} 不存在`);
-                        }
-                        // 解析Schema获取字段信息
-                        let userFields = [];
-                        let relations = [];
-                        if (result.Data.Schema) {
-                            try {
-                                const schema = JSON.parse(result.Data.Schema);
-                                const properties = schema.properties || {};
-                                // 提取用户定义的字段
-                                userFields = Object.keys(properties)
-                                    .filter((key) => !properties[key]["x-system"])
-                                    .map((key) => {
-                                    const field = properties[key];
-                                    return parseFieldStructure(field, key, schema);
-                                });
-                                // 提取关联关系
-                                relations = userFields
-                                    .filter((field) => field.linkage)
-                                    .map((field) => ({
-                                    field: field.name,
-                                    type: field.format,
-                                    title: field.title,
-                                    targetModel: field.linkage.parentDataSourceName,
-                                    foreignKey: field.linkage.parentFieldKey,
-                                    displayField: field.linkage.parentFieldTitle,
-                                }));
-                            }
-                            catch (e) {
-                                // Schema解析失败，使用空数组
-                                console.error("Schema解析失败", e);
-                            }
-                        }
-                        // 生成SDK使用文档
-                        const docs = generateSDKDocs(result.Data.Name, result.Data.Title, userFields, relations);
+                }
+                catch (error) {
+                    if (error.original?.Code === "ResourceNotFound") {
                         return {
                             content: [
                                 {
                                     type: "text",
                                     text: JSON.stringify({
-                                        success: true,
+                                        success: false,
                                         action: "docs",
-                                        modelName: name,
-                                        modelTitle: result.Data.Title,
-                                        docs,
-                                        message: "SDK使用文档生成成功",
+                                        error: "ResourceNotFound",
+                                        message: `数据模型 ${name} 不存在`,
                                     }, null, 2),
                                 },
                             ],
                         };
                     }
-                    catch (error) {
-                        if (error.original?.Code === "ResourceNotFound") {
-                            return {
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: JSON.stringify({
-                                            success: false,
-                                            action: "docs",
-                                            error: "ResourceNotFound",
-                                            message: `数据模型 ${name} 不存在`,
-                                        }, null, 2),
-                                    },
-                                ],
-                            };
-                        }
-                        throw error;
-                    }
-                default:
-                    throw new Error(`不支持的操作类型: ${action}`);
-            }
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            action,
-                            error: error.message || error.original?.Message || "未知错误",
-                            code: error.original?.Code,
-                            message: "数据模型操作失败",
-                        }, null, 2),
-                    },
-                ],
-            };
+                    throw error;
+                }
+            default:
+                throw new Error(`不支持的操作类型: ${action}`);
         }
     });
     // modifyDataModel - 数据模型修改工具（创建/更新）
@@ -109191,126 +109136,108 @@ classDiagram
             category: "database",
         },
     }, async ({ mermaidDiagram, action = "create", publish = false, dbInstanceType = "MYSQL", }) => {
-        try {
-            const cloudbase = await getManager();
-            let currentEnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
-            // 使用mermaidToJsonSchema转换Mermaid图表
-            const schemas = mermaidToJsonSchema(mermaidDiagram);
-            if (!schemas || Object.keys(schemas).length === 0) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                success: false,
-                                error: "No schemas generated from Mermaid diagram",
-                                message: "无法从Mermaid图表生成数据模型Schema",
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            // 创建数据模型列表
-            const createDataModelList = Object.entries(schemas).map(([name, schema]) => {
-                return {
-                    CreateSource: "cloudbase_create",
-                    Creator: null,
-                    DbLinkName: null,
-                    Description: schema.description ||
-                        `${schema.title || name}数据模型`,
-                    Schema: JSON.stringify(createBackendSchemaParams(schema)),
-                    Title: schema.title || name,
-                    Name: name,
-                    TableNameRule: "only_name",
-                };
-            });
-            // 调用批量创建数据模型API
-            const result = await cloudbase.commonService("lowcode").call({
-                Action: "BatchCreateDataModelList",
-                Param: {
-                    CreateDataModelList: createDataModelList,
-                    Creator: null,
-                    DbInstanceType: dbInstanceType,
-                    EnvId: currentEnvId,
-                },
-            });
-            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-            const taskId = result.Data?.TaskId;
-            if (!taskId) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                success: false,
-                                requestId: result.RequestId,
-                                error: "No TaskId returned",
-                                message: "创建任务失败，未返回任务ID",
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            // 轮询任务状态直至完成或超时
-            const maxWaitTime = 30000; // 30秒超时
-            const startTime = Date.now();
-            let status = "init";
-            let statusResult = null;
-            while (status === "init" && Date.now() - startTime < maxWaitTime) {
-                await new Promise((resolve) => setTimeout(resolve, 2000)); // 等待2秒
-                statusResult = await cloudbase.commonService("lowcode").call({
-                    Action: "QueryModelTaskStatus",
-                    Param: {
-                        EnvId: currentEnvId,
-                        TaskId: taskId,
-                    },
-                });
-                (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, statusResult);
-                status = statusResult.Data?.Status || "init";
-            }
-            // 返回最终结果
-            const models = Object.keys(schemas);
-            const successModels = statusResult?.Data?.SuccessResourceIdList || [];
-            const failedModels = models.filter((model) => !successModels.includes(model));
+        const cloudbase = await getManager();
+        let currentEnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+        const schemas = mermaidToJsonSchema(mermaidDiagram);
+        if (!schemas || Object.keys(schemas).length === 0) {
             return {
                 content: [
                     {
                         type: "text",
                         text: JSON.stringify({
-                            success: status === "success",
-                            requestId: result.RequestId,
-                            taskId: taskId,
-                            models: models,
-                            successModels: successModels,
-                            failedModels: failedModels,
-                            status: status,
-                            action: action,
-                            message: status === "success"
-                                ? `数据模型${action === "create" ? "创建" : "更新"}成功，共处理${models.length}个模型`
-                                : status === "init"
-                                    ? `任务超时，任务ID: ${taskId}，请稍后手动查询状态`
-                                    : `数据模型${action === "create" ? "创建" : "更新"}失败`,
-                            taskResult: statusResult?.Data,
+                            success: false,
+                            error: "No schemas generated from Mermaid diagram",
+                            message: "无法从Mermaid图表生成数据模型Schema",
                         }, null, 2),
                     },
                 ],
             };
         }
-        catch (error) {
+        // 创建数据模型列表
+        const createDataModelList = Object.entries(schemas).map(([name, schema]) => {
+            return {
+                CreateSource: "cloudbase_create",
+                Creator: null,
+                DbLinkName: null,
+                Description: schema.description ||
+                    `${schema.title || name}数据模型`,
+                Schema: JSON.stringify(createBackendSchemaParams(schema)),
+                Title: schema.title || name,
+                Name: name,
+                TableNameRule: "only_name",
+            };
+        });
+        // 调用批量创建数据模型API
+        const result = await cloudbase.commonService("lowcode").call({
+            Action: "BatchCreateDataModelList",
+            Param: {
+                CreateDataModelList: createDataModelList,
+                Creator: null,
+                DbInstanceType: dbInstanceType,
+                EnvId: currentEnvId,
+            },
+        });
+        (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+        const taskId = result.Data?.TaskId;
+        if (!taskId) {
             return {
                 content: [
                     {
                         type: "text",
                         text: JSON.stringify({
                             success: false,
-                            error: error.message || error.original?.Message || "未知错误",
-                            code: error.original?.Code,
-                            message: "数据模型修改操作失败",
+                            requestId: result.RequestId,
+                            error: "No TaskId returned",
+                            message: "创建任务失败，未返回任务ID",
                         }, null, 2),
                     },
                 ],
             };
         }
+        // 轮询任务状态直至完成或超时
+        const maxWaitTime = 30000; // 30秒超时
+        const startTime = Date.now();
+        let status = "init";
+        let statusResult = null;
+        while (status === "init" && Date.now() - startTime < maxWaitTime) {
+            await new Promise((resolve) => setTimeout(resolve, 2000)); // 等待2秒
+            statusResult = await cloudbase.commonService("lowcode").call({
+                Action: "QueryModelTaskStatus",
+                Param: {
+                    EnvId: currentEnvId,
+                    TaskId: taskId,
+                },
+            });
+            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, statusResult);
+            status = statusResult.Data?.Status || "init";
+        }
+        // 返回最终结果
+        const models = Object.keys(schemas);
+        const successModels = statusResult?.Data?.SuccessResourceIdList || [];
+        const failedModels = models.filter((model) => !successModels.includes(model));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: status === "success",
+                        requestId: result.RequestId,
+                        taskId: taskId,
+                        models: models,
+                        successModels: successModels,
+                        failedModels: failedModels,
+                        status: status,
+                        action: action,
+                        message: status === "success"
+                            ? `数据模型${action === "create" ? "创建" : "更新"}成功，共处理${models.length}个模型`
+                            : status === "init"
+                                ? `任务超时，任务ID: ${taskId}，请稍后手动查询状态`
+                                : `数据模型${action === "create" ? "创建" : "更新"}失败`,
+                        taskResult: statusResult?.Data,
+                    }, null, 2),
+                },
+            ],
+        };
     });
 }
 
@@ -112347,113 +112274,97 @@ function registerCloudRunTools(server) {
             category: "cloudrun"
         }
     }, async (args) => {
-        try {
-            const input = args;
-            const manager = await getManager();
-            if (!manager) {
-                throw new Error("Failed to initialize CloudBase manager. Please check your credentials and environment configuration.");
-            }
-            const cloudrunService = manager.cloudrun;
-            switch (input.action) {
-                case 'list': {
-                    const listParams = {
-                        pageSize: input.pageSize,
-                        pageNum: input.pageNum,
-                    };
-                    if (input.serverName) {
-                        listParams.serverName = input.serverName;
-                    }
-                    if (input.serverType) {
-                        listParams.serverType = input.serverType;
-                    }
-                    const result = await cloudrunService.list(listParams);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        services: result.ServerList || [],
-                                        pagination: {
-                                            total: result.Total || 0,
-                                            pageSize: input.pageSize,
-                                            pageNum: input.pageNum,
-                                            totalPages: Math.ceil((result.Total || 0) / (input.pageSize || 10))
-                                        }
-                                    },
-                                    message: `Found ${result.ServerList?.length || 0} CloudRun services`
-                                }, null, 2)
-                            }
-                        ]
-                    };
+        const input = args;
+        const manager = await getManager();
+        if (!manager) {
+            throw new Error("Failed to initialize CloudBase manager. Please check your credentials and environment configuration.");
+        }
+        const cloudrunService = manager.cloudrun;
+        switch (input.action) {
+            case 'list': {
+                const listParams = {
+                    pageSize: input.pageSize,
+                    pageNum: input.pageNum,
+                };
+                if (input.serverName) {
+                    listParams.serverName = input.serverName;
                 }
-                case 'detail': {
-                    const serverName = input.detailServerName || input.serverName;
-                    const result = await cloudrunService.detail({ serverName });
-                    if (!result) {
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: JSON.stringify({
-                                        success: false,
-                                        error: `Service '${serverName}' not found`,
-                                        message: "Please check the service name and try again."
-                                    }, null, 2)
-                                }
-                            ]
-                        };
-                    }
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        service: result
-                                    },
-                                    message: `Retrieved details for service '${serverName}'`
-                                }, null, 2)
-                            }
-                        ]
-                    };
+                if (input.serverType) {
+                    listParams.serverType = input.serverType;
                 }
-                case 'templates': {
-                    const result = await cloudrunService.getTemplates();
+                const result = await cloudrunService.list(listParams);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    services: result.ServerList || [],
+                                    pagination: {
+                                        total: result.Total || 0,
+                                        pageSize: input.pageSize,
+                                        pageNum: input.pageNum,
+                                        totalPages: Math.ceil((result.Total || 0) / (input.pageSize || 10))
+                                    }
+                                },
+                                message: `Found ${result.ServerList?.length || 0} CloudRun services`
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            case 'detail': {
+                const serverName = input.detailServerName || input.serverName;
+                const result = await cloudrunService.detail({ serverName });
+                if (!result) {
                     return {
                         content: [
                             {
                                 type: "text",
                                 text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        templates: result || []
-                                    },
-                                    message: `Found ${result?.length || 0} available templates`
+                                    success: false,
+                                    error: `Service '${serverName}' not found`,
+                                    message: "Please check the service name and try again."
                                 }, null, 2)
                             }
                         ]
                     };
                 }
-                default:
-                    throw new Error(`Unsupported action: ${input.action}`);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    service: result
+                                },
+                                message: `Retrieved details for service '${serverName}'`
+                            }, null, 2)
+                        }
+                    ]
+                };
             }
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: error.message || 'Unknown error occurred',
-                            message: "Failed to query CloudRun information. Please check your permissions and try again."
-                        }, null, 2)
-                    }
-                ]
-            };
+            case 'templates': {
+                const result = await cloudrunService.getTemplates();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    templates: result || []
+                                },
+                                message: `Found ${result?.length || 0} available templates`
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            default:
+                throw new Error(`Unsupported action: ${input.action}`);
         }
     });
     // Track local running processes for CloudRun function services
@@ -112471,62 +112382,60 @@ function registerCloudRunTools(server) {
             category: "cloudrun"
         }
     }, async (args) => {
-        try {
-            const input = args;
-            const manager = await getManager();
-            if (!manager) {
-                throw new Error("Failed to initialize CloudBase manager. Please check your credentials and environment configuration.");
-            }
-            const cloudrunService = manager.cloudrun;
-            let targetPath;
-            // Validate and normalize path for operations that require it
-            if (input.targetPath) {
-                targetPath = validateAndNormalizePath(input.targetPath);
-            }
-            switch (input.action) {
-                case 'createAgent': {
-                    if (!targetPath) {
-                        throw new Error("targetPath is required for createAgent operation");
-                    }
-                    if (!input.agentConfig) {
-                        throw new Error("agentConfig is required for createAgent operation");
-                    }
-                    const { agentName, botTag, description, template = 'blank' } = input.agentConfig;
-                    // Generate BotId
-                    const botId = botTag ? `ibot-${agentName}-${botTag}` : `ibot-${agentName}-${Date.now()}`;
-                    // Create Agent using CloudBase Manager
-                    const agentResult = await manager.agent.createFunctionAgent(targetPath, {
-                        Name: agentName,
-                        BotId: botId,
-                        Introduction: description || `Agent created by ${agentName}`,
-                        Avatar: undefined
-                    });
-                    // Create project directory
-                    const projectDir = path_1.default.join(targetPath, input.serverName);
-                    if (!fs_1.default.existsSync(projectDir)) {
-                        fs_1.default.mkdirSync(projectDir, { recursive: true });
+        const input = args;
+        const manager = await getManager();
+        if (!manager) {
+            throw new Error("Failed to initialize CloudBase manager. Please check your credentials and environment configuration.");
+        }
+        const cloudrunService = manager.cloudrun;
+        let targetPath;
+        if (input.targetPath) {
+            targetPath = validateAndNormalizePath(input.targetPath);
+        }
+        switch (input.action) {
+            case 'createAgent': {
+                if (!targetPath) {
+                    throw new Error("targetPath is required for createAgent operation");
+                }
+                if (!input.agentConfig) {
+                    throw new Error("agentConfig is required for createAgent operation");
+                }
+                const { agentName, botTag, description, template = 'blank' } = input.agentConfig;
+                // Generate BotId
+                const botId = botTag ? `ibot-${agentName}-${botTag}` : `ibot-${agentName}-${Date.now()}`;
+                // Create Agent using CloudBase Manager
+                const agentResult = await manager.agent.createFunctionAgent(targetPath, {
+                    Name: agentName,
+                    BotId: botId,
+                    Introduction: description || `Agent created by ${agentName}`,
+                    Avatar: undefined
+                });
+                // Create project directory
+                const projectDir = path_1.default.join(targetPath, input.serverName);
+                if (!fs_1.default.existsSync(projectDir)) {
+                    fs_1.default.mkdirSync(projectDir, { recursive: true });
+                }
+                // Generate package.json
+                const packageJson = {
+                    name: input.serverName,
+                    version: "1.0.0",
+                    description: description || `Agent created by ${agentName}`,
+                    main: "index.js",
+                    scripts: {
+                        "dev": "tcb cloudrun run --runMode=agent -w",
+                        "deploy": "tcb cloudrun deploy",
+                        "start": "node index.js"
+                    },
+                    dependencies: {
+                        "@cloudbase/aiagent-framework": "^1.0.0-beta.10"
+                    },
+                    devDependencies: {
+                        "@cloudbase/cli": "^2.6.16"
                     }
-                    // Generate package.json
-                    const packageJson = {
-                        name: input.serverName,
-                        version: "1.0.0",
-                        description: description || `Agent created by ${agentName}`,
-                        main: "index.js",
-                        scripts: {
-                            "dev": "tcb cloudrun run --runMode=agent -w",
-                            "deploy": "tcb cloudrun deploy",
-                            "start": "node index.js"
-                        },
-                        dependencies: {
-                            "@cloudbase/aiagent-framework": "^1.0.0-beta.10"
-                        },
-                        devDependencies: {
-                            "@cloudbase/cli": "^2.6.16"
-                        }
-                    };
-                    fs_1.default.writeFileSync(path_1.default.join(projectDir, 'package.json'), JSON.stringify(packageJson, null, 2));
-                    // Generate index.js with Agent template
-                    const indexJsContent = `const { IBot } = require("@cloudbase/aiagent-framework");
+                };
+                fs_1.default.writeFileSync(path_1.default.join(projectDir, 'package.json'), JSON.stringify(packageJson, null, 2));
+                // Generate index.js with Agent template
+                const indexJsContent = `const { IBot } = require("@cloudbase/aiagent-framework");
 const { BotRunner } = require("@cloudbase/aiagent-framework");
 
 const ANSWER = "你好，我是一个智能体，但我只会说这一句话。";
@@ -112571,18 +112480,18 @@ exports.main = function (event, context) {
   return BotRunner.run(event, context, new MyBot(context));
 };
 `;
-                    fs_1.default.writeFileSync(path_1.default.join(projectDir, 'index.js'), indexJsContent);
-                    // Generate cloudbaserc.json
-                    const currentEnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
-                    const cloudbasercContent = {
-                        envId: currentEnvId,
-                        cloudrun: {
-                            name: input.serverName
-                        }
-                    };
-                    fs_1.default.writeFileSync(path_1.default.join(projectDir, 'cloudbaserc.json'), JSON.stringify(cloudbasercContent, null, 2));
-                    // Generate README.md
-                    const readmeContent = `# ${agentName} Agent
+                fs_1.default.writeFileSync(path_1.default.join(projectDir, 'index.js'), indexJsContent);
+                // Generate cloudbaserc.json
+                const currentEnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+                const cloudbasercContent = {
+                    envId: currentEnvId,
+                    cloudrun: {
+                        name: input.serverName
+                    }
+                };
+                fs_1.default.writeFileSync(path_1.default.join(projectDir, 'cloudbaserc.json'), JSON.stringify(cloudbasercContent, null, 2));
+                // Generate README.md
+                const readmeContent = `# ${agentName} Agent
 
 这是一个基于函数型云托管的 AI 智能体。
 
@@ -112627,230 +112536,230 @@ for await (let x of res.textStream) {
 </script>
 \`\`\`
 `;
-                    fs_1.default.writeFileSync(path_1.default.join(projectDir, 'README.md'), readmeContent);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        agentName: agentName,
-                                        botId: botId,
-                                        projectDir: projectDir,
-                                        serverName: input.serverName,
-                                        template: template,
-                                        filesCreated: ['package.json', 'index.js', 'cloudbaserc.json', 'README.md']
-                                    },
-                                    message: `Successfully created Agent '${agentName}' with BotId '${botId}' in ${projectDir}`
-                                }, null, 2)
-                            }
-                        ]
-                    };
+                fs_1.default.writeFileSync(path_1.default.join(projectDir, 'README.md'), readmeContent);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    agentName: agentName,
+                                    botId: botId,
+                                    projectDir: projectDir,
+                                    serverName: input.serverName,
+                                    template: template,
+                                    filesCreated: ['package.json', 'index.js', 'cloudbaserc.json', 'README.md']
+                                },
+                                message: `Successfully created Agent '${agentName}' with BotId '${botId}' in ${projectDir}`
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            case 'deploy': {
+                if (!targetPath) {
+                    throw new Error("targetPath is required for deploy operation");
                 }
-                case 'deploy': {
-                    if (!targetPath) {
-                        throw new Error("targetPath is required for deploy operation");
-                    }
-                    // Determine service type - use input.serverType if provided, otherwise auto-detect
-                    let serverType;
-                    if (input.serverType) {
-                        serverType = input.serverType;
+                // Determine service type - use input.serverType if provided, otherwise auto-detect
+                let serverType;
+                if (input.serverType) {
+                    serverType = input.serverType;
+                }
+                else {
+                    try {
+                        // First try to get existing service details
+                        const details = await cloudrunService.detail({ serverName: input.serverName });
+                        serverType = details.BaseInfo?.ServerType || 'container';
                     }
-                    else {
-                        try {
-                            // First try to get existing service details
-                            const details = await cloudrunService.detail({ serverName: input.serverName });
-                            serverType = details.BaseInfo?.ServerType || 'container';
+                    catch (e) {
+                        // If service doesn't exist, determine by project structure
+                        const dockerfilePath = path_1.default.join(targetPath, 'Dockerfile');
+                        if (fs_1.default.existsSync(dockerfilePath)) {
+                            serverType = 'container';
                         }
-                        catch (e) {
-                            // If service doesn't exist, determine by project structure
-                            const dockerfilePath = path_1.default.join(targetPath, 'Dockerfile');
-                            if (fs_1.default.existsSync(dockerfilePath)) {
-                                serverType = 'container';
-                            }
-                            else {
-                                // Check if it's a Node.js function project (has package.json with specific structure)
-                                const packageJsonPath = path_1.default.join(targetPath, 'package.json');
-                                if (fs_1.default.existsSync(packageJsonPath)) {
-                                    try {
-                                        const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf8'));
-                                        // If it has function-specific dependencies or scripts, treat as function
-                                        if (packageJson.dependencies?.['@cloudbase/aiagent-framework'] ||
-                                            packageJson.scripts?.['dev']?.includes('cloudrun run')) {
-                                            serverType = 'function';
-                                        }
-                                        else {
-                                            serverType = 'container';
-                                        }
+                        else {
+                            // Check if it's a Node.js function project (has package.json with specific structure)
+                            const packageJsonPath = path_1.default.join(targetPath, 'package.json');
+                            if (fs_1.default.existsSync(packageJsonPath)) {
+                                try {
+                                    const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf8'));
+                                    // If it has function-specific dependencies or scripts, treat as function
+                                    if (packageJson.dependencies?.['@cloudbase/aiagent-framework'] ||
+                                        packageJson.scripts?.['dev']?.includes('cloudrun run')) {
+                                        serverType = 'function';
                                     }
-                                    catch (parseError) {
+                                    else {
                                         serverType = 'container';
                                     }
                                 }
-                                else {
-                                    // No package.json, default to container
+                                catch (parseError) {
                                     serverType = 'container';
                                 }
                             }
+                            else {
+                                // No package.json, default to container
+                                serverType = 'container';
+                            }
                         }
                     }
-                    const deployParams = {
-                        serverName: input.serverName,
-                        targetPath: targetPath,
-                        force: input.force,
-                        serverType: serverType,
-                    };
-                    // Add server configuration if provided
-                    if (input.serverConfig) {
-                        deployParams.serverConfig = input.serverConfig;
-                    }
-                    const result = await cloudrunService.deploy(deployParams);
-                    // Generate cloudbaserc.json configuration file
-                    const currentEnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
-                    const cloudbasercPath = path_1.default.join(targetPath, 'cloudbaserc.json');
-                    const cloudbasercContent = {
-                        envId: currentEnvId,
-                        cloudrun: {
-                            name: input.serverName
-                        }
-                    };
-                    try {
-                        fs_1.default.writeFileSync(cloudbasercPath, JSON.stringify(cloudbasercContent, null, 2));
-                    }
-                    catch (error) {
-                        // Ignore cloudbaserc.json creation errors
+                }
+                const deployParams = {
+                    serverName: input.serverName,
+                    targetPath: targetPath,
+                    force: input.force,
+                    serverType: serverType,
+                };
+                // Add server configuration if provided
+                if (input.serverConfig) {
+                    deployParams.serverConfig = input.serverConfig;
+                }
+                const result = await cloudrunService.deploy(deployParams);
+                // Generate cloudbaserc.json configuration file
+                const currentEnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+                const cloudbasercPath = path_1.default.join(targetPath, 'cloudbaserc.json');
+                const cloudbasercContent = {
+                    envId: currentEnvId,
+                    cloudrun: {
+                        name: input.serverName
                     }
-                    // Send deployment notification to CodeBuddy IDE
+                };
+                try {
+                    fs_1.default.writeFileSync(cloudbasercPath, JSON.stringify(cloudbasercContent, null, 2));
+                }
+                catch (error) {
+                    // Ignore cloudbaserc.json creation errors
+                }
+                // Send deployment notification to CodeBuddy IDE
+                try {
+                    // Query service details to get access URL
+                    let serviceUrl = "";
                     try {
-                        // Query service details to get access URL
-                        let serviceUrl = "";
-                        try {
-                            const serviceDetails = await cloudrunService.detail({ serverName: input.serverName });
-                            // Extract access URL from service details
-                            // Priority: DefaultDomainName > CustomDomainName > PublicDomain > InternalDomain
-                            const details = serviceDetails; // Use any to access dynamic properties
-                            if (details?.BaseInfo?.DefaultDomainName) {
-                                // DefaultDomainName is already a complete URL (e.g., https://...)
-                                serviceUrl = details.BaseInfo.DefaultDomainName;
-                            }
-                            else if (details?.BaseInfo?.CustomDomainName) {
-                                // CustomDomainName might be a domain without protocol
-                                const customDomain = details.BaseInfo.CustomDomainName;
-                                serviceUrl = customDomain.startsWith('http') ? customDomain : `https://${customDomain}`;
-                            }
-                            else if (details?.BaseInfo?.PublicDomain) {
-                                serviceUrl = `https://${details.BaseInfo.PublicDomain}`;
-                            }
-                            else if (details?.BaseInfo?.InternalDomain) {
-                                serviceUrl = `https://${details.BaseInfo.InternalDomain}`;
-                            }
-                            else if (details?.AccessInfo?.PublicDomain) {
-                                serviceUrl = `https://${details.AccessInfo.PublicDomain}`;
-                            }
-                            else {
-                                serviceUrl = ""; // URL not available
-                            }
+                        const serviceDetails = await cloudrunService.detail({ serverName: input.serverName });
+                        // Extract access URL from service details
+                        // Priority: DefaultDomainName > CustomDomainName > PublicDomain > InternalDomain
+                        const details = serviceDetails; // Use any to access dynamic properties
+                        if (details?.BaseInfo?.DefaultDomainName) {
+                            // DefaultDomainName is already a complete URL (e.g., https://...)
+                            serviceUrl = details.BaseInfo.DefaultDomainName;
                         }
-                        catch (detailErr) {
-                            // If query fails, continue with empty URL
-                            serviceUrl = "";
+                        else if (details?.BaseInfo?.CustomDomainName) {
+                            // CustomDomainName might be a domain without protocol
+                            const customDomain = details.BaseInfo.CustomDomainName;
+                            serviceUrl = customDomain.startsWith('http') ? customDomain : `https://${customDomain}`;
+                        }
+                        else if (details?.BaseInfo?.PublicDomain) {
+                            serviceUrl = `https://${details.BaseInfo.PublicDomain}`;
+                        }
+                        else if (details?.BaseInfo?.InternalDomain) {
+                            serviceUrl = `https://${details.BaseInfo.InternalDomain}`;
+                        }
+                        else if (details?.AccessInfo?.PublicDomain) {
+                            serviceUrl = `https://${details.AccessInfo.PublicDomain}`;
+                        }
+                        else {
+                            serviceUrl = ""; // URL not available
                         }
-                        // Extract project name from targetPath
-                        const projectName = path_1.default.basename(targetPath);
-                        // Build console URL
-                        const consoleUrl = `https://tcb.cloud.tencent.com/dev?envId=${currentEnvId}#/platform-run/service/detail?serverName=${input.serverName}&tabId=overview&envId=${currentEnvId}`;
-                        // Send notification
-                        await (0, notification_js_1.sendDeployNotification)(server, {
-                            deployType: 'cloudrun',
-                            url: serviceUrl,
-                            projectId: currentEnvId,
-                            projectName: projectName,
-                            consoleUrl: consoleUrl
-                        });
                     }
-                    catch (notifyErr) {
-                        // Notification failure should not affect deployment flow
-                        // Error is already logged in sendDeployNotification
+                    catch (detailErr) {
+                        // If query fails, continue with empty URL
+                        serviceUrl = "";
                     }
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        serviceName: input.serverName,
-                                        status: 'deployed',
-                                        deployPath: targetPath,
-                                        serverType: serverType,
-                                        cloudbasercGenerated: true
-                                    },
-                                    message: `Successfully deployed ${serverType} service '${input.serverName}' from ${targetPath}`
-                                }, null, 2)
-                            }
-                        ]
-                    };
+                    // Extract project name from targetPath
+                    const projectName = path_1.default.basename(targetPath);
+                    // Build console URL
+                    const consoleUrl = `https://tcb.cloud.tencent.com/dev?envId=${currentEnvId}#/platform-run/service/detail?serverName=${input.serverName}&tabId=overview&envId=${currentEnvId}`;
+                    // Send notification
+                    await (0, notification_js_1.sendDeployNotification)(server, {
+                        deployType: 'cloudrun',
+                        url: serviceUrl,
+                        projectId: currentEnvId,
+                        projectName: projectName,
+                        consoleUrl: consoleUrl
+                    });
                 }
-                case 'run': {
-                    if (!targetPath) {
-                        throw new Error("targetPath is required for run operation");
-                    }
-                    // Do not support container services locally: basic heuristic - if Dockerfile exists, treat as container
-                    const dockerfilePath = path_1.default.join(targetPath, 'Dockerfile');
-                    if (fs_1.default.existsSync(dockerfilePath)) {
-                        throw new Error("Local run is only supported for function-type CloudRun services. Container services are not supported.");
-                    }
-                    // Check if this is an Agent project
-                    const isAgent = checkIfAgentProject(targetPath);
-                    const runMode = input.runOptions?.runMode || (isAgent ? 'agent' : 'normal');
-                    // Check if service is already running and verify process exists
-                    if (runningProcesses.has(input.serverName)) {
-                        const existingPid = runningProcesses.get(input.serverName);
-                        try {
-                            // Check if process actually exists
-                            process.kill(existingPid, 0);
-                            return {
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: JSON.stringify({
-                                            success: true,
-                                            data: {
-                                                serviceName: input.serverName,
-                                                status: 'running',
-                                                pid: existingPid,
-                                                cwd: targetPath
-                                            },
-                                            message: `Service '${input.serverName}' is already running locally (pid=${existingPid})`
-                                        }, null, 2)
-                                    }
-                                ]
-                            };
-                        }
-                        catch (error) {
-                            // Process doesn't exist, remove from tracking
-                            runningProcesses.delete(input.serverName);
+                catch (notifyErr) {
+                    // Notification failure should not affect deployment flow
+                    // Error is already logged in sendDeployNotification
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    serviceName: input.serverName,
+                                    status: 'deployed',
+                                    deployPath: targetPath,
+                                    serverType: serverType,
+                                    cloudbasercGenerated: true
+                                },
+                                message: `Successfully deployed ${serverType} service '${input.serverName}' from ${targetPath}`
+                            }, null, 2)
                         }
+                    ]
+                };
+            }
+            case 'run': {
+                if (!targetPath) {
+                    throw new Error("targetPath is required for run operation");
+                }
+                // Do not support container services locally: basic heuristic - if Dockerfile exists, treat as container
+                const dockerfilePath = path_1.default.join(targetPath, 'Dockerfile');
+                if (fs_1.default.existsSync(dockerfilePath)) {
+                    throw new Error("Local run is only supported for function-type CloudRun services. Container services are not supported.");
+                }
+                // Check if this is an Agent project
+                const isAgent = checkIfAgentProject(targetPath);
+                const runMode = input.runOptions?.runMode || (isAgent ? 'agent' : 'normal');
+                // Check if service is already running and verify process exists
+                if (runningProcesses.has(input.serverName)) {
+                    const existingPid = runningProcesses.get(input.serverName);
+                    try {
+                        // Check if process actually exists
+                        process.kill(existingPid, 0);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify({
+                                        success: true,
+                                        data: {
+                                            serviceName: input.serverName,
+                                            status: 'running',
+                                            pid: existingPid,
+                                            cwd: targetPath
+                                        },
+                                        message: `Service '${input.serverName}' is already running locally (pid=${existingPid})`
+                                    }, null, 2)
+                                }
+                            ]
+                        };
                     }
-                    const runPort = input.runOptions?.port ?? 3000;
-                    const extraEnv = input.runOptions?.envParams ?? {};
-                    // Set environment variables for functions-framework
-                    const env = {
-                        ...process.env,
-                        PORT: String(runPort),
-                        ...extraEnv,
-                        // Add functions-framework specific environment variables
-                        ENABLE_CORS: 'true',
-                        ALLOWED_ORIGINS: '*'
-                    };
-                    // Choose execution method based on run mode
-                    let child;
-                    let command;
-                    if (runMode === 'agent') {
-                        // For Agent mode, use a different approach since functions-framework doesn't support Agent mode
-                        // We'll use a custom script that sets up the Agent environment
-                        command = `node -e "
+                    catch (error) {
+                        // Process doesn't exist, remove from tracking
+                        runningProcesses.delete(input.serverName);
+                    }
+                }
+                const runPort = input.runOptions?.port ?? 3000;
+                const extraEnv = input.runOptions?.envParams ?? {};
+                // Set environment variables for functions-framework
+                const env = {
+                    ...process.env,
+                    PORT: String(runPort),
+                    ...extraEnv,
+                    // Add functions-framework specific environment variables
+                    ENABLE_CORS: 'true',
+                    ALLOWED_ORIGINS: '*'
+                };
+                // Choose execution method based on run mode
+                let child;
+                let command;
+                if (runMode === 'agent') {
+                    // For Agent mode, use a different approach since functions-framework doesn't support Agent mode
+                    // We'll use a custom script that sets up the Agent environment
+                    command = `node -e "
                 const { runCLI } = require('@cloudbase/functions-framework');
                 process.env.PORT = '${runPort}';
                 process.env.ENABLE_CORS = 'true';
@@ -112859,16 +112768,16 @@ for await (let x of res.textStream) {
                 ${Object.entries(extraEnv).map(([key, value]) => `process.env.${key} = '${value}';`).join('\n')}
                 runCLI();
               "`;
-                        child = (0, child_process_1.spawn)(process.execPath, ['-e', command], {
-                            cwd: targetPath,
-                            env,
-                            stdio: ['ignore', 'pipe', 'pipe'],
-                            detached: true
-                        });
-                    }
-                    else {
-                        // Normal function mode
-                        command = `node -e "
+                    child = (0, child_process_1.spawn)(process.execPath, ['-e', command], {
+                        cwd: targetPath,
+                        env,
+                        stdio: ['ignore', 'pipe', 'pipe'],
+                        detached: true
+                    });
+                }
+                else {
+                    // Normal function mode
+                    command = `node -e "
                 const { runCLI } = require('@cloudbase/functions-framework');
                 process.env.PORT = '${runPort}';
                 process.env.ENABLE_CORS = 'true';
@@ -112876,182 +112785,167 @@ for await (let x of res.textStream) {
                 ${Object.entries(extraEnv).map(([key, value]) => `process.env.${key} = '${value}';`).join('\n')}
                 runCLI();
               "`;
-                        child = (0, child_process_1.spawn)(process.execPath, ['-e', command], {
-                            cwd: targetPath,
-                            env,
-                            stdio: ['ignore', 'pipe', 'pipe'],
-                            detached: true
-                        });
-                    }
-                    // Handle process exit to clean up tracking
-                    child.on('exit', (code, signal) => {
-                        runningProcesses.delete(input.serverName);
+                    child = (0, child_process_1.spawn)(process.execPath, ['-e', command], {
+                        cwd: targetPath,
+                        env,
+                        stdio: ['ignore', 'pipe', 'pipe'],
+                        detached: true
                     });
-                    child.on('error', (error) => {
-                        runningProcesses.delete(input.serverName);
-                    });
-                    child.unref();
-                    if (typeof child.pid !== 'number') {
-                        throw new Error('Failed to start local process: PID is undefined.');
-                    }
-                    runningProcesses.set(input.serverName, child.pid);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        serviceName: input.serverName,
-                                        status: 'running',
-                                        pid: child.pid,
-                                        port: runPort,
-                                        runMode: runMode,
-                                        isAgent: isAgent,
-                                        command: command,
-                                        cwd: targetPath
-                                    },
-                                    message: `Started local run for ${runMode} service '${input.serverName}' on port ${runPort} (pid=${child.pid})`
-                                }, null, 2)
-                            }
-                        ]
-                    };
                 }
-                case 'download': {
-                    if (!targetPath) {
-                        throw new Error("targetPath is required for download operation");
-                    }
-                    const result = await cloudrunService.download({
-                        serverName: input.serverName,
-                        targetPath: targetPath,
-                    });
-                    // Generate cloudbaserc.json configuration file
-                    const currentEnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
-                    const cloudbasercPath = path_1.default.join(targetPath, 'cloudbaserc.json');
-                    const cloudbasercContent = {
-                        envId: currentEnvId,
-                        cloudrun: {
-                            name: input.serverName
+                // Handle process exit to clean up tracking
+                child.on('exit', (code, signal) => {
+                    runningProcesses.delete(input.serverName);
+                });
+                child.on('error', (error) => {
+                    runningProcesses.delete(input.serverName);
+                });
+                child.unref();
+                if (typeof child.pid !== 'number') {
+                    throw new Error('Failed to start local process: PID is undefined.');
+                }
+                runningProcesses.set(input.serverName, child.pid);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    serviceName: input.serverName,
+                                    status: 'running',
+                                    pid: child.pid,
+                                    port: runPort,
+                                    runMode: runMode,
+                                    isAgent: isAgent,
+                                    command: command,
+                                    cwd: targetPath
+                                },
+                                message: `Started local run for ${runMode} service '${input.serverName}' on port ${runPort} (pid=${child.pid})`
+                            }, null, 2)
                         }
-                    };
-                    try {
-                        fs_1.default.writeFileSync(cloudbasercPath, JSON.stringify(cloudbasercContent, null, 2));
-                    }
-                    catch (error) {
-                        // Ignore cloudbaserc.json creation errors
-                    }
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        serviceName: input.serverName,
-                                        downloadPath: targetPath,
-                                        filesCount: 0,
-                                        cloudbasercGenerated: true
-                                    },
-                                    message: `Successfully downloaded service '${input.serverName}' to ${targetPath}`
-                                }, null, 2)
-                            }
-                        ]
-                    };
+                    ]
+                };
+            }
+            case 'download': {
+                if (!targetPath) {
+                    throw new Error("targetPath is required for download operation");
                 }
-                case 'delete': {
-                    if (!input.force) {
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: JSON.stringify({
-                                        success: false,
-                                        error: "Delete operation requires confirmation",
-                                        message: "Please set force: true to confirm deletion of the service. This action cannot be undone."
-                                    }, null, 2)
-                                }
-                            ]
-                        };
+                const result = await cloudrunService.download({
+                    serverName: input.serverName,
+                    targetPath: targetPath,
+                });
+                // Generate cloudbaserc.json configuration file
+                const currentEnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+                const cloudbasercPath = path_1.default.join(targetPath, 'cloudbaserc.json');
+                const cloudbasercContent = {
+                    envId: currentEnvId,
+                    cloudrun: {
+                        name: input.serverName
                     }
-                    const result = await cloudrunService.delete({
-                        serverName: input.serverName,
-                    });
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        serviceName: input.serverName,
-                                        status: 'deleted'
-                                    },
-                                    message: `Successfully deleted service '${input.serverName}'`
-                                }, null, 2)
-                            }
-                        ]
-                    };
+                };
+                try {
+                    fs_1.default.writeFileSync(cloudbasercPath, JSON.stringify(cloudbasercContent, null, 2));
                 }
-                case 'init': {
-                    if (!targetPath) {
-                        throw new Error("targetPath is required for init operation");
-                    }
-                    const result = await cloudrunService.init({
-                        serverName: input.serverName,
-                        targetPath: targetPath,
-                        template: input.template,
-                    });
-                    // Generate cloudbaserc.json configuration file
-                    const currentEnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
-                    const cloudbasercPath = path_1.default.join(targetPath, input.serverName, 'cloudbaserc.json');
-                    const cloudbasercContent = {
-                        envId: currentEnvId,
-                        cloudrun: {
-                            name: input.serverName
+                catch (error) {
+                    // Ignore cloudbaserc.json creation errors
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    serviceName: input.serverName,
+                                    downloadPath: targetPath,
+                                    filesCount: 0,
+                                    cloudbasercGenerated: true
+                                },
+                                message: `Successfully downloaded service '${input.serverName}' to ${targetPath}`
+                            }, null, 2)
                         }
-                    };
-                    try {
-                        fs_1.default.writeFileSync(cloudbasercPath, JSON.stringify(cloudbasercContent, null, 2));
-                    }
-                    catch (error) {
-                        // Ignore cloudbaserc.json creation errors
-                    }
+                    ]
+                };
+            }
+            case 'delete': {
+                if (!input.force) {
                     return {
                         content: [
                             {
                                 type: "text",
                                 text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        serviceName: input.serverName,
-                                        template: input.template,
-                                        initPath: targetPath,
-                                        projectDir: result.projectDir || path_1.default.join(targetPath, input.serverName),
-                                        cloudbasercGenerated: true
-                                    },
-                                    message: `Successfully initialized service '${input.serverName}' with template '${input.template}' at ${targetPath}`
+                                    success: false,
+                                    error: "Delete operation requires confirmation",
+                                    message: "Please set force: true to confirm deletion of the service. This action cannot be undone."
                                 }, null, 2)
                             }
                         ]
                     };
                 }
-                default:
-                    throw new Error(`Unsupported action: ${input.action}`);
+                const result = await cloudrunService.delete({
+                    serverName: input.serverName,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    serviceName: input.serverName,
+                                    status: 'deleted'
+                                },
+                                message: `Successfully deleted service '${input.serverName}'`
+                            }, null, 2)
+                        }
+                    ]
+                };
             }
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: error.message || 'Unknown error occurred',
-                            message: `Failed to ${args.action} CloudRun service. Please check your permissions and parameters.`
-                        }, null, 2)
+            case 'init': {
+                if (!targetPath) {
+                    throw new Error("targetPath is required for init operation");
+                }
+                const result = await cloudrunService.init({
+                    serverName: input.serverName,
+                    targetPath: targetPath,
+                    template: input.template,
+                });
+                // Generate cloudbaserc.json configuration file
+                const currentEnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+                const cloudbasercPath = path_1.default.join(targetPath, input.serverName, 'cloudbaserc.json');
+                const cloudbasercContent = {
+                    envId: currentEnvId,
+                    cloudrun: {
+                        name: input.serverName
                     }
-                ]
-            };
+                };
+                try {
+                    fs_1.default.writeFileSync(cloudbasercPath, JSON.stringify(cloudbasercContent, null, 2));
+                }
+                catch (error) {
+                    // Ignore cloudbaserc.json creation errors
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    serviceName: input.serverName,
+                                    template: input.template,
+                                    initPath: targetPath,
+                                    projectDir: result.projectDir || path_1.default.join(targetPath, input.serverName),
+                                    cloudbasercGenerated: true
+                                },
+                                message: `Successfully initialized service '${input.serverName}' with template '${input.template}' at ${targetPath}`
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            default:
+                throw new Error(`Unsupported action: ${input.action}`);
         }
     });
 }
@@ -125414,7 +125308,6 @@ const cloudbase_manager_js_1 = __webpack_require__(3431);
 const CATEGORY = "cloud-api";
 const ALLOWED_SERVICES = [
     "tcb",
-    "flexdb",
     "scf",
     "sts",
     "cam",
@@ -125437,7 +125330,7 @@ function registerCapiTools(server) {
         inputSchema: {
             service: zod_1.z
                 .enum(ALLOWED_SERVICES)
-                .describe("选择要访问的服务，必须先查看规则/技能确认是否可用。可选：tcb、flexdb、scf、sts、cam、lowcode、cdn、vpc。"),
+                .describe("选择要访问的服务，必须先查看规则/技能确认是否可用。可选：tcb、scf、sts、cam、lowcode、cdn、vpc。"),
             action: zod_1.z
                 .string()
                 .min(1)
@@ -132403,41 +132296,25 @@ function registerInviteCodeTools(server) {
                 ]
             };
         }
-        try {
-            const manager = await getManager();
-            const EnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
-            const result = await manager.commonService().call({
-                Action: 'ActivateInviteCode',
-                Param: { InviteCode, EnvId }
-            });
-            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            ErrorCode: result?.ErrorCode || '',
-                            ErrorMsg: result?.ErrorMsg || '',
-                            RequestId: result?.RequestId || ''
-                        }, null, 2)
-                    }
-                ]
-            };
-        }
-        catch (e) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            ErrorCode: e.code || 'Exception',
-                            ErrorMsg: '激活失败：' + e.message,
-                            RequestId: e.RequestId || ''
-                        }, null, 2)
-                    }
-                ]
-            };
-        }
+        const manager = await getManager();
+        const EnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+        const result = await manager.commonService().call({
+            Action: 'ActivateInviteCode',
+            Param: { InviteCode, EnvId }
+        });
+        (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        ErrorCode: result?.ErrorCode || '',
+                        ErrorMsg: result?.ErrorMsg || '',
+                        RequestId: result?.RequestId || ''
+                    }, null, 2)
+                }
+            ]
+        };
     });
 }
 
@@ -137058,7 +136935,7 @@ class TelemetryReporter {
         const nodeVersion = process.version; // Node.js版本
         const arch = os_1.default.arch(); // 系统架构
         // 从构建时注入的版本号获取MCP版本信息
-        const mcpVersion = process.env.npm_package_version || "2.8.0" || 0;
+        const mcpVersion = process.env.npm_package_version || "2.10.0" || 0;
         return {
             userAgent: `${osType} ${osRelease} ${arch} ${nodeVersion} CloudBase-MCP/${mcpVersion}`,
             deviceId: this.deviceId,
@@ -196594,7 +196471,7 @@ function renderHeader(accountInfo, ide) {
         <img class="logo" src="https://7463-tcb-advanced-a656fc-1257967285.tcb.qcloud.la/mcp/cloudbase-logo.svg" alt="CloudBase Logo" />
         <span class="title">CloudBase</span>
       </div>
-      ${hasAccount ? `
+      ${(hasAccount && accountInfo.region !== 'ap-singapore') ? /** 国际站不支持切 */ `
         <div class="header-right">
           <div class="account-section">
             <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5">
@@ -196602,6 +196479,7 @@ function renderHeader(accountInfo, ide) {
               <circle cx="12" cy="7" r="4"/>
             </svg>
             <span class="account-uin">${accountInfo.uin}</span>
+            ${accountInfo.region ? `<span class="account-region">${accountInfo.region}</span>` : ''}
             ${!isCodeBuddy ? `
               <button class="btn-switch" onclick="switchAccount()" title="切换账号">
                 <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5">
@@ -203629,7 +203507,7 @@ ${envIdSection}
 ## 环境信息
 - 操作系统: ${os_1.default.type()} ${os_1.default.release()}
 - Node.js版本: ${process.version}
-- MCP 版本：${process.env.npm_package_version || "2.8.0" || 0}
+- MCP 版本：${process.env.npm_package_version || "2.10.0" || 0}
 - 系统架构: ${os_1.default.arch()}
 - 时间: ${new Date().toISOString()}
 - 请求ID: ${requestId}
@@ -211773,9 +211651,10 @@ checkIndex: 检查索引是否存在`),
         title: "修改 NoSQL 数据库结构",
         description: "修改 NoSQL 数据库结构",
         inputSchema: {
-            action: zod_1.z.enum(["createCollection", "updateCollection"])
+            action: zod_1.z.enum(["createCollection", "updateCollection", "deleteCollection"])
                 .describe(`createCollection: 创建集合
-updateCollection: 更新集合`),
+updateCollection: 更新集合
+deleteCollection: 删除集合`),
             collectionName: zod_1.z.string().describe("集合名称"),
             updateOptions: zod_1.z
                 .object({
@@ -211802,68 +211681,74 @@ updateCollection: 更新集合`),
         },
         annotations: {
             readOnlyHint: false,
-            destructiveHint: false,
+            destructiveHint: true,
             idempotentHint: false,
             openWorldHint: true,
             category: CATEGORY,
         },
     }, async ({ action, collectionName, updateOptions }) => {
-        try {
-            const cloudbase = await getManager();
-            if (action === "createCollection") {
-                const result = await cloudbase.database.createCollection(collectionName);
-                (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                success: true,
-                                requestId: result.RequestId,
-                                action,
-                                message: "云开发数据库集合创建成功",
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            if (action === "updateCollection") {
-                if (!updateOptions) {
-                    throw new Error("更新集合时必须提供 options");
-                }
-                const result = await cloudbase.database.updateCollection(collectionName, updateOptions);
-                (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                success: true,
-                                requestId: result.RequestId,
-                                action,
-                                message: "云开发数据库集合更新成功",
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            throw new Error(`不支持的操作类型: ${action}`);
+        const cloudbase = await getManager();
+        if (action === "createCollection") {
+            const result = await cloudbase.database.createCollection(collectionName);
+            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: true,
+                            requestId: result.RequestId,
+                            action,
+                            message: "云开发数据库集合创建成功",
+                        }, null, 2),
+                    },
+                ],
+            };
         }
-        catch (error) {
+        if (action === "updateCollection") {
+            if (!updateOptions) {
+                throw new Error("更新集合时必须提供 options");
+            }
+            const result = await cloudbase.database.updateCollection(collectionName, updateOptions);
+            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
             return {
                 content: [
                     {
                         type: "text",
                         text: JSON.stringify({
-                            success: false,
+                            success: true,
+                            requestId: result.RequestId,
                             action,
-                            error: error.message,
-                            message: "集合创建/更新操作失败",
+                            message: "云开发数据库集合更新成功",
                         }, null, 2),
                     },
                 ],
             };
         }
+        if (action === "deleteCollection") {
+            const result = await cloudbase.database.deleteCollection(collectionName);
+            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+            const body = {
+                success: true,
+                requestId: result.RequestId,
+                action,
+                message: result.Exists === false
+                    ? "集合不存在"
+                    : "云开发数据库集合删除成功",
+            };
+            if (result.Exists === false) {
+                body.exists = false;
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(body, null, 2),
+                    },
+                ],
+            };
+        }
+        throw new Error(`不支持的操作类型: ${action}`);
     });
     // readNoSqlDatabaseContent
     server.registerTool?.("readNoSqlDatabaseContent", {
@@ -211892,53 +211777,36 @@ updateCollection: 更新集合`),
             category: CATEGORY,
         },
     }, async ({ collectionName, query, projection, sort, limit, offset }) => {
-        try {
-            const cloudbase = await getManager();
-            const instanceId = await getDatabaseInstanceId(getManager);
-            // 兼容对象和字符串
-            const toJSONString = (v) => typeof v === "object" && v !== null ? JSON.stringify(v) : v;
-            const result = await cloudbase.commonService("flexdb").call({
-                Action: "Query",
-                Param: {
-                    TableName: collectionName,
-                    MgoQuery: toJSONString(query),
-                    MgoProjection: toJSONString(projection),
-                    MgoSort: toJSONString(sort),
-                    MgoLimit: limit ?? 100, // 默认返回100条,避免底层SDK缺参报错
-                    MgoOffset: offset,
-                    Tag: instanceId,
+        const cloudbase = await getManager();
+        const instanceId = await getDatabaseInstanceId(getManager);
+        const toJSONString = (v) => typeof v === "object" && v !== null ? JSON.stringify(v) : v;
+        const result = await cloudbase.commonService("tcb", "2018-06-08").call({
+            Action: "QueryRecords",
+            Param: {
+                TableName: collectionName,
+                MgoQuery: toJSONString(query),
+                MgoProjection: toJSONString(projection),
+                MgoSort: toJSONString(sort),
+                MgoLimit: limit ?? 100,
+                MgoOffset: offset,
+                Tag: instanceId,
+            },
+        });
+        (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        requestId: result.RequestId,
+                        data: result.Data,
+                        pager: result.Pager,
+                        message: "文档查询成功",
+                    }, null, 2),
                 },
-            });
-            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: true,
-                            requestId: result.RequestId,
-                            data: result.Data,
-                            pager: result.Pager,
-                            message: "文档查询成功",
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: error.message,
-                            message: "文档查询失败",
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
+            ],
+        };
     });
     // writeNoSqlDatabaseContent
     server.registerTool?.("writeNoSqlDatabaseContent", {
@@ -211946,9 +211814,7 @@ updateCollection: 更新集合`),
         description: "修改 NoSQL 数据库数据记录",
         inputSchema: {
             action: zod_1.z.enum(["insert", "update", "delete"])
-                .describe(`createCollection: 创建数据
-updateCollection: 更新数据
-deleteCollection: 删除数据`),
+                .describe(`insert: 插入数据（新增文档）\nupdate: 更新数据\ndelete: 删除数据`),
             collectionName: zod_1.z.string().describe("集合名称"),
             documents: zod_1.z
                 .array(zod_1.z.object({}).passthrough())
@@ -212047,98 +211913,70 @@ deleteCollection: 删除数据`),
     });
 }
 async function insertDocuments({ collectionName, documents, getManager, logger, }) {
-    try {
-        const cloudbase = await getManager();
-        const instanceId = await getDatabaseInstanceId(getManager);
-        // 将对象数组序列化为字符串数组
-        const docsAsStrings = documents.map((doc) => JSON.stringify(doc));
-        const result = await cloudbase.commonService("flexdb").call({
-            Action: "PutItem",
-            Param: {
-                TableName: collectionName,
-                MgoDocs: docsAsStrings,
-                Tag: instanceId,
-            },
-        });
-        (0, cloudbase_manager_js_1.logCloudBaseResult)(logger, result);
-        return JSON.stringify({
-            success: true,
-            requestId: result.RequestId,
-            insertedIds: result.InsertedIds,
-            message: "文档插入成功",
-        }, null, 2);
-    }
-    catch (error) {
-        return JSON.stringify({
-            success: false,
-            error: error.message,
-            message: "文档插入失败",
-        }, null, 2);
-    }
+    const cloudbase = await getManager();
+    const instanceId = await getDatabaseInstanceId(getManager);
+    const docsAsStrings = documents.map((doc) => JSON.stringify(doc));
+    const result = await cloudbase.commonService("tcb", "2018-06-08").call({
+        Action: "PutItem",
+        Param: {
+            TableName: collectionName,
+            MgoDocs: docsAsStrings,
+            Tag: instanceId,
+        },
+    });
+    (0, cloudbase_manager_js_1.logCloudBaseResult)(logger, result);
+    return JSON.stringify({
+        success: true,
+        requestId: result.RequestId,
+        insertedIds: result.InsertedIds,
+        message: "文档插入成功",
+    }, null, 2);
 }
 async function updateDocuments({ collectionName, query, update, isMulti, upsert, getManager, logger, }) {
-    try {
-        const cloudbase = await getManager();
-        const instanceId = await getDatabaseInstanceId(getManager);
-        const toJSONString = (v) => typeof v === "object" && v !== null ? JSON.stringify(v) : v;
-        const result = await cloudbase.commonService("flexdb").call({
-            Action: "UpdateItem",
-            Param: {
-                TableName: collectionName,
-                MgoQuery: toJSONString(query),
-                MgoUpdate: toJSONString(update),
-                MgoIsMulti: isMulti,
-                MgoUpsert: upsert,
-                Tag: instanceId,
-            },
-        });
-        (0, cloudbase_manager_js_1.logCloudBaseResult)(logger, result);
-        return JSON.stringify({
-            success: true,
-            requestId: result.RequestId,
-            modifiedCount: result.ModifiedNum,
-            matchedCount: result.MatchedNum,
-            upsertedId: result.UpsertedId,
-            message: "文档更新成功",
-        }, null, 2);
-    }
-    catch (error) {
-        return JSON.stringify({
-            success: false,
-            error: error.message,
-            message: "文档更新失败",
-        }, null, 2);
-    }
+    const cloudbase = await getManager();
+    const instanceId = await getDatabaseInstanceId(getManager);
+    const toJSONString = (v) => typeof v === "object" && v !== null ? JSON.stringify(v) : v;
+    const result = await cloudbase.commonService("tcb", "2018-06-08").call({
+        Action: "UpdateItem",
+        Param: {
+            TableName: collectionName,
+            MgoQuery: toJSONString(query),
+            MgoUpdate: toJSONString(update),
+            MgoIsMulti: isMulti,
+            MgoUpsert: upsert,
+            Tag: instanceId,
+        },
+    });
+    (0, cloudbase_manager_js_1.logCloudBaseResult)(logger, result);
+    return JSON.stringify({
+        success: true,
+        requestId: result.RequestId,
+        modifiedCount: result.ModifiedNum,
+        matchedCount: result.MatchedNum,
+        upsertedId: result.UpsertedId,
+        message: "文档更新成功",
+    }, null, 2);
 }
 async function deleteDocuments({ collectionName, query, isMulti, getManager, logger, }) {
-    try {
-        const cloudbase = await getManager();
-        const instanceId = await getDatabaseInstanceId(getManager);
-        const toJSONString = (v) => typeof v === "object" && v !== null ? JSON.stringify(v) : v;
-        const result = await cloudbase.commonService("flexdb").call({
-            Action: "DeleteItem",
-            Param: {
-                TableName: collectionName,
-                MgoQuery: toJSONString(query),
-                MgoIsMulti: isMulti,
-                Tag: instanceId,
-            },
-        });
-        (0, cloudbase_manager_js_1.logCloudBaseResult)(logger, result);
-        return JSON.stringify({
-            success: true,
-            requestId: result.RequestId,
-            deleted: result.Deleted,
-            message: "文档删除成功",
-        }, null, 2);
-    }
-    catch (error) {
-        return JSON.stringify({
-            success: false,
-            error: error.message,
-            message: "文档删除失败",
-        }, null, 2);
-    }
+    const cloudbase = await getManager();
+    const instanceId = await getDatabaseInstanceId(getManager);
+    const toJSONString = (v) => typeof v === "object" && v !== null ? JSON.stringify(v) : v;
+    const result = await cloudbase.commonService("tcb", "2018-06-08").call({
+        Action: "DeleteItem",
+        Param: {
+            TableName: collectionName,
+            MgoQuery: toJSONString(query),
+            MgoIsMulti: isMulti,
+            Tag: instanceId,
+        },
+    });
+    (0, cloudbase_manager_js_1.logCloudBaseResult)(logger, result);
+    return JSON.stringify({
+        success: true,
+        requestId: result.RequestId,
+        deleted: result.Deleted,
+        message: "文档删除成功",
+    }, null, 2);
 }
 
 
@@ -218385,15 +218223,14 @@ function registerSetupTools(server) {
         title: "下载项目模板",
         description: `自动下载并部署CloudBase项目模板。⚠️ **MANDATORY FOR NEW PROJECTS** ⚠️
 
-**CRITICAL**: This tool MUST be called FIRST when starting a new project.\n\n支持的模板:\n- react: React + CloudBase 全栈应用模板\n- vue: Vue + CloudBase 全栈应用模板\n- miniprogram: 微信小程序 + 云开发模板  \n- uniapp: UniApp + CloudBase 跨端应用模板\n- rules: 只包含AI编辑器配置文件（包含Cursor、WindSurf、CodeBuddy等所有主流编辑器配置），适合在已有项目中补充AI编辑器配置\n\n支持的IDE类型:\n- all: 下载所有IDE配置\n- cursor: Cursor AI编辑器\n- 其他IDE类型见下方列表\n\n注意：如果未传入 ide 参数且无法从环境变量检测到 IDE，将提示错误并要求传入 ide 参数\n- windsurf: WindSurf AI编辑器\n- codebuddy: CodeBuddy AI编辑器\n- claude-code: Claude Code AI编辑器\n- cline: Cline AI编辑器\n- gemini-cli: Gemini CLI\n- opencode: OpenCode AI编辑器\n- qwen-code: 通义灵码\n- baidu-comate: 百度Comate\n- openai-codex-cli: OpenAI Codex CLI\n- augment-code: Augment Code\n- github-copilot: GitHub Copilot\n- roocode: RooCode AI编辑器\n- tongyi-lingma: 通义灵码\n- trae: Trae AI编辑器\n- qoder: Qoder AI编辑器\n- antigravity: Google Antigravity AI编辑器\n- vscode: Visual Studio Code\n- kiro: Kiro AI编辑器\n- aider: Aider AI编辑器\n\n特别说明：\n- rules 模板会自动包含当前 mcp 版本号信息（版本号：${ true ? "2.8.0" : 0}），便于后续维护和版本追踪\n- 下载 rules 模板时，如果项目中已存在 README.md 文件，系统会自动保护该文件不被覆盖（除非设置 overwrite=true）`,
+**CRITICAL**: This tool MUST be called FIRST when starting a new project.\n\n支持的模板:\n- react: React + CloudBase 全栈应用模板\n- vue: Vue + CloudBase 全栈应用模板\n- miniprogram: 微信小程序 + 云开发模板  \n- uniapp: UniApp + CloudBase 跨端应用模板\n- rules: 只包含AI编辑器配置文件（包含Cursor、WindSurf、CodeBuddy等所有主流编辑器配置），适合在已有项目中补充AI编辑器配置\n\n支持的IDE类型:\n- all: 下载所有IDE配置\n- cursor: Cursor AI编辑器\n- 其他IDE类型见下方列表\n\n注意：如果未传入 ide 参数且无法从环境变量检测到 IDE，将提示错误并要求传入 ide 参数\n- windsurf: WindSurf AI编辑器\n- codebuddy: CodeBuddy AI编辑器\n- claude-code: Claude Code AI编辑器\n- cline: Cline AI编辑器\n- gemini-cli: Gemini CLI\n- opencode: OpenCode AI编辑器\n- qwen-code: 通义灵码\n- baidu-comate: 百度Comate\n- openai-codex-cli: OpenAI Codex CLI\n- augment-code: Augment Code\n- github-copilot: GitHub Copilot\n- roocode: RooCode AI编辑器\n- tongyi-lingma: 通义灵码\n- trae: Trae AI编辑器\n- qoder: Qoder AI编辑器\n- antigravity: Google Antigravity AI编辑器\n- vscode: Visual Studio Code\n- kiro: Kiro AI编辑器\n- aider: Aider AI编辑器\n\n特别说明：\n- rules 模板会自动包含当前 mcp 版本号信息（版本号：${ true ? "2.10.0" : 0}），便于后续维护和版本追踪\n- 下载 rules 模板时，如果项目中已存在 README.md 文件，系统会自动保护该文件不被覆盖（除非设置 overwrite=true）`,
         inputSchema: {
             template: zod_1.z
                 .enum(["react", "vue", "miniprogram", "uniapp", "rules"])
                 .describe("要下载的模板类型"),
             ide: zod_1.z
                 .enum(IDE_TYPES)
-                .optional()
-                .describe("指定要下载的IDE类型。如果未指定，会根据 INTEGRATION_IDE 环境变量自动选择对应的IDE配置；如果环境变量也未设置，则必须传入此参数"),
+                .describe("指定要下载的IDE类型。"),
             overwrite: zod_1.z
                 .boolean()
                 .optional()
@@ -218408,7 +218245,7 @@ function registerSetupTools(server) {
         },
     }, async ({ template, ide, overwrite = false, }) => {
         try {
-            const ideResolution = resolveDownloadTemplateIDE(ide, process.env.INTEGRATION_IDE);
+            const ideResolution = resolveDownloadTemplateIDE(ide, undefined);
             if (!ideResolution.ok) {
                 const supportedIDEs = ideResolution.supportedIDEs.join(", ");
                 if (ideResolution.reason === "unmapped_integration_ide") {
@@ -219682,6 +219519,7 @@ exports.getLoginState = getLoginState;
 exports.logout = logout;
 const toolbox_1 = __webpack_require__(25901);
 const logger_js_1 = __webpack_require__(13039);
+const tencet_cloud_js_1 = __webpack_require__(95018);
 const auth = toolbox_1.AuthSupevisor.getInstance({});
 async function getLoginState(options) {
     const { TENCENTCLOUD_SECRETID, TENCENTCLOUD_SECRETKEY, TENCENTCLOUD_SESSIONTOKEN, } = process.env;
@@ -219699,9 +219537,10 @@ async function getLoginState(options) {
     }
     const loginState = await auth.getLoginState();
     if (!loginState) {
-        await auth.loginByWebAuth(options?.fromCloudBaseLoginPage
+        await auth.loginByWebAuth((options?.fromCloudBaseLoginPage && !(0, tencet_cloud_js_1.isInternationalRegion)(options?.region))
             ? {
                 getAuthUrl: (url) => {
+                    // 国际站
                     const separator = url.includes('?') ? '&' : '?';
                     const urlWithParam = `${url}${separator}allowNoEnv=true`;
                     return `https://tcb.cloud.tencent.com/login?_redirect_uri=${encodeURIComponent(urlWithParam)}`;
@@ -219709,6 +219548,9 @@ async function getLoginState(options) {
             }
             : {
                 getAuthUrl: (url) => {
+                    if ((0, tencet_cloud_js_1.isInternationalRegion)(options?.region)) {
+                        url = url.replace('cloud.tencent.com', 'tencentcloud.com');
+                    }
                     const separator = url.includes('?') ? '&' : '?';
                     return `${url}${separator}allowNoEnv=true`;
                 },
@@ -256605,7 +256447,7 @@ class InteractiveServer {
                                             IsVisible: false,
                                             Channels: ["dcloud", "iotenable", "tem", "scene_module"],
                                         };
-                                        envResult = await sessionData.manager.commonService("tcb").call({
+                                        envResult = await sessionData.manager.commonService("tcb", "2018-06-08").call({
                                             Action: "DescribeEnvs",
                                             Param: queryParams,
                                         });
@@ -265452,94 +265294,78 @@ function registerStorageTools(server) {
             category: "storage"
         }
     }, async (args) => {
-        try {
-            const input = args;
-            const manager = await getManager();
-            if (!manager) {
-                throw new Error("Failed to initialize CloudBase manager. Please check your credentials and environment configuration.");
-            }
-            const storageService = manager.storage;
-            switch (input.action) {
-                case 'list': {
-                    const result = await storageService.listDirectoryFiles(input.cloudPath);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        action: 'list',
-                                        cloudPath: input.cloudPath,
-                                        files: result || [],
-                                        totalCount: result?.length || 0
-                                    },
-                                    message: `Successfully listed ${result?.length || 0} files in directory '${input.cloudPath}'`
-                                }, null, 2)
-                            }
-                        ]
-                    };
-                }
-                case 'info': {
-                    const result = await storageService.getFileInfo(input.cloudPath);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        action: 'info',
-                                        cloudPath: input.cloudPath,
-                                        fileInfo: result
-                                    },
-                                    message: `Successfully retrieved file info for '${input.cloudPath}'`
-                                }, null, 2)
-                            }
-                        ]
-                    };
-                }
-                case 'url': {
-                    const result = await storageService.getTemporaryUrl([{
-                            cloudPath: input.cloudPath,
-                            maxAge: input.maxAge || 3600
-                        }]);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        action: 'url',
-                                        cloudPath: input.cloudPath,
-                                        temporaryUrl: result[0]?.url || "",
-                                        expireTime: `${input.maxAge || 3600}秒`,
-                                        fileId: result[0]?.fileId || ""
-                                    },
-                                    message: `Successfully generated temporary URL for '${input.cloudPath}'`
-                                }, null, 2)
-                            }
-                        ]
-                    };
-                }
-                default:
-                    throw new Error(`Unsupported action: ${input.action}`);
+        const input = args;
+        const manager = await getManager();
+        if (!manager) {
+            throw new Error("Failed to initialize CloudBase manager. Please check your credentials and environment configuration.");
+        }
+        const storageService = manager.storage;
+        switch (input.action) {
+            case 'list': {
+                const result = await storageService.listDirectoryFiles(input.cloudPath);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    action: 'list',
+                                    cloudPath: input.cloudPath,
+                                    files: result || [],
+                                    totalCount: result?.length || 0
+                                },
+                                message: `Successfully listed ${result?.length || 0} files in directory '${input.cloudPath}'`
+                            }, null, 2)
+                        }
+                    ]
+                };
             }
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: error.message || 'Unknown error occurred',
-                            message: `Failed to query storage information. Please check your permissions and parameters.`
-                        }, null, 2)
-                    }
-                ]
-            };
+            case 'info': {
+                const result = await storageService.getFileInfo(input.cloudPath);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    action: 'info',
+                                    cloudPath: input.cloudPath,
+                                    fileInfo: result
+                                },
+                                message: `Successfully retrieved file info for '${input.cloudPath}'`
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            case 'url': {
+                const result = await storageService.getTemporaryUrl([{
+                        cloudPath: input.cloudPath,
+                        maxAge: input.maxAge || 3600
+                    }]);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    action: 'url',
+                                    cloudPath: input.cloudPath,
+                                    temporaryUrl: result[0]?.url || "",
+                                    expireTime: `${input.maxAge || 3600}秒`,
+                                    fileId: result[0]?.fileId || ""
+                                },
+                                message: `Successfully generated temporary URL for '${input.cloudPath}'`
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            default:
+                throw new Error(`Unsupported action: ${input.action}`);
         }
     });
     // Tool 2: manageStorage - 管理存储文件（写操作）
@@ -265555,151 +265381,128 @@ function registerStorageTools(server) {
             category: "storage"
         }
     }, async (args) => {
-        try {
-            const input = args;
-            const manager = await getManager();
-            if (!manager) {
-                throw new Error("Failed to initialize CloudBase manager. Please check your credentials and environment configuration.");
-            }
-            const storageService = manager.storage;
-            switch (input.action) {
-                case 'upload': {
-                    if (input.isDirectory) {
-                        // 上传目录
-                        await storageService.uploadDirectory({
-                            localPath: input.localPath,
-                            cloudPath: input.cloudPath,
-                            onProgress: (progressData) => {
-                                console.log("Upload directory progress:", progressData);
-                            }
-                        });
-                    }
-                    else {
-                        // 上传文件
-                        await storageService.uploadFile({
-                            localPath: input.localPath,
-                            cloudPath: input.cloudPath,
-                            onProgress: (progressData) => {
-                                console.log("Upload file progress:", progressData);
-                            }
-                        });
-                    }
-                    // 获取文件临时下载地址
-                    const fileUrls = await storageService.getTemporaryUrl([{
-                            cloudPath: input.cloudPath,
-                            maxAge: 3600 // 临时链接有效期1小时
-                        }]);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        action: 'upload',
-                                        localPath: input.localPath,
-                                        cloudPath: input.cloudPath,
-                                        isDirectory: input.isDirectory,
-                                        temporaryUrl: fileUrls[0]?.url || "",
-                                        expireTime: "1小时"
-                                    },
-                                    message: `Successfully uploaded ${input.isDirectory ? 'directory' : 'file'} from '${input.localPath}' to '${input.cloudPath}'`
-                                }, null, 2)
-                            }
-                        ]
-                    };
+        const input = args;
+        const manager = await getManager();
+        if (!manager) {
+            throw new Error("Failed to initialize CloudBase manager. Please check your credentials and environment configuration.");
+        }
+        const storageService = manager.storage;
+        switch (input.action) {
+            case 'upload': {
+                if (input.isDirectory) {
+                    await storageService.uploadDirectory({
+                        localPath: input.localPath,
+                        cloudPath: input.cloudPath,
+                        onProgress: (progressData) => {
+                            console.log("Upload directory progress:", progressData);
+                        }
+                    });
                 }
-                case 'download': {
-                    if (input.isDirectory) {
-                        // 下载目录
-                        await storageService.downloadDirectory({
-                            cloudPath: input.cloudPath,
-                            localPath: input.localPath
-                        });
-                    }
-                    else {
-                        // 下载文件
-                        await storageService.downloadFile({
-                            cloudPath: input.cloudPath,
-                            localPath: input.localPath
-                        });
-                    }
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        action: 'download',
-                                        cloudPath: input.cloudPath,
-                                        localPath: input.localPath,
-                                        isDirectory: input.isDirectory
-                                    },
-                                    message: `Successfully downloaded ${input.isDirectory ? 'directory' : 'file'} from '${input.cloudPath}' to '${input.localPath}'`
-                                }, null, 2)
-                            }
-                        ]
-                    };
+                else {
+                    await storageService.uploadFile({
+                        localPath: input.localPath,
+                        cloudPath: input.cloudPath,
+                        onProgress: (progressData) => {
+                            console.log("Upload file progress:", progressData);
+                        }
+                    });
                 }
-                case 'delete': {
-                    if (!input.force) {
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: JSON.stringify({
-                                        success: false,
-                                        error: "Delete operation requires confirmation",
-                                        message: "Please set force: true to confirm deletion. This action cannot be undone."
-                                    }, null, 2)
-                                }
-                            ]
-                        };
-                    }
-                    if (input.isDirectory) {
-                        // 删除目录
-                        await storageService.deleteDirectory(input.cloudPath);
-                    }
-                    else {
-                        // 删除文件
-                        await storageService.deleteFile([input.cloudPath]);
-                    }
+                const fileUrls = await storageService.getTemporaryUrl([{
+                        cloudPath: input.cloudPath,
+                        maxAge: 3600
+                    }]);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    action: 'upload',
+                                    localPath: input.localPath,
+                                    cloudPath: input.cloudPath,
+                                    isDirectory: input.isDirectory,
+                                    temporaryUrl: fileUrls[0]?.url || "",
+                                    expireTime: "1小时"
+                                },
+                                message: `Successfully uploaded ${input.isDirectory ? 'directory' : 'file'} from '${input.localPath}' to '${input.cloudPath}'`
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            case 'download': {
+                if (input.isDirectory) {
+                    await storageService.downloadDirectory({
+                        cloudPath: input.cloudPath,
+                        localPath: input.localPath
+                    });
+                }
+                else {
+                    await storageService.downloadFile({
+                        cloudPath: input.cloudPath,
+                        localPath: input.localPath
+                    });
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    action: 'download',
+                                    cloudPath: input.cloudPath,
+                                    localPath: input.localPath,
+                                    isDirectory: input.isDirectory
+                                },
+                                message: `Successfully downloaded ${input.isDirectory ? 'directory' : 'file'} from '${input.cloudPath}' to '${input.localPath}'`
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            case 'delete': {
+                if (!input.force) {
                     return {
                         content: [
                             {
                                 type: "text",
                                 text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        action: 'delete',
-                                        cloudPath: input.cloudPath,
-                                        isDirectory: input.isDirectory,
-                                        deleted: true
-                                    },
-                                    message: `Successfully deleted ${input.isDirectory ? 'directory' : 'file'} '${input.cloudPath}'`
+                                    success: false,
+                                    error: "Delete operation requires confirmation",
+                                    message: "Please set force: true to confirm deletion. This action cannot be undone."
                                 }, null, 2)
                             }
                         ]
                     };
                 }
-                default:
-                    throw new Error(`Unsupported action: ${input.action}`);
+                if (input.isDirectory) {
+                    await storageService.deleteDirectory(input.cloudPath);
+                }
+                else {
+                    await storageService.deleteFile([input.cloudPath]);
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    action: 'delete',
+                                    cloudPath: input.cloudPath,
+                                    isDirectory: input.isDirectory,
+                                    deleted: true
+                                },
+                                message: `Successfully deleted ${input.isDirectory ? 'directory' : 'file'} '${input.cloudPath}'`
+                            }, null, 2)
+                        }
+                    ]
+                };
             }
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: error.message || 'Unknown error occurred',
-                            message: `Failed to manage storage. Please check your permissions and parameters.`
-                        }, null, 2)
-                    }
-                ]
-            };
+            default:
+                throw new Error(`Unsupported action: ${input.action}`);
         }
     });
 }
@@ -266628,6 +266431,27 @@ function pauseStreams (streams, options) {
 }
 
 
+/***/ }),
+
+/***/ 95018:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.isInternationalRegion = void 0;
+exports.isValidRegion = isValidRegion;
+const REGION = {
+    SHANGHAI: 'ap-shanghai',
+    SINGAPORE: 'ap-singapore',
+};
+const isInternationalRegion = (region) => region === REGION.SINGAPORE;
+exports.isInternationalRegion = isInternationalRegion;
+function isValidRegion(region) {
+    return Object.values(REGION).includes(region);
+}
+
+
 /***/ }),
 
 /***/ 95026: