@cloudbase/cloudbase-mcp 2.23.3 → 2.23.6

package/dist/index.js

@@ -593,7 +593,7 @@ async function enrichEnvInfoWithBilling(params) {
  *   for new code, including an explicit `MysqlNotAvailable` line when
  *   MySQL is absent — that one IS a hard "do not use" signal.
  */
-function enrichEnvInfoWithRuntimeMode(result) {
+async function enrichEnvInfoWithRuntimeMode(result, manager) {
     const envInfo = result?.EnvInfo;
     if (!envInfo || typeof envInfo !== "object") {
         return result;
@@ -623,7 +623,29 @@ function enrichEnvInfoWithRuntimeMode(result) {
         }
         return [];
     })();
-    const hasMysql = mysqlList.length > 0;
+    let hasMysql = mysqlList.length > 0;
+    // Fallback: if MySQL not detected from DescribeEnvInfo fields, probe via
+    // DescribeMySQLClusterDetail (dedicated MySQL API). This covers cases where
+    // the SDK strips MySQL fields from the DescribeEnvInfo response.
+    if (!hasMysql && manager?.commonService) {
+        try {
+            const probeResult = await manager
+                .commonService("tcb", "2018-06-08")
+                .call({
+                Action: "DescribeMySQLClusterDetail",
+                Param: { EnvId: envInfo.EnvId },
+            });
+            const clusterId = probeResult?.DbClusterId ||
+                probeResult?.Response?.DbClusterId ||
+                probeResult?.Data?.DbClusterId;
+            if (clusterId) {
+                hasMysql = true;
+            }
+        }
+        catch {
+            // Probe failure means MySQL is not provisioned — keep hasMysql = false
+        }
+    }
     // Primary mode: prefer PG when it is provisioned, otherwise fall back to
     // legacy NoSQL labeling. This drives "what skill to read first / what API
     // to reach for when starting new business code".
@@ -641,7 +663,7 @@ function enrichEnvInfoWithRuntimeMode(result) {
                 : "No legacy NoSQL Database/Storage observed in this env.",
             MysqlNotAvailable: hasMysql
                 ? "MySQL instance(s) detected — see EnvInfo.MysqlInstances."
-                : "No MySQL instance is provisioned for this env. Do NOT use `manageSqlDatabase` / `querySqlDatabase` (those are MySQL-specific) and do NOT read the `relational-database-tool` skill — that family targets MySQL, not CloudBase PG.",
+                : "No MySQL instance is provisioned for this env. Do NOT use `manageMysqlDatabase` / `queryMysqlDatabase` (those are MySQL-specific) and do NOT read the `relational-database-tool` skill — that family targets MySQL, not CloudBase PG.",
             RecommendedSkills: "Read `postgresql-development` first for new PG code. `no-sql-web-sdk` is still applicable for existing NoSQL collections in this env. Skip `relational-database-tool` (MySQL-only) entirely.",
         }
         : {
@@ -651,7 +673,7 @@ function enrichEnvInfoWithRuntimeMode(result) {
             Storage: "Browser uploads use `app.uploadFile()` against the bucket exposed in `EnvInfo.Storages[].Bucket`.",
             MysqlNotAvailable: hasMysql
                 ? "MySQL instance(s) detected — see EnvInfo.MysqlInstances."
-                : "No MySQL instance in this env. `manageSqlDatabase` / `querySqlDatabase` and the `relational-database-tool` skill are not applicable.",
+                : "No MySQL instance in this env. `manageMysqlDatabase` / `queryMysqlDatabase` and the `relational-database-tool` skill are not applicable.",
             RecommendedSkills: "Read `no-sql-web-sdk` (and `cloud-storage-web` for uploads). `postgresql-development` and `relational-database-tool` are not applicable to this env.",
         };
     return {
@@ -1415,7 +1437,7 @@ function registerEnvTools(server) {
                     if (envId) {
                         result = await enrichEnvInfoWithMissingFields(cloudbaseInfo, result, envId);
                     }
-                    result = enrichEnvInfoWithRuntimeMode(result);
+                    result = await enrichEnvInfoWithRuntimeMode(result, cloudbaseInfo);
                     break;
                 case "domains":
                     const cloudbaseDomains = await getManager();
@@ -1483,7 +1505,7 @@ function registerEnvTools(server) {
     // Register primary tool name (queryEnv)
     const queryEnvToolSchema = {
         title: "CloudBase 环境查询",
-        description: "查询 CloudBase 环境相关信息，支持查询环境列表、指定环境详情和安全域名。（曾用名：envQuery、listEnvs、getEnvInfo、getEnvAuthDomains）当 action=list 时，会按 DescribeEnvs 语义做列表/筛选，标准返回字段为 EnvId、Alias、Status、EnvType、Region、PackageId、PackageName、IsDefault，并支持通过 fields 白名单裁剪这些字段；aliasExact=true 时会按别名精确筛选，避免把前缀相近的环境误当作候选；即使传入 envId，action=list 也只返回摘要，不会返回完整资源明细或 expiry。如需查询某个已知 EnvId 对应环境的详细信息（包括资源字段和计费信息），必须使用 action=info 并传入目标环境的 envId 参数。action=info 会在可用时补充 BillingInfo（如 ExpireTime、PayMode、IsAutoRenew 等计费字段）。\n\n🔍 action=info 还会派生三个用于后端选型的字段：\n- `EnvInfo.RuntimeMode`：'postgresql' 或 'nosql'，表示新业务建议默认使用的后端（PG 已开通时为 postgresql，否则为 nosql）。\n- `EnvInfo.RuntimeBackends`：`{postgresql, nosql, mysql}` 三个布尔值，描述当前环境实际并存的后端。\n- `EnvInfo.RuntimeModeHints`：每个后端对应的 API/工具/skill 提示。\n\nAI 在写业务/权限/存储代码前必须先看这三项：PG 模式下新业务推荐 `app.rdb()` + RLS（`managePgDatabase action=execute` 跑 `CREATE POLICY`）+ pgstore；已存在的 NoSQL 集合 / 旧 storage / `managePermissions(resourceType=\"noSqlDatabase\")` 在 PG 环境下仍然有效。真正不适用的是 MySQL：当 `RuntimeBackends.mysql === false` 时，`manageSqlDatabase` / `querySqlDatabase` / `relational-database-tool` skill 都不该使用。",
+        description: "查询 CloudBase 环境相关信息，支持查询环境列表、指定环境详情和安全域名。（曾用名：envQuery、listEnvs、getEnvInfo、getEnvAuthDomains）当 action=list 时，会按 DescribeEnvs 语义做列表/筛选，标准返回字段为 EnvId、Alias、Status、EnvType、Region、PackageId、PackageName、IsDefault，并支持通过 fields 白名单裁剪这些字段；aliasExact=true 时会按别名精确筛选，避免把前缀相近的环境误当作候选；即使传入 envId，action=list 也只返回摘要，不会返回完整资源明细或 expiry。如需查询某个已知 EnvId 对应环境的详细信息（包括资源字段和计费信息），必须使用 action=info 并传入目标环境的 envId 参数。action=info 会在可用时补充 BillingInfo（如 ExpireTime、PayMode、IsAutoRenew 等计费字段）。\n\n🔍 action=info 还会派生三个用于后端选型的字段：\n- `EnvInfo.RuntimeMode`：'postgresql' 或 'nosql'，表示新业务建议默认使用的后端（PG 已开通时为 postgresql，否则为 nosql）。\n- `EnvInfo.RuntimeBackends`：`{postgresql, nosql, mysql}` 三个布尔值，描述当前环境实际并存的后端。\n- `EnvInfo.RuntimeModeHints`：每个后端对应的 API/工具/skill 提示。\n\nAI 在写业务/权限/存储代码前必须先看这三项：PG 模式下新业务推荐 `app.rdb()` + RLS（`managePgDatabase action=execute` 跑 `CREATE POLICY`）+ pgstore；已存在的 NoSQL 集合 / 旧 storage / `managePermissions(resourceType=\"noSqlDatabase\")` 在 PG 环境下仍然有效。真正不适用的是 MySQL：当 `RuntimeBackends.mysql === false` 时，`manageMysqlDatabase` / `queryMysqlDatabase` / `relational-database-tool` skill 都不该使用。",
         inputSchema: {
             action: zod_1.z
                 .enum(["list", "info", "domains"])
@@ -1585,9 +1607,9 @@ function registerEnvTools(server) {
                 .optional()
                 .describe("环境地域（action=create 时可选）。默认 ap-shanghai，可选 ap-guangzhou、ap-beijing 等"),
             resources: zod_1.z
-                .array(zod_1.z.enum(["flexdb", "storage", "function"]))
+                .array(zod_1.z.enum(["flexdb", "storage", "function", "postgresql"]))
                 .optional()
-                .describe("启用的资源类型（action=create 时可选）。默认启用全部三项：flexdb(文档数据库)、storage(存储)、function(云函数)"),
+                .describe("启用的资源类型（action=create 时可选）。默认启用全部四项：flexdb(文档数据库)、storage(存储)、function(云函数)、postgresql(PostgreSQL 数据库)"),
             duration: zod_1.z
                 .number()
                 .int()
@@ -1640,7 +1662,7 @@ function registerEnvTools(server) {
                         return (0, tool_result_js_1.buildJsonToolResult)({
                             ok: false,
                             code: "CONFIRM_REQUIRED",
-                            message: `创建环境需要您确认。请确认以下配置信息后传入 confirm="yes"：\n别名: ${alias}\n套餐: ${packageId}\n地域: ${region}\n资源类型: ${resources?.join(", ") ?? "flexdb, storage, function"}\n时长: ${duration} 个月`,
+                            message: `创建环境需要您确认。请确认以下配置信息后传入 confirm="yes"：\n别名: ${alias}\n套餐: ${packageId}\n地域: ${region}\n资源类型: ${resources?.join(", ") ?? "flexdb, storage, function, postgresql"}\n时长: ${duration} 个月`,
                             next_step: {
                                 tool: "manageEnv",
                                 action: "create",
@@ -1767,6 +1789,7 @@ function registerEnvTools(server) {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.removeEmptyStringParams = removeEmptyStringParams;
 exports.buildCapiErrorMessage = buildCapiErrorMessage;
 exports.registerCapiTools = registerCapiTools;
 const zod_1 = __webpack_require__(2971);
@@ -1802,6 +1825,19 @@ function levenshteinDistance(left, right) {
     }
     return matrix[left.length][right.length];
 }
+/**
+ * Remove empty string parameters from the params object.
+ * Tencent Cloud APIs reject empty strings for required parameters like StartTime/EndTime.
+ */
+function removeEmptyStringParams(params) {
+    const cleaned = {};
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== "") {
+            cleaned[key] = value;
+        }
+    }
+    return cleaned;
+}
 function findTcbActionEntry(action) {
     if (tcb_action_index_js_1.TCB_ACTION_INDEX_MAP[action]) {
         return tcb_action_index_js_1.TCB_ACTION_INDEX_MAP[action];
@@ -1988,9 +2024,10 @@ function registerCapiTools(server) {
         }
         let result;
         try {
+            const cleanedParams = params ? removeEmptyStringParams(params) : {};
             result = await cloudbase.commonService(service).call({
                 Action: action,
-                Param: params ?? {},
+                Param: cleanedParams,
             });
         }
         catch (error) {
@@ -2080,7 +2117,7 @@ ${envIdSection}
 ## 环境信息
 - 操作系统: ${os_1.default.type()} ${os_1.default.release()}
 - Node.js版本: ${process.version}
-- MCP 版本：${process.env.npm_package_version || "2.23.3" || 0}
+- MCP 版本：${process.env.npm_package_version || "2.23.6" || 0}
 - 系统架构: ${os_1.default.arch()}
 - 时间: ${new Date().toISOString()}
 - 请求ID: ${requestId}
@@ -2161,7 +2198,7 @@ function createWrappedHandler(name, handler, server) {
                 requestId: (typeof error === 'object' && error && 'requestId' in error) ? error.requestId : '',
                 ide: server.ide || process.env.INTEGRATION_IDE || ''
             });
-            const mcpVersion =  true ? "2.23.3" : 0;
+            const mcpVersion =  true ? "2.23.6" : 0;
             const requestIdSuffix = requestId ? `\n🆔 RequestId: ${requestId}` : '';
             const enhancedErrorMessage = `${errorMessage}${requestIdSuffix}\n\n📦 CloudBase MCP v${mcpVersion}\n🔗 遇到问题？请复制以下链接到浏览器打开\n即可自动携带错误详情快速创建 GitHub Issue：\n${issueLink}`;
             // 创建新的错误对象，保持原有的错误类型但更新消息
@@ -2346,6 +2383,7 @@ const DEFAULT_PLUGINS = [
     "database",
     "pg_database",
     "pg_storage",
+    "mysql_database",
     "functions",
     "hosting",
     "storage",
@@ -2368,10 +2406,6 @@ function registerDatabase(server) {
     if (!(0, tencent_cloud_js_1.isInternationalRegion)(region)) {
         (0, databaseNoSQL_js_1.registerDatabaseTools)(server);
     }
-    const pgPluginEnabled = server.enabledPlugins?.some((pluginName) => pluginName === "pg_database" || pluginName === "pg_storage");
-    if (!pgPluginEnabled) {
-        (0, databaseSQL_js_1.registerSQLDatabaseTools)(server);
-    }
     (0, dataModel_js_1.registerDataModelTools)(server);
 }
 function registerMysqlDatabase(server) {
@@ -7644,7 +7678,7 @@ const queryStorageInputSchema = {
 // Input schema for manageStorage tool
 const manageStorageInputSchema = {
     action: zod_1.z.enum(['upload', 'download', 'delete']).describe('管理操作类型：upload=上传文件或目录，download=下载文件或目录，delete=删除文件或目录'),
-    localPath: zod_1.z.string().describe('本地文件路径，建议传入绝对路径，例如 /tmp/files/data.txt'),
+    localPath: zod_1.z.string().optional().describe('本地文件路径，建议传入绝对路径，例如 /tmp/files/data.txt；upload/download 操作时必填，delete 操作时不需要传该参数'),
     cloudPath: zod_1.z.string().describe('云端文件路径，例如 files/data.txt'),
     force: zod_1.z.boolean().optional().default(false).describe('强制操作开关，删除操作时建议设置为true以确认删除，默认false'),
     isDirectory: zod_1.z.boolean().optional().default(false).describe('是否为目录操作，true=目录操作，false=文件操作，默认false')
@@ -7894,14 +7928,16 @@ function registerStorageTools(server) {
         const storageService = manager.storage;
         switch (input.action) {
             case 'upload': {
+                const localPath = input.localPath;
+                const cloudPath = input.cloudPath;
                 if (input.isDirectory) {
                     if (storageOverrides?.uploadDirectory) {
-                        await storageOverrides.uploadDirectory({ localPath: input.localPath, cloudPath: input.cloudPath });
+                        await storageOverrides.uploadDirectory({ localPath, cloudPath });
                     }
                     else {
                         await storageService.uploadDirectory({
-                            localPath: input.localPath,
-                            cloudPath: input.cloudPath,
+                            localPath,
+                            cloudPath,
                             onProgress: (progressData) => {
                                 console.log("Upload directory progress:", progressData);
                             }
@@ -7910,12 +7946,12 @@ function registerStorageTools(server) {
                 }
                 else {
                     if (storageOverrides?.uploadFile) {
-                        await storageOverrides.uploadFile({ localPath: input.localPath, cloudPath: input.cloudPath });
+                        await storageOverrides.uploadFile({ localPath, cloudPath });
                     }
                     else {
                         await storageService.uploadFile({
-                            localPath: input.localPath,
-                            cloudPath: input.cloudPath,
+                            localPath,
+                            cloudPath,
                             onProgress: (progressData) => {
                                 console.log("Upload file progress:", progressData);
                             }
@@ -7982,25 +8018,27 @@ function registerStorageTools(server) {
                 };
             }
             case 'download': {
+                const dlCloudPath = input.cloudPath;
+                const dlLocalPath = input.localPath;
                 if (input.isDirectory) {
                     if (storageOverrides?.downloadDirectory) {
-                        await storageOverrides.downloadDirectory({ cloudPath: input.cloudPath, localPath: input.localPath });
+                        await storageOverrides.downloadDirectory({ cloudPath: dlCloudPath, localPath: dlLocalPath });
                     }
                     else {
                         await storageService.downloadDirectory({
-                            cloudPath: input.cloudPath,
-                            localPath: input.localPath
+                            cloudPath: dlCloudPath,
+                            localPath: dlLocalPath
                         });
                     }
                 }
                 else {
                     if (storageOverrides?.downloadFile) {
-                        await storageOverrides.downloadFile({ cloudPath: input.cloudPath, localPath: input.localPath });
+                        await storageOverrides.downloadFile({ cloudPath: dlCloudPath, localPath: dlLocalPath });
                     }
                     else {
                         await storageService.downloadFile({
-                            cloudPath: input.cloudPath,
-                            localPath: input.localPath
+                            cloudPath: dlCloudPath,
+                            localPath: dlLocalPath
                         });
                     }
                 }
@@ -9737,7 +9775,7 @@ class TelemetryReporter {
         const nodeVersion = process.version; // Node.js版本
         const arch = os_1.default.arch(); // 系统架构
         // 从构建时注入的版本号获取MCP版本信息
-        const mcpVersion = process.env.npm_package_version || "2.23.3" || 0;
+        const mcpVersion = process.env.npm_package_version || "2.23.6" || 0;
         return {
             userAgent: `${osType} ${osRelease} ${arch} ${nodeVersion} CloudBase-MCP/${mcpVersion}`,
             deviceId: this.deviceId,
@@ -10026,7 +10064,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.MANAGE_FUNCTION_ACTIONS = exports.QUERY_FUNCTION_ACTIONS = exports.TRIGGER_CONFIG_EXAMPLES = exports.SUPPORTED_TRIGGER_TYPES = exports.DEFAULT_NODEJS_RUNTIME = exports.SUPPORTED_NODEJS_RUNTIMES = exports.RECOMMENDED_RUNTIMES = exports.DEFAULT_RUNTIME = exports.ALL_SUPPORTED_RUNTIMES = exports.SUPPORTED_RUNTIMES = void 0;
+exports.CUSTOM_IMAGE_RUNTIME = exports.MANAGE_FUNCTION_ACTIONS = exports.QUERY_FUNCTION_ACTIONS = exports.TRIGGER_CONFIG_EXAMPLES = exports.SUPPORTED_TRIGGER_TYPES = exports.DEFAULT_NODEJS_RUNTIME = exports.SUPPORTED_NODEJS_RUNTIMES = exports.RECOMMENDED_RUNTIMES = exports.DEFAULT_RUNTIME = exports.ALL_SUPPORTED_RUNTIMES = exports.SUPPORTED_RUNTIMES = void 0;
 exports.formatRuntimeList = formatRuntimeList;
 exports.validateTimerCron = validateTimerCron;
 exports.shouldInstallDependencyForFunction = shouldInstallDependencyForFunction;
@@ -10134,6 +10172,41 @@ const VPC_SCHEMA = zod_1.z.object({
     vpcId: zod_1.z.string(),
     subnetId: zod_1.z.string(),
 });
+// 镜像部署值，对应 SCF Runtime=CustomImage
+exports.CUSTOM_IMAGE_RUNTIME = "CustomImage";
+// HTTP 函数镜像部署配置，对应 Manager SDK 的 IFunctionImageConfig（camelCase）。
+// 用于 zip→COS→CloudApp custom 构建→TCR→SCF 镜像部署链路的「阶段 B」：基于已推送到 TCR 的镜像创建/更新函数。
+const IMAGE_CONFIG_SCHEMA = zod_1.z.object({
+    imageType: zod_1.z
+        .enum(["enterprise", "personal"])
+        .optional()
+        .describe("镜像仓库类型：enterprise（企业版 TCR）或 personal（个人版）。省略时默认 enterprise。"),
+    imageUri: zod_1.z
+        .string()
+        .describe("完整镜像地址（必须含 tag），格式 {domain}/{namespace}/{image}:{tag}，" +
+        "例如 ccr.ccs.tencentyun.com/your-ns/demo-app:demo-app-001。不要使用 :latest。"),
+    registryId: zod_1.z
+        .string()
+        .optional()
+        .describe("TCR 实例 ID，形如 tcr-xxxxxxxx。imageType=enterprise 时必填。"),
+    command: zod_1.z
+        .string()
+        .optional()
+        .describe("覆盖镜像 ENTRYPOINT。不填则使用 Dockerfile 默认值，例如 python。"),
+    args: zod_1.z
+        .string()
+        .optional()
+        .describe("覆盖镜像 CMD，空格分隔，例如 -u app.py。"),
+    entryPoint: zod_1.z.string().optional().describe("镜像入口点，一般不需要单独设置。"),
+    imagePort: zod_1.z
+        .number()
+        .optional()
+        .describe("容器监听端口。Web Server 函数填 9000（默认），Job 型镜像填 -1。"),
+    containerImageAccelerate: zod_1.z
+        .boolean()
+        .optional()
+        .describe("是否开启镜像加速。镜像较大时建议开启以缩短冷启动时间。"),
+});
 const SEVEN_FIELD_CRON_REGEX = /^\s*\S+\s+\S+\s+\S+\s+\S+\s+\S+\s+\S+\s+\S+\s*$/;
 function validateTimerCron(config) {
     const trimmed = config.trim();
@@ -10193,7 +10266,11 @@ const CREATE_FUNCTION_SCHEMA = zod_1.z.object({
         `  Python: ${exports.RECOMMENDED_RUNTIMES.python}\n` +
         `  PHP: ${exports.RECOMMENDED_RUNTIMES.php}\n` +
         `  Java: ${exports.RECOMMENDED_RUNTIMES.java}\n` +
-        `  Go: ${exports.RECOMMENDED_RUNTIMES.golang}`),
+        `  Go: ${exports.RECOMMENDED_RUNTIMES.golang}\n\n` +
+        `镜像部署（基于 TCR 镜像创建函数）时填 "${exports.CUSTOM_IMAGE_RUNTIME}"，并提供 imageConfig；此时无需 functionRootPath/zipFile。`),
+    imageConfig: IMAGE_CONFIG_SCHEMA.optional().describe("镜像部署配置（仅 runtime=CustomImage 时使用）。" +
+        "用于 zip→COS→CloudApp custom 构建→TCR→SCF 的「阶段 B」：基于已推送到 TCR 的镜像创建 HTTP 函数。" +
+        "传入 imageConfig 后即按镜像部署处理，函数无需打包本地代码、scf_bootstrap 或 Handler。"),
     triggers: zod_1.z.array(TRIGGER_SCHEMA).optional().describe("触发器配置数组"),
     handler: zod_1.z.string().optional().describe("函数入口"),
     ignore: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]).optional().describe("忽略文件"),
@@ -10342,7 +10419,12 @@ function registerFunctionTools(server) {
             return;
         }
         if (input.action === "createFunction" || input.action === "updateFunctionCode") {
-            throw new Error(`${input.action} 在 cloud mode 下不可用，因为该操作依赖本地函数代码目录。请改用本地模式执行。`);
+            // 镜像部署不依赖本地代码目录（代码已在 TCR），cloud mode 下可用。
+            const hasImageConfig = Boolean(input.imageConfig ?? input.func?.imageConfig);
+            if (hasImageConfig) {
+                return;
+            }
+            throw new Error(`${input.action} 在 cloud mode 下不可用，因为该操作依赖本地函数代码目录。请改用本地模式执行，或使用镜像部署（runtime=CustomImage + imageConfig）。`);
         }
         if (input.action === "createLayerVersion" && input.contentPath) {
             throw new Error("createLayerVersion 在 cloud mode 下不支持 contentPath，本地文件内容请改为 base64Content 或改用本地模式执行。");
@@ -10692,6 +10774,70 @@ function registerFunctionTools(server) {
                 const func = { ...input.func };
                 const functionName = String(func.name);
                 (0, logger_js_1.debug)(`[createFunction] name=${functionName}, type=${String(func.type || "Event")}`);
+                // 镜像部署分支（Runtime=CustomImage）：基于已推送到 TCR 的镜像创建 HTTP 函数。
+                // 对应 zip→COS→CloudApp custom 构建→TCR→SCF 链路的「阶段 B」。
+                const createImageConfig = input.imageConfig ??
+                    func.imageConfig;
+                const isImageRuntime = typeof func.runtime === "string" &&
+                    func.runtime.replace(/\s+/g, "").toLowerCase() ===
+                        exports.CUSTOM_IMAGE_RUNTIME.toLowerCase();
+                if (createImageConfig || isImageRuntime) {
+                    if (!createImageConfig?.imageUri) {
+                        throw new Error("镜像部署（runtime=CustomImage）时，imageConfig.imageUri 是必需的，" +
+                            "格式为 {domain}/{namespace}/{image}:{tag}（含 tag，不要用 :latest）。");
+                    }
+                    if ((createImageConfig.imageType ?? "enterprise") === "enterprise" &&
+                        !createImageConfig.registryId) {
+                        throw new Error("imageType=enterprise（企业版 TCR）时，imageConfig.registryId（tcr-xxxxxxxx）是必需的。");
+                    }
+                    // 镜像函数即 HTTP 函数；Manager SDK 会自动补 ImageType=enterprise、ImagePort=9000，
+                    // 并在镜像部署时剥离 Handler / InstallDependency，故此处不需要 functionRootPath。
+                    const imageFunc = {
+                        ...func,
+                        type: func.type ?? "HTTP",
+                        runtime: exports.CUSTOM_IMAGE_RUNTIME,
+                        imageConfig: createImageConfig,
+                    };
+                    delete imageFunc.installDependency;
+                    let imageResult;
+                    try {
+                        imageResult = await cloudbase.functions.createFunction({
+                            func: imageFunc,
+                            deployMode: "image",
+                            force: Boolean(input.force),
+                        });
+                    }
+                    catch (error) {
+                        throw wrapFunctionOperationError("createFunction", functionName, undefined, error);
+                    }
+                    (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, imageResult);
+                    return buildEnvelope({
+                        action: input.action,
+                        functionName,
+                        deployMode: "image",
+                        imageUri: createImageConfig.imageUri,
+                        raw: imageResult,
+                    }, `已基于镜像 ${createImageConfig.imageUri} 创建 HTTP 函数 ${functionName}。` +
+                        `请确认 TCR、SCF 与构建管道处于同一地域；如需通过 URL 访问，请显式调用 ` +
+                        `manageGateway(action="createAccess", type="HTTP") 并按需调整函数安全规则。` +
+                        `部署后可用 queryFunctions(action="getFunctionDetail") 确认函数已就绪。`, [
+                        {
+                            tool: "queryFunctions",
+                            action: "getFunctionDetail",
+                            reason: "确认镜像函数已就绪（Active）",
+                        },
+                        {
+                            tool: "manageFunctions",
+                            action: "updateFunctionCode",
+                            reason: "后续迭代只需用新镜像 tag 调用 updateFunctionCode 更新镜像",
+                        },
+                        {
+                            tool: "manageGateway",
+                            action: "createAccess",
+                            reason: "如需通过 URL 访问镜像 HTTP 函数，显式创建网关访问入口并传 type=\"HTTP\"",
+                        },
+                    ]);
+                }
                 if (func.type !== "HTTP") {
                     const originalRuntime = typeof func.runtime === "string" ? func.runtime : undefined;
                     func.runtime = resolveEventFunctionRuntime(func.runtime);
@@ -10785,6 +10931,42 @@ function registerFunctionTools(server) {
                     throw new Error("updateFunctionCode 操作时，functionName 参数是必需的");
                 }
                 const cloudbase = await getManager();
+                // 镜像更新分支：后续迭代只需用新镜像 tag 更新函数。
+                const updateImageConfig = input.imageConfig ??
+                    input.func?.imageConfig;
+                if (updateImageConfig) {
+                    if (!updateImageConfig.imageUri) {
+                        throw new Error("镜像更新时，imageConfig.imageUri 是必需的，格式为 {domain}/{namespace}/{image}:{tag}（含 tag，不要用 :latest）。");
+                    }
+                    let imageResult;
+                    try {
+                        imageResult = await cloudbase.functions.updateFunctionCode({
+                            func: {
+                                name: input.functionName,
+                                imageConfig: updateImageConfig,
+                            },
+                            deployMode: "image",
+                        });
+                    }
+                    catch (error) {
+                        throw wrapFunctionOperationError("updateFunctionCode", input.functionName, undefined, error);
+                    }
+                    (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, imageResult);
+                    return buildEnvelope({
+                        action: input.action,
+                        functionName: input.functionName,
+                        deployMode: "image",
+                        imageUri: updateImageConfig.imageUri,
+                        raw: imageResult,
+                    }, `已将函数 ${input.functionName} 的镜像更新为 ${updateImageConfig.imageUri}。` +
+                        `部署后可用 queryFunctions(action="getFunctionDetail") 确认函数已就绪（Active）。`, [
+                        {
+                            tool: "queryFunctions",
+                            action: "getFunctionDetail",
+                            reason: "确认镜像更新后函数已就绪（Active）",
+                        },
+                    ]);
+                }
                 const processedRootPath = processFunctionRootPath(input.functionRootPath, input.functionName);
                 const updateParams = {
                     func: {
@@ -11195,6 +11377,8 @@ function registerFunctionTools(server) {
         title: "管理 CloudBase 云函数",
         description: "CloudBase 云函数统一写入口。支持创建函数、更新代码、更新配置、调用函数、管理定时跑 / 定时任务 / scheduled job 的 timer 触发器和层绑定。" +
             "如果要创建 cron 定时任务，先用 createFunction 创建函数，再用 createFunctionTrigger 创建 timer 触发器（支持7段cron表达式），deleteFunctionTrigger 删除触发器。" +
+            "镜像部署（Runtime=CustomImage）：先把代码经 zip→COS→CloudApp custom 构建→TCR 推镜像（这一阶段为裸腾讯云 API，本工具不覆盖），" +
+            "再用 createFunction(func.runtime=\"CustomImage\", imageConfig) 基于 TCR 镜像创建 HTTP 函数；后续迭代用 updateFunctionCode + imageConfig 换镜像 tag。" +
             "危险操作需要显式 confirm=true。",
         inputSchema: {
             action: zod_1.z
@@ -11234,6 +11418,9 @@ function registerFunctionTools(server) {
                 .optional()
                 .describe("updateFunctionLayers 的目标层列表，顺序即最终顺序"),
             codeSecret: zod_1.z.string().optional().describe("层绑定时的代码保护密钥"),
+            imageConfig: IMAGE_CONFIG_SCHEMA.optional().describe("镜像部署配置（Runtime=CustomImage）。createFunction 时基于 TCR 镜像创建 HTTP 函数，" +
+                "updateFunctionCode 时仅更换镜像 tag。需提供 imageUri（含 tag），企业版 TCR 还需 registryId。" +
+                "也可在 func.imageConfig 中提供；两处都传时以顶层 imageConfig 优先。"),
             confirm: zod_1.z.boolean().optional().describe("危险操作确认开关。deleteFunction、deleteFunctionTrigger、deleteLayerVersion、detachLayer 等删除类操作需要显式传入 confirm=true"),
             incrementalFile: zod_1.z.string().optional().describe("incrementalDeployFunction 增量部署时的变更文件路径"),
         },
@@ -12909,7 +13096,7 @@ function registerPermissionTools(server) {
     }));
     server.registerTool?.("managePermissions", {
         title: "管理 CloudBase 权限与用户配置",
-        description: "管理 CloudBase 权限与用户配置，支持修改资源权限（数据库/云函数/存储桶等）、角色管理、成员与策略增删、应用用户 CRUD。\n\n示例：\n- 设置存储桶为私有：`action=\"updateResourcePermission\", resourceType=\"storage\", resourceId=\"bucket-name\", permission=\"PRIVATE\"`\n- 创建角色：`action=\"createRole\", roleName=\"admin\", roleIdentity=\"admin\"`\n\n注意：`createUser` / `updateUser` 是环境侧应用用户管理能力，适合测试账号、管理员或预置用户，不应替代浏览器里的 Web SDK 注册表单；前端用户名密码注册应使用 `auth.signUp({ username, password })`，登录应使用 `auth.signInWithPassword({ username, password })`。直接在浏览器里用 `auth.signUp` 创建用户名密码用户取决于 SDK/provider 支持，使用前必须验证；不支持时应走后端或管理端边界，不能在浏览器暴露密钥。`securityRule` 的详细语义取决于 `resourceType`：`doc._openid`、`auth.openid`、查询条件子集校验，以及 `create` / `update` / `delete` JSON 模板仅适用于 `resourceType=\"noSqlDatabase\"` 的文档数据库安全规则；配置 `function` 或 `storage` 时，请参考各自官方安全规则文档，而不是复用 NoSQL 模板。\n\n📌 跨后端边界提示：调用前先用 `envQuery(action=\"info\", envId=...)` 看 `EnvInfo.RuntimeBackends`：\n- `resourceType=\"noSqlDatabase\"` 仅作用于 CloudBase NoSQL 文档数据库的集合；CloudBase PostgreSQL（PG）表的行级权限**不**受它控制——PG 表请改用 RLS：`managePgDatabase(action=\"execute\", confirm=true)` 跑 `ALTER TABLE ... ENABLE ROW LEVEL SECURITY` 与 `CREATE POLICY ...`。同一个 PG 环境里如果还有 NoSQL 集合在用，对那些**集合**继续使用 `noSqlDatabase` 规则是正确的——不是\"PG 环境就禁用本工具\"。\n- `resourceType=\"storage\"` 控制的是 NoSQL/COS 存储桶 ACL；PG 的 `pgstore` bucket 不在此 `resourceType` 覆盖范围内。\n- 本工具不涉及 MySQL；MySQL 数据库权限请走 MySQL 自身的 GRANT/REVOKE 语句（通过 `manageSqlDatabase`）。",
+        description: "管理 CloudBase 权限与用户配置，支持修改资源权限（数据库/云函数/存储桶等）、角色管理、成员与策略增删、应用用户 CRUD。\n\n示例：\n- 设置存储桶为私有：`action=\"updateResourcePermission\", resourceType=\"storage\", resourceId=\"bucket-name\", permission=\"PRIVATE\"`\n- 创建角色：`action=\"createRole\", roleName=\"admin\", roleIdentity=\"admin\"`\n\n注意：`createUser` / `updateUser` 是环境侧应用用户管理能力，适合测试账号、管理员或预置用户，不应替代浏览器里的 Web SDK 注册表单；前端用户名密码注册应使用 `auth.signUp({ username, password })`，登录应使用 `auth.signInWithPassword({ username, password })`。直接在浏览器里用 `auth.signUp` 创建用户名密码用户取决于 SDK/provider 支持，使用前必须验证；不支持时应走后端或管理端边界，不能在浏览器暴露密钥。`securityRule` 的详细语义取决于 `resourceType`：`doc._openid`、`auth.openid`、查询条件子集校验，以及 `create` / `update` / `delete` JSON 模板仅适用于 `resourceType=\"noSqlDatabase\"` 的文档数据库安全规则；配置 `function` 或 `storage` 时，请参考各自官方安全规则文档，而不是复用 NoSQL 模板。\n\n📌 跨后端边界提示：调用前先用 `envQuery(action=\"info\", envId=...)` 看 `EnvInfo.RuntimeBackends`：\n- `resourceType=\"noSqlDatabase\"` 仅作用于 CloudBase NoSQL 文档数据库的集合；CloudBase PostgreSQL（PG）表的行级权限**不**受它控制——PG 表请改用 RLS：`managePgDatabase(action=\"execute\", confirm=true)` 跑 `ALTER TABLE ... ENABLE ROW LEVEL SECURITY` 与 `CREATE POLICY ...`。同一个 PG 环境里如果还有 NoSQL 集合在用，对那些**集合**继续使用 `noSqlDatabase` 规则是正确的——不是\"PG 环境就禁用本工具\"。\n- `resourceType=\"storage\"` 控制的是 NoSQL/COS 存储桶 ACL；PG 的 `pgstore` bucket 不在此 `resourceType` 覆盖范围内。\n- 本工具不涉及 MySQL；MySQL 数据库权限请走 MySQL 自身的 GRANT/REVOKE 语句（通过 `manageMysqlDatabase`）。",
         inputSchema: {
             action: zod_1.z.enum(MANAGE_PERMISSION_ACTIONS),
             resourceType: zod_1.z
@@ -13599,7 +13786,7 @@ function registerSetupTools(server) {
     server.registerTool("downloadTemplate", {
         title: "下载项目模板",
         description: `自动下载并部署CloudBase项目模板。
-**Note**: Call this tool when the user requests to create a new project using a CloudBase template.\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.23.3" : 0}），便于后续维护和版本追踪\n- 下载 rules 模板时，如果项目中已存在 README.md 文件，系统会自动保护该文件不被覆盖（除非设置 overwrite=true）`,
+**Note**: Call this tool when the user requests to create a new project using a CloudBase template.\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.23.6" : 0}），便于后续维护和版本追踪\n- 下载 rules 模板时，如果项目中已存在 README.md 文件，系统会自动保护该文件不被覆盖（除非设置 overwrite=true）`,
         inputSchema: {
             template: zod_1.z
                 .enum(["react", "vue", "miniprogram", "uniapp", "rules"])
@@ -16879,6 +17066,8 @@ function registerAgentTools(server) {
             category: "agents",
         },
     }, async ({ action, agentId, name, description, runtime, timeout, memorySize, installDependency, zipFile, cosBucketRegion, tempCosObjectName, sessionConfig, cwd, params, }) => {
+        let _agentName;
+        let _agentRuntime;
         try {
             const cloudbase = await getManager();
             const payload = normalizeAgentPayload({
@@ -16895,11 +17084,19 @@ function registerAgentTools(server) {
                 cwd,
                 ...(params ?? {}),
             });
+            _agentName = payload?.Name;
+            _agentRuntime = payload?.Runtime;
             if (action === "createAgent") {
                 const normalizedName = normalizeString(payload.Name);
                 if (!normalizedName) {
                     throw new Error("action=createAgent 时必须提供 name（可通过顶层 name 或 params.name 传入）");
                 }
+                // CloudBase 后端在创建 Agent 时会同步创建云函数，函数名/别名长度受 SCF 限制（最大 64 字符）。
+                // envId 可能被用作前缀或别名的一部分，因此这里预留足够余量，避免后端 CreateFunction 失败。
+                if (normalizedName.length > 30) {
+                    throw new Error(`agent name 过长（当前 ${normalizedName.length} 字符）。CloudBase 创建 Agent 时会同步创建云函数，` +
+                        `函数名/别名受 SCF 64 字符限制，且 envId 可能作为前缀拼接。请将 name 控制在 30 字符以内。`);
+                }
                 const createPayload = {
                     ...payload,
                     Name: normalizedName,
@@ -16938,6 +17135,17 @@ function registerAgentTools(server) {
             }, "Agent 删除成功"));
         }
         catch (error) {
+            // 对后端 InternalError 提供更有意义的错误信息
+            const errMsg = error instanceof Error ? error.message : String(error);
+            if (errMsg.includes("InternalError") || errMsg.includes("服务处理出错")) {
+                server.logger?.({
+                    type: "createAgentError",
+                    message: "createAgent 后端返回 InternalError，可能是云函数创建失败",
+                    originalError: errMsg,
+                    name: _agentName,
+                    runtime: _agentRuntime,
+                });
+            }
             return (0, json_content_js_1.jsonContent)(buildErrorEnvelope(error));
         }
     });
@@ -17075,7 +17283,7 @@ async function checkMysqlGate(server) {
             success: false,
             errorCode: "MYSQL_NOT_AVAILABLE",
             message: `This environment (${envId}) does not have MySQL. Use managePgDatabase / queryPgDatabase instead.`,
-            nextActions: [{ tool: "managePgDatabase", params: { action: "execute" }, description: "Use managePgDatabase" }],
+            nextActions: [{ tool: "managePgDatabase", params: { action: "execute" }, description: "Use managePgDatabase for PostgreSQL operations" }],
         });
     }
     try {
@@ -17087,7 +17295,7 @@ async function checkMysqlGate(server) {
             return (0, tool_result_js_1.buildJsonToolResult)({
                 success: false,
                 errorCode: "MYSQL_NOT_AVAILABLE",
-                message: `This environment (${envId}) has PostgreSQL enabled but MySQL is NOT available. Use managePgDatabase / queryPgDatabase instead of manageSqlDatabase / querySqlDatabase.`,
+                message: `This environment (${envId}) has PostgreSQL enabled but MySQL is NOT available. Use managePgDatabase / queryPgDatabase instead of manageMysqlDatabase / queryMysqlDatabase.`,
                 nextActions: [{ tool: "managePgDatabase", params: { action: "execute" }, description: "Use managePgDatabase for PostgreSQL operations" }],
             });
         }
@@ -17096,8 +17304,8 @@ async function checkMysqlGate(server) {
     MYSQL_GATE_CACHE.set(envId, true);
     return null;
 }
-const QUERY_SQL_DATABASE = "querySqlDatabase";
-const MANAGE_SQL_DATABASE = "manageSqlDatabase";
+const QUERY_MYSQL_DATABASE = "queryMysqlDatabase";
+const MANAGE_MYSQL_DATABASE = "manageMysqlDatabase";
 const QUERY_PERMISSIONS = "queryPermissions";
 const MANAGE_PERMISSIONS = "managePermissions";
 const QUERY_ACTIONS = [
@@ -17389,14 +17597,14 @@ async function getSqlInstanceInfo({ getManager, cloudBaseOptions, server, }) {
 function buildProvisionNextActions(status, request) {
     if (status === "READY") {
         return [
-            buildNextAction(MANAGE_SQL_DATABASE, "initializeSchema", "MySQL is ready. Initialize tables and indexes next."),
+            buildNextAction(MANAGE_MYSQL_DATABASE, "initializeSchema", "MySQL is ready. Initialize tables and indexes next."),
         ];
     }
     if (status === "FAILED") {
         return [];
     }
     return [
-        buildNextAction(QUERY_SQL_DATABASE, "describeCreateResult", "MySQL provisioning is still running. Check the create result again before initializing schema.", request
+        buildNextAction(QUERY_MYSQL_DATABASE, "describeCreateResult", "MySQL provisioning is still running. Check the create result again before initializing schema.", request
             ? { action: "describeCreateResult", request }
             : { action: "describeCreateResult" }),
     ];
@@ -17415,15 +17623,15 @@ function buildTaskStatusNextActions(status, request) {
     if (status === "READY") {
         if (inferTaskKind(request) === "destroy") {
             return [
-                buildNextAction(QUERY_SQL_DATABASE, "getInstanceInfo", "The destroy task completed. Confirm whether the MySQL instance no longer exists."),
+                buildNextAction(QUERY_MYSQL_DATABASE, "getInstanceInfo", "The destroy task completed. Confirm whether the MySQL instance no longer exists."),
             ];
         }
         return [
-            buildNextAction(MANAGE_SQL_DATABASE, "initializeSchema", "MySQL is ready. Initialize tables and indexes next."),
+            buildNextAction(MANAGE_MYSQL_DATABASE, "initializeSchema", "MySQL is ready. Initialize tables and indexes next."),
         ];
     }
     return [
-        buildNextAction(QUERY_SQL_DATABASE, "describeTaskStatus", "MySQL task is still running. Check task status again before continuing.", request ? { action: "describeTaskStatus", request } : { action: "describeTaskStatus" }),
+        buildNextAction(QUERY_MYSQL_DATABASE, "describeTaskStatus", "MySQL task is still running. Check task status again before continuing.", request ? { action: "describeTaskStatus", request } : { action: "describeTaskStatus" }),
     ];
 }
 async function handleRunQuery(args, context) {
@@ -17433,7 +17641,7 @@ async function handleRunQuery(args, context) {
             errorCode: "SQL_REQUIRED",
             message: "`sql` is required when action is `runQuery`.",
             nextActions: [
-                buildNextAction(QUERY_SQL_DATABASE, "runQuery", "Provide a read-only SQL statement such as SELECT/SHOW/DESCRIBE."),
+                buildNextAction(QUERY_MYSQL_DATABASE, "runQuery", "Provide a read-only SQL statement such as SELECT/SHOW/DESCRIBE."),
             ],
         });
     }
@@ -17441,9 +17649,9 @@ async function handleRunQuery(args, context) {
         return buildSqlToolResult({
             success: false,
             errorCode: "READ_ONLY_SQL_REQUIRED",
-            message: "`querySqlDatabase(action=runQuery)` only accepts read-only SQL statements.",
+            message: "`queryMysqlDatabase(action=runQuery)` only accepts read-only SQL statements.",
             nextActions: [
-                buildNextAction(MANAGE_SQL_DATABASE, "runStatement", "Use the manage tool for INSERT/UPDATE/DELETE/DDL statements."),
+                buildNextAction(MANAGE_MYSQL_DATABASE, "runStatement", "Use the manage tool for INSERT/UPDATE/DELETE/DDL statements."),
             ],
         });
     }
@@ -17471,7 +17679,7 @@ async function handleRunQuery(args, context) {
                 errorCode: "MYSQL_NOT_CREATED",
                 message: "MySQL is not provisioned yet or not found. Please provision MySQL before running queries.",
                 nextActions: [
-                    buildNextAction(MANAGE_SQL_DATABASE, "provisionMySQL", "Provision MySQL before querying data.", { action: "provisionMySQL", confirm: true }),
+                    buildNextAction(MANAGE_MYSQL_DATABASE, "provisionMySQL", "Provision MySQL before querying data.", { action: "provisionMySQL", confirm: true }),
                 ],
             });
         }
@@ -17570,7 +17778,7 @@ async function handleGetInstanceInfo(context) {
         nextActions: instanceInfo.exists
             ? undefined
             : [
-                buildNextAction(MANAGE_SQL_DATABASE, "provisionMySQL", "Provision MySQL before running SQL statements or schema initialization.", { action: "provisionMySQL", confirm: true }),
+                buildNextAction(MANAGE_MYSQL_DATABASE, "provisionMySQL", "Provision MySQL before running SQL statements or schema initialization.", { action: "provisionMySQL", confirm: true }),
             ],
     });
 }
@@ -17581,7 +17789,7 @@ async function handleProvisionMySQL(args, context) {
             errorCode: "CONFIRM_REQUIRED",
             message: "Provisioning MySQL creates billable resources. Re-run with `confirm: true` to continue.",
             nextActions: [
-                buildNextAction(MANAGE_SQL_DATABASE, "provisionMySQL", "Explicit confirmation is required before provisioning MySQL.", { action: "provisionMySQL", confirm: true }),
+                buildNextAction(MANAGE_MYSQL_DATABASE, "provisionMySQL", "Explicit confirmation is required before provisioning MySQL.", { action: "provisionMySQL", confirm: true }),
             ],
         });
     }
@@ -17595,7 +17803,7 @@ async function handleProvisionMySQL(args, context) {
             message: "A SQL database instance already exists for the current environment.",
             nextActions: existing.status === "READY"
                 ? [
-                    buildNextAction(MANAGE_SQL_DATABASE, "initializeSchema", "The instance already exists. You can initialize schema next if needed."),
+                    buildNextAction(MANAGE_MYSQL_DATABASE, "initializeSchema", "The instance already exists. You can initialize schema next if needed."),
                 ]
                 : undefined,
         });
@@ -17641,7 +17849,7 @@ async function handleDestroyMySQL(args, context) {
             errorCode: "CONFIRM_REQUIRED",
             message: "Destroying MySQL removes database resources. Re-run with `confirm: true` to continue.",
             nextActions: [
-                buildNextAction(MANAGE_SQL_DATABASE, "destroyMySQL", "Explicit confirmation is required before destroying MySQL.", { action: "destroyMySQL", confirm: true }),
+                buildNextAction(MANAGE_MYSQL_DATABASE, "destroyMySQL", "Explicit confirmation is required before destroying MySQL.", { action: "destroyMySQL", confirm: true }),
             ],
         });
     }
@@ -17688,7 +17896,7 @@ async function handleDestroyMySQL(args, context) {
             : "MySQL destroy request was rejected.",
         nextActions: isSuccess
             ? [
-                buildNextAction(QUERY_SQL_DATABASE, "describeTaskStatus", "Check the MySQL destroy task status before assuming the instance is gone.", {
+                buildNextAction(QUERY_MYSQL_DATABASE, "describeTaskStatus", "Check the MySQL destroy task status before assuming the instance is gone.", {
                     action: "describeTaskStatus",
                     request: taskRequest,
                 }),
@@ -17711,7 +17919,7 @@ async function handleRunStatement(args, context) {
             errorCode: "MYSQL_NOT_CREATED",
             message: "MySQL is not provisioned for the current environment yet.",
             nextActions: [
-                buildNextAction(MANAGE_SQL_DATABASE, "provisionMySQL", "Provision MySQL before executing write statements or DDL.", { action: "provisionMySQL", confirm: true }),
+                buildNextAction(MANAGE_MYSQL_DATABASE, "provisionMySQL", "Provision MySQL before executing write statements or DDL.", { action: "provisionMySQL", confirm: true }),
             ],
         });
     }
@@ -17721,7 +17929,7 @@ async function handleRunStatement(args, context) {
             errorCode: "MYSQL_NOT_READY",
             message: `MySQL is not ready yet (current status: ${instanceInfo.status}).`,
             nextActions: [
-                buildNextAction(QUERY_SQL_DATABASE, "getInstanceInfo", "Check current instance status before retrying the statement."),
+                buildNextAction(QUERY_MYSQL_DATABASE, "getInstanceInfo", "Check current instance status before retrying the statement."),
             ],
         });
     }
@@ -17748,7 +17956,7 @@ async function handleRunStatement(args, context) {
                 errorCode: "MYSQL_NOT_CREATED",
                 message: "MySQL is not provisioned yet or not found. Please provision MySQL before running statements.",
                 nextActions: [
-                    buildNextAction(MANAGE_SQL_DATABASE, "provisionMySQL", "Provision MySQL before executing statements.", { action: "provisionMySQL", confirm: true }),
+                    buildNextAction(MANAGE_MYSQL_DATABASE, "provisionMySQL", "Provision MySQL before executing statements.", { action: "provisionMySQL", confirm: true }),
                 ],
             });
         }
@@ -17777,7 +17985,7 @@ async function resolveInitializationReadiness(args, context) {
                 errorCode: "MYSQL_NOT_CREATED",
                 message: "MySQL is not provisioned yet. Initialize schema only after provisioning completes.",
                 nextActions: [
-                    buildNextAction(MANAGE_SQL_DATABASE, "provisionMySQL", "Provision MySQL before schema initialization.", { action: "provisionMySQL", confirm: true }),
+                    buildNextAction(MANAGE_MYSQL_DATABASE, "provisionMySQL", "Provision MySQL before schema initialization.", { action: "provisionMySQL", confirm: true }),
                 ],
             }),
         };
@@ -17817,7 +18025,7 @@ async function resolveInitializationReadiness(args, context) {
                     rawStatus,
                 },
                 nextActions: [
-                    buildNextAction(QUERY_SQL_DATABASE, "describeTaskStatus", "Check MySQL task status until the instance becomes ready.", args.statusContext?.taskStatusRequest
+                    buildNextAction(QUERY_MYSQL_DATABASE, "describeTaskStatus", "Check MySQL task status until the instance becomes ready.", args.statusContext?.taskStatusRequest
                         ? {
                             action: "describeTaskStatus",
                             request: args.statusContext.taskStatusRequest,
@@ -17874,7 +18082,7 @@ async function handleInitializeSchema(args, context) {
                         errorCode: "MYSQL_NOT_CREATED",
                         message: "MySQL is not provisioned yet or not found. Please provision MySQL before initializing schema.",
                         nextActions: [
-                            buildNextAction(MANAGE_SQL_DATABASE, "provisionMySQL", "Provision MySQL before executing statements.", { action: "provisionMySQL", confirm: true }),
+                            buildNextAction(MANAGE_MYSQL_DATABASE, "provisionMySQL", "Provision MySQL before executing statements.", { action: "provisionMySQL", confirm: true }),
                         ],
                     });
                 }
@@ -17922,7 +18130,7 @@ function registerSQLDatabaseTools(server) {
         cloudBaseOptions,
         server,
     };
-    server.registerTool?.(QUERY_SQL_DATABASE, {
+    server.registerTool?.(QUERY_MYSQL_DATABASE, {
         title: "查询 CloudBase MySQL 数据库状态或执行只读 SQL",
         description: "查询 CloudBase MySQL 数据库信息。支持执行只读 SQL、查询 MySQL 开通结果、查询 MySQL 任务状态，以及获取当前实例上下文信息。",
         inputSchema: {
@@ -17968,7 +18176,7 @@ function registerSQLDatabaseTools(server) {
                 throw new Error(`Unsupported SQL query action: ${args.action}`);
         }
     });
-    server.registerTool?.(MANAGE_SQL_DATABASE, {
+    server.registerTool?.(MANAGE_MYSQL_DATABASE, {
         title: "管理 CloudBase MySQL 数据库生命周期或执行写入 SQL",
         description: "管理 CloudBase MySQL 数据库资源。支持开通 MySQL、销毁 MySQL、执行写入 SQL/DDL，以及初始化数据库 Schema。注意：必须先开通 MySQL（action=provisionMySQL，confirm=true）才能执行 runStatement 或 initializeSchema。若 MySQL 尚未开通，工具会返回 MYSQL_NOT_CREATED 并给出开通的 nextAction 提示。",
         inputSchema: {