@cloudbase/cloudbase-mcp 2.21.0 → 2.21.1-beta.1

package/dist/index.cjs

@@ -1914,17 +1914,17 @@ function buildEnvDomainManagementResult(params) {
             operation: action,
             targetDomains: domains,
             asyncState: "PENDING",
-            message: '安全域名已提交添加请求。该变更通常需要约 10 分钟传播，请继续轮询 envQuery(action="domains")，直到目标域名状态为 ENABLE。',
+            message: '安全域名已提交添加请求。该变更通常需要约 10 分钟传播，请继续轮询 queryEnv(action="domains")，直到目标域名状态为 ENABLE。',
             propagation: {
                 requiresPolling: true,
-                pollTool: "envQuery",
+                pollTool: "queryEnv",
                 pollAction: "domains",
                 pollIntervalSuggestionSeconds: 10,
                 timeoutSuggestionSeconds: 600,
-                successCondition: '目标域名出现在 envQuery(action="domains") 返回中，且 Status 为 ENABLE。',
+                successCondition: '目标域名出现在 queryEnv(action="domains") 返回中，且 Status 为 ENABLE。',
             },
             next_step: {
-                tool: "envQuery",
+                tool: "queryEnv",
                 action: "domains",
                 suggested_args: {
                     action: "domains",
@@ -1939,17 +1939,17 @@ function buildEnvDomainManagementResult(params) {
         operation: action,
         targetDomains: domains,
         asyncState: "PENDING",
-        message: '安全域名已提交删除请求。该变更可能需要数分钟传播，请继续轮询 envQuery(action="domains")，直到目标域名不再出现。',
+        message: '安全域名已提交删除请求。该变更可能需要数分钟传播，请继续轮询 queryEnv(action="domains")，直到目标域名不再出现。',
         propagation: {
             requiresPolling: true,
-            pollTool: "envQuery",
+            pollTool: "queryEnv",
             pollAction: "domains",
             pollIntervalSuggestionSeconds: 10,
             timeoutSuggestionSeconds: 600,
-            successCondition: '目标域名不再出现在 envQuery(action="domains") 返回中。',
+            successCondition: '目标域名不再出现在 queryEnv(action="domains") 返回中。',
         },
         next_step: {
-            tool: "envQuery",
+            tool: "queryEnv",
             action: "domains",
             suggested_args: {
                 action: "domains",
@@ -2223,7 +2223,7 @@ function buildEnvQueryListResult(params) {
     const paginated = paginateEnvList(filteredList, params.filters.offset, params.filters.limit);
     const exactEnvIdSummaryHint = params.filters.envId
         ? {
-            tool: "envQuery",
+            tool: "queryEnv",
             action: "info",
             reason: "action=list with envId only returns a concise summary. Use action=info to fetch detailed environment information such as full resource metadata and additional environment details.",
         }
@@ -2294,7 +2294,7 @@ function normalizeOptionalToolString(value) {
         : undefined;
 }
 /**
- * Build enhanced error message for envQuery tool errors
+ * Build enhanced error message for queryEnv tool errors
  * Provides actionable guidance based on error patterns
  */
 function buildEnvQueryErrorMessage(error, action) {
@@ -2310,7 +2310,7 @@ function buildEnvQueryErrorMessage(error, action) {
         suggestions.push("参数错误：可能是认证信息无效或已过期，请尝试以下步骤：");
         suggestions.push("1. 先调用 auth(action=\"status\") 检查当前登录状态");
         suggestions.push("2. 如果未登录，调用 auth(action=\"start_auth\", authMode=\"device\") 完成登录");
-        suggestions.push("3. 登录完成后再次调用 envQuery(action=\"list\")");
+        suggestions.push("3. 登录完成后再次调用 queryEnv(action=\"list\")");
     }
     if (hasAuthError) {
         suggestions.push("认证错误：当前未登录或认证已过期。");
@@ -2322,7 +2322,7 @@ function buildEnvQueryErrorMessage(error, action) {
     }
     if (hasEnvNotFoundError) {
         suggestions.push("环境错误：指定的环境不存在或无法访问。");
-        suggestions.push("请使用 envQuery(action=\"list\") 查看可用的环境列表。");
+        suggestions.push("请使用 queryEnv(action=\"list\") 查看可用的环境列表。");
     }
     if (hasNetworkError) {
         suggestions.push("网络错误：请检查网络连接，稍后重试。");
@@ -2334,7 +2334,7 @@ function buildEnvQueryErrorMessage(error, action) {
         suggestions.push("2. 如未登录，执行 auth(action=\"start_auth\") 完成认证");
         suggestions.push("3. 确认环境 ID 正确且可访问");
     }
-    return `[envQuery/${action}] 调用失败: ${baseMessage}\n\n解决建议：\n${suggestions.join("\n")}`;
+    return `[queryEnv/${action}] 调用失败: ${baseMessage}\n\n解决建议：\n${suggestions.join("\n")}`;
 }
 function normalizeOptionalToolBoolean(value) {
     return typeof value === "boolean" ? value : undefined;
@@ -2363,519 +2363,500 @@ function registerEnvTools(server) {
     const supportedAuthActions = getSupportedAuthActions(server);
     const authActionEnum = [...supportedAuthActions];
     // auth - CloudBase (云开发) 开发阶段登录与环境绑定
-    server.registerTool?.("auth", {
-        title: "CloudBase 开发阶段登录与环境",
-        description: "CloudBase（腾讯云开发）开发阶段登录与环境绑定。登录后即可访问云资源；环境(env)是云函数、数据库、静态托管等资源的隔离单元，绑定环境后其他 MCP 工具才能操作该环境。支持：查询状态、发起登录、绑定环境(set_env)、退出登录。",
-        inputSchema: {
-            action: zod_1.z
-                .enum(authActionEnum)
-                .optional()
-                .describe("动作：status=查询状态，start_auth=发起登录，set_env=绑定环境(传envId)，logout=退出登录"),
-            ...(supportedAuthActions.includes("start_auth")
-                ? {
-                    authMode: zod_1.z
-                        .enum(["device", "web"])
-                        .optional()
-                        .describe("认证模式：device=设备码授权，web=浏览器回调授权"),
-                    oauthEndpoint: zod_1.z
-                        .string()
-                        .optional()
-                        .describe("高级可选：自定义 device-code 登录 endpoint。配置后 oauthCustom 默认按 true 处理"),
-                    clientId: zod_1.z
-                        .string()
-                        .optional()
-                        .describe("高级可选：自定义 device-code 登录 client_id，不传则使用默认值"),
-                    oauthCustom: zod_1.z
-                        .boolean()
-                        .optional()
-                        .describe("高级可选：自定义 endpoint 返回格式开关。未配置 endpoint 时默认 false；配置 endpoint 后默认 true，且不能设为 false"),
-                }
-                : {}),
-            envId: zod_1.z
-                .string()
-                .optional()
-                .describe("环境ID(CloudBase 环境唯一标识)，绑定后工具将操作该环境。action=set_env 时必填"),
-            ...(supportedAuthActions.includes("logout")
-                ? {
-                    confirm: zod_1.z
-                        .literal("yes")
-                        .optional()
-                        .describe("action=logout 时确认操作，传 yes"),
-                }
-                : {}),
-            ...(supportedAuthActions.includes("get_temp_credentials")
-                ? {
-                    reveal: zod_1.z
-                        .boolean()
-                        .optional()
-                        .describe("action=get_temp_credentials 时可选。true=返回明文临时密钥；默认 false 仅返回脱敏结果"),
-                }
-                : {}),
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: true,
-            category: "env",
-        },
-    }, async (rawArgs) => {
-        const action = rawArgs.action ?? "status";
-        const authMode = rawArgs.authMode === "device" || rawArgs.authMode === "web"
-            ? rawArgs.authMode
-            : undefined;
-        const oauthEndpoint = normalizeOptionalToolString(rawArgs.oauthEndpoint);
-        const clientId = normalizeOptionalToolString(rawArgs.clientId);
-        const oauthCustom = normalizeOptionalToolBoolean(rawArgs.oauthCustom);
-        const envId = rawArgs.envId;
-        const confirm = rawArgs.confirm === "yes" ? "yes" : undefined;
-        const reveal = normalizeOptionalToolBoolean(rawArgs.reveal) === true;
-        const resolvedAuthOptions = resolveToolAuthOptions(server, {
-            authMode,
-            oauthEndpoint,
-            clientId,
-            oauthCustom,
-        });
-        const authConfigSummary = (0, auth_js_1.buildAuthConfigSummary)(resolvedAuthOptions);
-        let deviceAuthInfo;
-        const onDeviceCode = (info) => {
-            deviceAuthInfo = info;
-            (0, auth_js_1.setPendingAuthProgressState)(info, "device");
-            // emitDeviceAuthNotice(server, info);
-        };
-        const authChallenge = () => (0, auth_js_1.buildDeviceAuthChallengePayload)(deviceAuthInfo);
-        try {
-            if (!supportedAuthActions.includes(action)) {
-                return (0, tool_result_js_1.buildJsonToolResult)({
-                    ok: false,
-                    code: "NOT_SUPPORTED",
-                    message: `当前 IDE 不支持 auth(action="${action}")。`,
-                    next_step: (0, tool_result_js_1.buildAuthNextStep)("status", {
-                        suggestedArgs: { action: "status" },
-                    }),
-                });
-            }
-            if (action === "status") {
-                const loginState = await (0, auth_js_1.peekLoginState)();
-                const authFlowState = await (0, auth_js_1.getAuthProgressState)();
-                // 判断是否为 API Key 模式
-                const isApiKeyMode = !!(process.env.CLOUDBASE_API_KEY && process.env.CLOUDBASE_ENV_ID);
-                const authStatus = loginState
-                    ? "READY"
-                    : authFlowState.status === "PENDING"
-                        ? "PENDING"
-                        : "REQUIRED";
-                let envPreparation;
-                const message = authStatus === "READY"
-                    ? undefined
-                    : authStatus === "PENDING"
-                        ? "设备码授权进行中，请完成浏览器授权后再次调用 auth(action=\"status\")"
-                        : isCodeBuddyIde(server)
-                            ? "当前未登录。CodeBuddy 暂不支持在 tool 内发起认证，请在外部完成认证后再次调用 auth(action=\"status\")。"
-                            : "当前未登录，请先执行 auth(action=\"start_auth\")";
-                if (authStatus === "READY" && loginState) {
-                    envPreparation = await prepareAuthEnvironment({
-                        server,
-                        cloudBaseOptions,
-                        loginState,
-                    });
-                }
-                return (0, tool_result_js_1.buildJsonToolResult)({
-                    ok: true,
-                    code: "STATUS",
-                    auth_status: authStatus,
-                    ...(isApiKeyMode ? { auth_mode: "api_key" } : {}),
-                    auth_config: authConfigSummary,
-                    ...(envPreparation
-                        ? buildAuthEnvSetupPayload(envPreparation)
-                        : {
-                            env_status: "NONE",
-                            current_env_id: null,
-                            ...buildEnvCandidatePayload([]),
-                        }),
-                    auth_challenge: authFlowState.status === "PENDING"
-                        ? (0, auth_js_1.buildDeviceAuthChallengePayload)(authFlowState.authChallenge)
-                        : undefined,
-                    message,
-                    next_step: authStatus === "REQUIRED"
-                        ? buildAuthRequiredNextStep(server)
-                        : authStatus === "PENDING"
-                            ? (0, tool_result_js_1.buildAuthNextStep)("status", {
-                                suggestedArgs: { action: "status" },
-                            })
-                            : envPreparation?.nextStep,
-                });
-            }
-            if (action === "start_auth") {
-                // API Key 模式：尝试换取临时密钥
-                if (process.env.CLOUDBASE_API_KEY && process.env.CLOUDBASE_ENV_ID) {
-                    try {
-                        const existingLoginState = await (0, auth_js_1.peekLoginState)();
-                        if (existingLoginState) {
-                            return (0, tool_result_js_1.buildJsonToolResult)({
-                                ok: true,
-                                code: "AUTH_READY",
-                                message: "当前使用 API Key 认证模式，已自动完成登录，无需手动授权。",
-                                auth_mode: "api_key",
-                                envId: process.env.CLOUDBASE_ENV_ID,
-                            });
-                        }
+    // 微信 IDE 使用票据认证，不需要登录工具
+    if (server.ide !== 'wxide') {
+        server.registerTool?.("auth", {
+            title: "CloudBase 开发阶段登录与环境",
+            description: "CloudBase（腾讯云开发）开发阶段登录与环境绑定。登录后即可访问云资源；环境(env)是云函数、数据库、静态托管等资源的隔离单元，绑定环境后其他 MCP 工具才能操作该环境。支持：查询状态、发起登录、绑定环境(set_env)、退出登录。",
+            inputSchema: {
+                action: zod_1.z
+                    .enum(authActionEnum)
+                    .optional()
+                    .describe("动作：status=查询状态，start_auth=发起登录，set_env=绑定环境(传envId)，logout=退出登录"),
+                ...(supportedAuthActions.includes("start_auth")
+                    ? {
+                        authMode: zod_1.z
+                            .enum(["device", "web"])
+                            .optional()
+                            .describe("认证模式：device=设备码授权，web=浏览器回调授权"),
+                        oauthEndpoint: zod_1.z
+                            .string()
+                            .optional()
+                            .describe("高级可选：自定义 device-code 登录 endpoint。配置后 oauthCustom 默认按 true 处理"),
+                        clientId: zod_1.z
+                            .string()
+                            .optional()
+                            .describe("高级可选：自定义 device-code 登录 client_id，不传则使用默认值"),
+                        oauthCustom: zod_1.z
+                            .boolean()
+                            .optional()
+                            .describe("高级可选：自定义 endpoint 返回格式开关。未配置 endpoint 时默认 false；配置 endpoint 后默认 true，且不能设为 false"),
                     }
-                    catch (e) {
-                        // peekLoginState 内部异常，记录后 fall through
-                        (0, logger_js_1.debug)("start_auth: peekLoginState threw", { error: e instanceof Error ? e.message : String(e) });
+                    : {}),
+                envId: zod_1.z
+                    .string()
+                    .optional()
+                    .describe("环境ID(CloudBase 环境唯一标识)，绑定后工具将操作该环境。action=set_env 时必填"),
+                ...(supportedAuthActions.includes("logout")
+                    ? {
+                        confirm: zod_1.z
+                            .literal("yes")
+                            .optional()
+                            .describe("action=logout 时确认操作，传 yes"),
+                    }
+                    : {}),
+                ...(supportedAuthActions.includes("get_temp_credentials")
+                    ? {
+                        reveal: zod_1.z
+                            .boolean()
+                            .optional()
+                            .describe("action=get_temp_credentials 时可选。true=返回明文临时密钥；默认 false 仅返回脱敏结果"),
                     }
-                    // API Key 换取失败：返回详细诊断信息
-                    // 尝试获取更详细的错误信息
-                    let diagMessage = "当前配置了 API Key 认证模式，但换取临时密钥失败。";
-                    const endpoint = process.env.CLOUDBASE_API_ENDPOINT || `https://${process.env.CLOUDBASE_ENV_ID}.ap-shanghai.tcb-api.tencentcloudapi.com`;
-                    diagMessage += `\n\n诊断信息：`;
-                    diagMessage += `\n- CLOUDBASE_ENV_ID: ${process.env.CLOUDBASE_ENV_ID}`;
-                    diagMessage += `\n- CLOUDBASE_API_KEY: ${process.env.CLOUDBASE_API_KEY.slice(0, 20)}...（已截断）`;
-                    diagMessage += `\n- Endpoint: ${endpoint}`;
-                    diagMessage += `\n\n可能原因：`;
-                    diagMessage += `\n1. API Key 已过期或被删除`;
-                    diagMessage += `\n2. Endpoint 不可达（网络/DNS 问题）`;
-                    diagMessage += `\n3. CLOUDBASE_ENV_ID 与 API Key 所属环境不匹配`;
-                    diagMessage += `\n\n建议：检查 MCP 配置中的 CLOUDBASE_API_KEY 和 CLOUDBASE_ENV_ID 环境变量是否正确。`;
+                    : {}),
+            },
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: false,
+                idempotentHint: false,
+                openWorldHint: true,
+                category: "env",
+            },
+        }, async (rawArgs) => {
+            const action = rawArgs.action ?? "status";
+            const authMode = rawArgs.authMode === "device" || rawArgs.authMode === "web"
+                ? rawArgs.authMode
+                : undefined;
+            const oauthEndpoint = normalizeOptionalToolString(rawArgs.oauthEndpoint);
+            const clientId = normalizeOptionalToolString(rawArgs.clientId);
+            const oauthCustom = normalizeOptionalToolBoolean(rawArgs.oauthCustom);
+            const envId = rawArgs.envId;
+            const confirm = rawArgs.confirm === "yes" ? "yes" : undefined;
+            const reveal = normalizeOptionalToolBoolean(rawArgs.reveal) === true;
+            const resolvedAuthOptions = resolveToolAuthOptions(server, {
+                authMode,
+                oauthEndpoint,
+                clientId,
+                oauthCustom,
+            });
+            const authConfigSummary = (0, auth_js_1.buildAuthConfigSummary)(resolvedAuthOptions);
+            let deviceAuthInfo;
+            const onDeviceCode = (info) => {
+                deviceAuthInfo = info;
+                (0, auth_js_1.setPendingAuthProgressState)(info, "device");
+                // emitDeviceAuthNotice(server, info);
+            };
+            const authChallenge = () => (0, auth_js_1.buildDeviceAuthChallengePayload)(deviceAuthInfo);
+            try {
+                if (!supportedAuthActions.includes(action)) {
                     return (0, tool_result_js_1.buildJsonToolResult)({
                         ok: false,
-                        code: "API_KEY_AUTH_FAILED",
-                        message: diagMessage,
-                        auth_mode: "api_key",
-                        envId: process.env.CLOUDBASE_ENV_ID,
-                        endpoint,
-                    });
-                }
-                const region = server.cloudBaseOptions?.region || process.env.TCB_REGION;
-                const auth = toolbox_1.AuthSupervisor.getInstance({});
-                const authFlowState = await (0, auth_js_1.getAuthProgressState)();
-                if (authFlowState.status === "PENDING" && authFlowState.authChallenge) {
-                    return (0, tool_result_js_1.buildJsonToolResult)({
-                        ok: true,
-                        code: "AUTH_PENDING",
-                        message: "设备码授权进行中，请在浏览器中打开 verification_uri 并输入 user_code 完成授权。",
-                        auth_challenge: (0, auth_js_1.buildDeviceAuthChallengePayload)(authFlowState.authChallenge),
+                        code: "NOT_SUPPORTED",
+                        message: `当前 IDE 不支持 auth(action="${action}")。`,
                         next_step: (0, tool_result_js_1.buildAuthNextStep)("status", {
                             suggestedArgs: { action: "status" },
                         }),
                     });
                 }
-                // 1. 如果已经有登录态，直接返回 AUTH_READY
-                try {
-                    const existingLoginState = await (0, auth_js_1.peekLoginState)();
-                    if (existingLoginState) {
-                        const envPreparation = await prepareAuthEnvironment({
+                if (action === "status") {
+                    const loginState = await (0, auth_js_1.peekLoginState)();
+                    const authFlowState = await (0, auth_js_1.getAuthProgressState)();
+                    // 判断是否为 API Key 模式
+                    const isApiKeyMode = !!(process.env.CLOUDBASE_API_KEY && process.env.CLOUDBASE_ENV_ID);
+                    const authStatus = loginState
+                        ? "READY"
+                        : authFlowState.status === "PENDING"
+                            ? "PENDING"
+                            : "REQUIRED";
+                    let envPreparation;
+                    const message = authStatus === "READY"
+                        ? undefined
+                        : authStatus === "PENDING"
+                            ? "设备码授权进行中，请完成浏览器授权后再次调用 auth(action=\"status\")"
+                            : isCodeBuddyIde(server)
+                                ? "当前未登录。CodeBuddy 暂不支持在 tool 内发起认证，请在外部完成认证后再次调用 auth(action=\"status\")。"
+                                : "当前未登录，请先执行 auth(action=\"start_auth\")";
+                    if (authStatus === "READY" && loginState) {
+                        envPreparation = await prepareAuthEnvironment({
                             server,
                             cloudBaseOptions,
-                            loginState: existingLoginState,
-                        });
-                        return (0, tool_result_js_1.buildJsonToolResult)({
-                            ok: true,
-                            code: "AUTH_READY",
-                            message: envPreparation.message,
-                            auth_challenge: authChallenge(),
-                            ...buildAuthEnvSetupPayload(envPreparation),
-                            next_step: envPreparation.nextStep,
+                            loginState,
                         });
                     }
-                }
-                catch {
-                    // 忽略 getLoginState 错误，继续尝试发起登录
-                }
-                const validationError = (0, auth_js_1.getAuthConfigValidationError)(resolvedAuthOptions);
-                if (validationError) {
                     return (0, tool_result_js_1.buildJsonToolResult)({
-                        ok: false,
-                        code: "INVALID_ARGS",
-                        message: validationError,
+                        ok: true,
+                        code: "STATUS",
+                        auth_status: authStatus,
+                        ...(isApiKeyMode ? { auth_mode: "api_key" } : {}),
                         auth_config: authConfigSummary,
-                        next_step: (0, tool_result_js_1.buildAuthNextStep)("start_auth", {
-                            suggestedArgs: { action: "start_auth", authMode: "device" },
-                        }),
+                        ...(envPreparation
+                            ? buildAuthEnvSetupPayload(envPreparation)
+                            : {
+                                env_status: "NONE",
+                                current_env_id: null,
+                                ...buildEnvCandidatePayload([]),
+                            }),
+                        auth_challenge: authFlowState.status === "PENDING"
+                            ? (0, auth_js_1.buildDeviceAuthChallengePayload)(authFlowState.authChallenge)
+                            : undefined,
+                        message,
+                        next_step: authStatus === "REQUIRED"
+                            ? buildAuthRequiredNextStep(server)
+                            : authStatus === "PENDING"
+                                ? (0, tool_result_js_1.buildAuthNextStep)("status", {
+                                    suggestedArgs: { action: "status" },
+                                })
+                                : envPreparation?.nextStep,
                     });
                 }
-                // 2. 设备码模式：监听到 device code 即返回 AUTH_PENDING，后续由 toolbox 异步轮询并更新本地 credential
-                const effectiveMode = resolvedAuthOptions.authMode;
-                if (effectiveMode === "device") {
-                    let resolveCode;
-                    let rejectCode;
-                    const codeReady = new Promise((resolve, reject) => {
-                        resolveCode = resolve;
-                        rejectCode = reject;
-                    });
-                    const deviceOnCode = (info) => {
-                        onDeviceCode(info);
-                        if (resolveCode) {
-                            resolveCode();
-                        }
-                    };
-                    try {
-                        // 启动 Device Flow，全流程由 toolbox 负责轮询和写入 credential，这里不等待完成
-                        auth
-                            .loginByWebAuth({
-                            flow: "device",
-                            ...(resolvedAuthOptions.clientId
-                                ? { client_id: resolvedAuthOptions.clientId }
-                                : {}),
-                            ...(resolvedAuthOptions.oauthEndpoint
-                                ? { getOAuthEndpoint: () => resolvedAuthOptions.oauthEndpoint }
-                                : {}),
-                            ...(resolvedAuthOptions.oauthCustom
-                                ? { custom: true }
-                                : {}),
-                            onDeviceCode: deviceOnCode,
-                        })
-                            .then(() => {
-                            (0, auth_js_1.resolveAuthProgressState)();
-                        })
-                            .catch((err) => {
-                            (0, auth_js_1.rejectAuthProgressState)(err);
-                            // 如果在拿到 device code 之前就失败，则唤醒当前调用并返回错误
-                            if (!deviceAuthInfo && rejectCode) {
-                                rejectCode(err);
+                if (action === "start_auth") {
+                    // API Key 模式：尝试换取临时密钥
+                    if (process.env.CLOUDBASE_API_KEY && process.env.CLOUDBASE_ENV_ID) {
+                        try {
+                            const existingLoginState = await (0, auth_js_1.peekLoginState)();
+                            if (existingLoginState) {
+                                return (0, tool_result_js_1.buildJsonToolResult)({
+                                    ok: true,
+                                    code: "AUTH_READY",
+                                    message: "当前使用 API Key 认证模式，已自动完成登录，无需手动授权。",
+                                    auth_mode: "api_key",
+                                    envId: process.env.CLOUDBASE_ENV_ID,
+                                });
                             }
+                        }
+                        catch (e) {
+                            // peekLoginState 内部异常，记录后 fall through
+                            (0, logger_js_1.debug)("start_auth: peekLoginState threw", { error: e instanceof Error ? e.message : String(e) });
+                        }
+                        // API Key 换取失败：返回详细诊断信息
+                        // 尝试获取更详细的错误信息
+                        let diagMessage = "当前配置了 API Key 认证模式，但换取临时密钥失败。";
+                        const endpoint = process.env.CLOUDBASE_API_ENDPOINT || `https://${process.env.CLOUDBASE_ENV_ID}.ap-shanghai.tcb-api.tencentcloudapi.com`;
+                        diagMessage += `\n\n诊断信息：`;
+                        diagMessage += `\n- CLOUDBASE_ENV_ID: ${process.env.CLOUDBASE_ENV_ID}`;
+                        diagMessage += `\n- CLOUDBASE_API_KEY: ${process.env.CLOUDBASE_API_KEY.slice(0, 20)}...（已截断）`;
+                        diagMessage += `\n- Endpoint: ${endpoint}`;
+                        diagMessage += `\n\n可能原因：`;
+                        diagMessage += `\n1. API Key 已过期或被删除`;
+                        diagMessage += `\n2. Endpoint 不可达（网络/DNS 问题）`;
+                        diagMessage += `\n3. CLOUDBASE_ENV_ID 与 API Key 所属环境不匹配`;
+                        diagMessage += `\n\n建议：检查 MCP 配置中的 CLOUDBASE_API_KEY 和 CLOUDBASE_ENV_ID 环境变量是否正确。`;
+                        return (0, tool_result_js_1.buildJsonToolResult)({
+                            ok: false,
+                            code: "API_KEY_AUTH_FAILED",
+                            message: diagMessage,
+                            auth_mode: "api_key",
+                            envId: process.env.CLOUDBASE_ENV_ID,
+                            endpoint,
                         });
                     }
-                    catch (err) {
-                        if (rejectCode) {
-                            rejectCode(err);
-                        }
+                    const region = server.cloudBaseOptions?.region || process.env.TCB_REGION;
+                    const auth = toolbox_1.AuthSupervisor.getInstance({});
+                    const authFlowState = await (0, auth_js_1.getAuthProgressState)();
+                    if (authFlowState.status === "PENDING" && authFlowState.authChallenge) {
+                        return (0, tool_result_js_1.buildJsonToolResult)({
+                            ok: true,
+                            code: "AUTH_PENDING",
+                            message: "设备码授权进行中，请在浏览器中打开 verification_uri 并输入 user_code 完成授权。",
+                            auth_challenge: (0, auth_js_1.buildDeviceAuthChallengePayload)(authFlowState.authChallenge),
+                            next_step: (0, tool_result_js_1.buildAuthNextStep)("status", {
+                                suggestedArgs: { action: "status" },
+                            }),
+                        });
                     }
+                    // 1. 如果已经有登录态，直接返回 AUTH_READY
                     try {
-                        await codeReady;
+                        const existingLoginState = await (0, auth_js_1.peekLoginState)();
+                        if (existingLoginState) {
+                            const envPreparation = await prepareAuthEnvironment({
+                                server,
+                                cloudBaseOptions,
+                                loginState: existingLoginState,
+                            });
+                            return (0, tool_result_js_1.buildJsonToolResult)({
+                                ok: true,
+                                code: "AUTH_READY",
+                                message: envPreparation.message,
+                                auth_challenge: authChallenge(),
+                                ...buildAuthEnvSetupPayload(envPreparation),
+                                next_step: envPreparation.nextStep,
+                            });
+                        }
                     }
-                    catch (err) {
-                        const message = err instanceof Error ? err.message : String(err ?? "unknown error");
+                    catch {
+                        // 忽略 getLoginState 错误，继续尝试发起登录
+                    }
+                    const validationError = (0, auth_js_1.getAuthConfigValidationError)(resolvedAuthOptions);
+                    if (validationError) {
                         return (0, tool_result_js_1.buildJsonToolResult)({
                             ok: false,
-                            code: "AUTH_REQUIRED",
-                            message: `设备码登录初始化失败: ${message}`,
+                            code: "INVALID_ARGS",
+                            message: validationError,
+                            auth_config: authConfigSummary,
                             next_step: (0, tool_result_js_1.buildAuthNextStep)("start_auth", {
                                 suggestedArgs: { action: "start_auth", authMode: "device" },
                             }),
                         });
                     }
-                    if (!deviceAuthInfo) {
+                    // 2. 设备码模式：监听到 device code 即返回 AUTH_PENDING，后续由 toolbox 异步轮询并更新本地 credential
+                    const effectiveMode = resolvedAuthOptions.authMode;
+                    if (effectiveMode === "device") {
+                        let resolveCode;
+                        let rejectCode;
+                        const codeReady = new Promise((resolve, reject) => {
+                            resolveCode = resolve;
+                            rejectCode = reject;
+                        });
+                        const deviceOnCode = (info) => {
+                            onDeviceCode(info);
+                            if (resolveCode) {
+                                resolveCode();
+                            }
+                        };
+                        try {
+                            // 启动 Device Flow，全流程由 toolbox 负责轮询和写入 credential，这里不等待完成
+                            auth
+                                .loginByWebAuth({
+                                flow: "device",
+                                ...(resolvedAuthOptions.clientId
+                                    ? { client_id: resolvedAuthOptions.clientId }
+                                    : {}),
+                                ...(resolvedAuthOptions.oauthEndpoint
+                                    ? { getOAuthEndpoint: () => resolvedAuthOptions.oauthEndpoint }
+                                    : {}),
+                                ...(resolvedAuthOptions.oauthCustom
+                                    ? { custom: true }
+                                    : {}),
+                                onDeviceCode: deviceOnCode,
+                            })
+                                .then(() => {
+                                (0, auth_js_1.resolveAuthProgressState)();
+                            })
+                                .catch((err) => {
+                                (0, auth_js_1.rejectAuthProgressState)(err);
+                                // 如果在拿到 device code 之前就失败，则唤醒当前调用并返回错误
+                                if (!deviceAuthInfo && rejectCode) {
+                                    rejectCode(err);
+                                }
+                            });
+                        }
+                        catch (err) {
+                            if (rejectCode) {
+                                rejectCode(err);
+                            }
+                        }
+                        try {
+                            await codeReady;
+                        }
+                        catch (err) {
+                            const message = err instanceof Error ? err.message : String(err ?? "unknown error");
+                            return (0, tool_result_js_1.buildJsonToolResult)({
+                                ok: false,
+                                code: "AUTH_REQUIRED",
+                                message: `设备码登录初始化失败: ${message}`,
+                                next_step: (0, tool_result_js_1.buildAuthNextStep)("start_auth", {
+                                    suggestedArgs: { action: "start_auth", authMode: "device" },
+                                }),
+                            });
+                        }
+                        if (!deviceAuthInfo) {
+                            return (0, tool_result_js_1.buildJsonToolResult)({
+                                ok: false,
+                                code: "AUTH_REQUIRED",
+                                message: "未获取到设备码信息，请重试设备码登录",
+                                next_step: (0, tool_result_js_1.buildAuthNextStep)("start_auth", {
+                                    suggestedArgs: { action: "start_auth", authMode: "device" },
+                                }),
+                            });
+                        }
+                        const envCandidates = await fetchAvailableEnvCandidates(cloudBaseOptions, server);
+                        return (0, tool_result_js_1.buildJsonToolResult)({
+                            ok: true,
+                            code: "AUTH_PENDING",
+                            message: "已发起设备码登录，请在浏览器中打开 verification_uri 并输入 user_code 完成授权。授权完成后请再次调用 auth(action=\"status\")。",
+                            auth_challenge: authChallenge(),
+                            ...buildEnvCandidatePayload(envCandidates),
+                            next_step: (0, tool_result_js_1.buildAuthNextStep)("status", {
+                                suggestedArgs: { action: "status" },
+                            }),
+                        });
+                    }
+                    // 3. 非 Device Flow（显式 web 模式）仍然使用 getLoginState 阻塞等待
+                    const loginState = await (0, auth_js_1.ensureLogin)({
+                        region,
+                        authMode: effectiveMode,
+                        clientId: resolvedAuthOptions.clientId,
+                        oauthEndpoint: resolvedAuthOptions.oauthEndpoint,
+                        oauthCustom: resolvedAuthOptions.oauthCustom,
+                    });
+                    if (!loginState) {
                         return (0, tool_result_js_1.buildJsonToolResult)({
                             ok: false,
                             code: "AUTH_REQUIRED",
-                            message: "未获取到设备码信息，请重试设备码登录",
+                            message: "未获取到登录态，请先完成认证",
                             next_step: (0, tool_result_js_1.buildAuthNextStep)("start_auth", {
-                                suggestedArgs: { action: "start_auth", authMode: "device" },
+                                suggestedArgs: { action: "start_auth", authMode: effectiveMode },
                             }),
                         });
                     }
-                    const envCandidates = await fetchAvailableEnvCandidates(cloudBaseOptions, server);
+                    const envPreparation = await prepareAuthEnvironment({
+                        server,
+                        cloudBaseOptions,
+                        loginState,
+                    });
                     return (0, tool_result_js_1.buildJsonToolResult)({
                         ok: true,
-                        code: "AUTH_PENDING",
-                        message: "已发起设备码登录，请在浏览器中打开 verification_uri 并输入 user_code 完成授权。授权完成后请再次调用 auth(action=\"status\")。",
+                        code: "AUTH_READY",
+                        message: envPreparation.message,
                         auth_challenge: authChallenge(),
-                        ...buildEnvCandidatePayload(envCandidates),
-                        next_step: (0, tool_result_js_1.buildAuthNextStep)("status", {
-                            suggestedArgs: { action: "status" },
-                        }),
+                        ...buildAuthEnvSetupPayload(envPreparation),
+                        next_step: envPreparation.nextStep,
                     });
                 }
-                // 3. 非 Device Flow（显式 web 模式）仍然使用 getLoginState 阻塞等待
-                const loginState = await (0, auth_js_1.ensureLogin)({
-                    region,
-                    authMode: effectiveMode,
-                    clientId: resolvedAuthOptions.clientId,
-                    oauthEndpoint: resolvedAuthOptions.oauthEndpoint,
-                    oauthCustom: resolvedAuthOptions.oauthCustom,
-                });
-                if (!loginState) {
-                    return (0, tool_result_js_1.buildJsonToolResult)({
-                        ok: false,
-                        code: "AUTH_REQUIRED",
-                        message: "未获取到登录态，请先完成认证",
-                        next_step: (0, tool_result_js_1.buildAuthNextStep)("start_auth", {
-                            suggestedArgs: { action: "start_auth", authMode: effectiveMode },
-                        }),
-                    });
-                }
-                const envPreparation = await prepareAuthEnvironment({
-                    server,
-                    cloudBaseOptions,
-                    loginState,
-                });
-                return (0, tool_result_js_1.buildJsonToolResult)({
-                    ok: true,
-                    code: "AUTH_READY",
-                    message: envPreparation.message,
-                    auth_challenge: authChallenge(),
-                    ...buildAuthEnvSetupPayload(envPreparation),
-                    next_step: envPreparation.nextStep,
-                });
-            }
-            if (action === "set_env") {
-                const loginState = await (0, auth_js_1.peekLoginState)();
-                if (!loginState) {
-                    return (0, tool_result_js_1.buildJsonToolResult)({
-                        ok: false,
-                        code: "AUTH_REQUIRED",
-                        message: isCodeBuddyIde(server)
-                            ? "当前未登录。CodeBuddy 暂不支持在 tool 内发起认证，请在外部完成认证后再次调用 auth(action=\"status\")。"
-                            : "当前未登录，请先执行 auth(action=\"start_auth\")。",
-                        next_step: buildAuthRequiredNextStep(server),
-                    });
-                }
-                const envCandidates = await fetchAvailableEnvCandidates(cloudBaseOptions, server);
-                if (!envId) {
-                    return (0, tool_result_js_1.buildJsonToolResult)({
-                        ok: false,
-                        code: "INVALID_ARGS",
-                        message: "action=set_env 时必须提供 envId",
-                        ...buildEnvCandidatePayload(envCandidates),
-                        next_step: buildSetEnvNextStep(envCandidates),
-                    });
-                }
-                const target = envCandidates.find((item) => item.envId === envId);
-                if (envCandidates.length > 0 && !target) {
+                if (action === "set_env") {
+                    const loginState = await (0, auth_js_1.peekLoginState)();
+                    if (!loginState) {
+                        return (0, tool_result_js_1.buildJsonToolResult)({
+                            ok: false,
+                            code: "AUTH_REQUIRED",
+                            message: isCodeBuddyIde(server)
+                                ? "当前未登录。CodeBuddy 暂不支持在 tool 内发起认证，请在外部完成认证后再次调用 auth(action=\"status\")。"
+                                : "当前未登录，请先执行 auth(action=\"start_auth\")。",
+                            next_step: buildAuthRequiredNextStep(server),
+                        });
+                    }
+                    const envCandidates = await fetchAvailableEnvCandidates(cloudBaseOptions, server);
+                    if (!envId) {
+                        return (0, tool_result_js_1.buildJsonToolResult)({
+                            ok: false,
+                            code: "INVALID_ARGS",
+                            message: "action=set_env 时必须提供 envId",
+                            ...buildEnvCandidatePayload(envCandidates),
+                            next_step: buildSetEnvNextStep(envCandidates),
+                        });
+                    }
+                    const target = envCandidates.find((item) => item.envId === envId);
+                    if (envCandidates.length > 0 && !target) {
+                        return (0, tool_result_js_1.buildJsonToolResult)({
+                            ok: false,
+                            code: "INVALID_ARGS",
+                            message: `未找到环境: ${envId}`,
+                            ...buildEnvCandidatePayload(envCandidates),
+                            next_step: buildSetEnvNextStep(envCandidates),
+                        });
+                    }
+                    await cloudbase_manager_js_1.envManager.setEnvId(envId);
                     return (0, tool_result_js_1.buildJsonToolResult)({
-                        ok: false,
-                        code: "INVALID_ARGS",
-                        message: `未找到环境: ${envId}`,
-                        ...buildEnvCandidatePayload(envCandidates),
-                        next_step: buildSetEnvNextStep(envCandidates),
+                        ok: true,
+                        code: "ENV_READY",
+                        message: `环境设置成功，当前环境: ${envId}`,
+                        current_env_id: envId,
                     });
                 }
-                await cloudbase_manager_js_1.envManager.setEnvId(envId);
-                return (0, tool_result_js_1.buildJsonToolResult)({
-                    ok: true,
-                    code: "ENV_READY",
-                    message: `环境设置成功，当前环境: ${envId}`,
-                    current_env_id: envId,
-                });
-            }
-            if (action === "logout") {
-                // API Key 模式下不允许 logout
-                if (process.env.CLOUDBASE_API_KEY && process.env.CLOUDBASE_ENV_ID) {
+                if (action === "logout") {
+                    // API Key 模式下不允许 logout
+                    if (process.env.CLOUDBASE_API_KEY && process.env.CLOUDBASE_ENV_ID) {
+                        return (0, tool_result_js_1.buildJsonToolResult)({
+                            ok: false,
+                            code: "LOGOUT_NOT_ALLOWED",
+                            message: "当前使用 API Key 认证模式，不支持退出登录。如需切换认证方式，请移除 CLOUDBASE_API_KEY 环境变量后重启。",
+                            auth_mode: "api_key",
+                        });
+                    }
+                    if (confirm !== "yes") {
+                        return (0, tool_result_js_1.buildJsonToolResult)({
+                            ok: false,
+                            code: "INVALID_ARGS",
+                            message: "action=logout 时必须传 confirm=\"yes\"",
+                            next_step: (0, tool_result_js_1.buildAuthNextStep)("logout", {
+                                suggestedArgs: { action: "logout", confirm: "yes" },
+                            }),
+                        });
+                    }
+                    await (0, auth_js_1.logout)();
+                    (0, cloudbase_manager_js_1.resetCloudBaseManagerCache)();
                     return (0, tool_result_js_1.buildJsonToolResult)({
-                        ok: false,
-                        code: "LOGOUT_NOT_ALLOWED",
-                        message: "当前使用 API Key 认证模式，不支持退出登录。如需切换认证方式，请移除 CLOUDBASE_API_KEY 环境变量后重启。",
-                        auth_mode: "api_key",
+                        ok: true,
+                        code: "LOGGED_OUT",
+                        message: "✅ 已退出登录",
                     });
                 }
-                if (confirm !== "yes") {
+                if (action === "get_temp_credentials") {
+                    const loginState = (await (0, auth_js_1.peekLoginState)());
+                    if (!loginState) {
+                        return (0, tool_result_js_1.buildJsonToolResult)({
+                            ok: false,
+                            code: "AUTH_REQUIRED",
+                            message: "当前未登录，请先完成管理端认证后再获取临时密钥。",
+                            next_step: buildAuthRequiredNextStep(server),
+                        });
+                    }
+                    if (confirm !== "yes") {
+                        return (0, tool_result_js_1.buildJsonToolResult)({
+                            ok: false,
+                            code: "INVALID_ARGS",
+                            message: "action=get_temp_credentials 时必须显式传 confirm=\"yes\"，以确认你要导出当前管理端临时密钥。",
+                            next_step: (0, tool_result_js_1.buildAuthNextStep)("get_temp_credentials", {
+                                suggestedArgs: { action: "get_temp_credentials", confirm: "yes" },
+                            }),
+                        });
+                    }
+                    if (!isTemporaryCredentialLoginState(loginState)) {
+                        return (0, tool_result_js_1.buildJsonToolResult)({
+                            ok: false,
+                            code: "UNSUPPORTED_CREDENTIAL_TYPE",
+                            message: "当前登录态不是可导出的临时密钥。仅支持通过 Web / device 登录得到的临时密钥，永久密钥登录不允许导出。",
+                        });
+                    }
+                    const secretId = normalizeOptionalToolString(loginState.secretId);
+                    const secretKey = normalizeOptionalToolString(loginState.secretKey);
+                    const token = normalizeOptionalToolString(loginState.token);
+                    if (!secretId || !secretKey || !token) {
+                        return (0, tool_result_js_1.buildJsonToolResult)({
+                            ok: false,
+                            code: "INTERNAL_ERROR",
+                            message: "当前登录态缺少完整的临时密钥字段，请重新登录后再试。",
+                        });
+                    }
                     return (0, tool_result_js_1.buildJsonToolResult)({
-                        ok: false,
-                        code: "INVALID_ARGS",
-                        message: "action=logout 时必须传 confirm=\"yes\"",
-                        next_step: (0, tool_result_js_1.buildAuthNextStep)("logout", {
-                            suggestedArgs: { action: "logout", confirm: "yes" },
-                        }),
+                        ok: true,
+                        code: "TEMP_CREDENTIALS_READY",
+                        message: reveal
+                            ? "当前管理端临时密钥已准备好，请注意避免泄露。"
+                            : "当前管理端临时密钥已准备好，默认仅返回脱敏结果。",
+                        env_id: normalizeOptionalToolString(loginState.envId) ?? null,
+                        credentials: {
+                            secretId: reveal ? secretId : maskSensitiveValue(secretId),
+                            secretKey: reveal ? secretKey : maskSensitiveValue(secretKey),
+                            token: reveal ? token : maskSensitiveValue(token),
+                            masked: !reveal,
+                        },
                     });
                 }
-                await (0, auth_js_1.logout)();
-                (0, cloudbase_manager_js_1.resetCloudBaseManagerCache)();
                 return (0, tool_result_js_1.buildJsonToolResult)({
-                    ok: true,
-                    code: "LOGGED_OUT",
-                    message: "✅ 已退出登录",
+                    ok: false,
+                    code: "NOT_SUPPORTED",
+                    message: `不支持的 auth action: ${action}`,
+                    next_step: (0, tool_result_js_1.buildAuthNextStep)("status", {
+                        suggestedArgs: { action: "status" },
+                    }),
                 });
             }
-            if (action === "get_temp_credentials") {
-                const loginState = (await (0, auth_js_1.peekLoginState)());
-                if (!loginState) {
-                    return (0, tool_result_js_1.buildJsonToolResult)({
-                        ok: false,
-                        code: "AUTH_REQUIRED",
-                        message: "当前未登录，请先完成管理端认证后再获取临时密钥。",
-                        next_step: buildAuthRequiredNextStep(server),
-                    });
-                }
-                if (confirm !== "yes") {
-                    return (0, tool_result_js_1.buildJsonToolResult)({
-                        ok: false,
-                        code: "INVALID_ARGS",
-                        message: "action=get_temp_credentials 时必须显式传 confirm=\"yes\"，以确认你要导出当前管理端临时密钥。",
-                        next_step: (0, tool_result_js_1.buildAuthNextStep)("get_temp_credentials", {
-                            suggestedArgs: { action: "get_temp_credentials", confirm: "yes" },
-                        }),
-                    });
-                }
-                if (!isTemporaryCredentialLoginState(loginState)) {
-                    return (0, tool_result_js_1.buildJsonToolResult)({
-                        ok: false,
-                        code: "UNSUPPORTED_CREDENTIAL_TYPE",
-                        message: "当前登录态不是可导出的临时密钥。仅支持通过 Web / device 登录得到的临时密钥，永久密钥登录不允许导出。",
-                    });
-                }
-                const secretId = normalizeOptionalToolString(loginState.secretId);
-                const secretKey = normalizeOptionalToolString(loginState.secretKey);
-                const token = normalizeOptionalToolString(loginState.token);
-                if (!secretId || !secretKey || !token) {
-                    return (0, tool_result_js_1.buildJsonToolResult)({
-                        ok: false,
-                        code: "INTERNAL_ERROR",
-                        message: "当前登录态缺少完整的临时密钥字段，请重新登录后再试。",
-                    });
-                }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
                 return (0, tool_result_js_1.buildJsonToolResult)({
-                    ok: true,
-                    code: "TEMP_CREDENTIALS_READY",
-                    message: reveal
-                        ? "当前管理端临时密钥已准备好，请注意避免泄露。"
-                        : "当前管理端临时密钥已准备好，默认仅返回脱敏结果。",
-                    env_id: normalizeOptionalToolString(loginState.envId) ?? null,
-                    credentials: {
-                        secretId: reveal ? secretId : maskSensitiveValue(secretId),
-                        secretKey: reveal ? secretKey : maskSensitiveValue(secretKey),
-                        token: reveal ? token : maskSensitiveValue(token),
-                        masked: !reveal,
-                    },
+                    ok: false,
+                    code: "INTERNAL_ERROR",
+                    message: `auth 执行失败: ${message}`,
+                    auth_challenge: authChallenge(),
+                    next_step: (0, tool_result_js_1.buildAuthNextStep)("status", {
+                        suggestedArgs: { action: "status" },
+                    }),
                 });
             }
-            return (0, tool_result_js_1.buildJsonToolResult)({
-                ok: false,
-                code: "NOT_SUPPORTED",
-                message: `不支持的 auth action: ${action}`,
-                next_step: (0, tool_result_js_1.buildAuthNextStep)("status", {
-                    suggestedArgs: { action: "status" },
-                }),
-            });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return (0, tool_result_js_1.buildJsonToolResult)({
-                ok: false,
-                code: "INTERNAL_ERROR",
-                message: `auth 执行失败: ${message}`,
-                auth_challenge: authChallenge(),
-                next_step: (0, tool_result_js_1.buildAuthNextStep)("status", {
-                    suggestedArgs: { action: "status" },
-                }),
-            });
-        }
-    });
-    // envQuery - 环境查询（合并 listEnvs + getEnvInfo + getEnvAuthDomains）
-    server.registerTool?.("envQuery", {
-        title: "CloudBase 环境查询",
-        description: "查询 CloudBase 环境相关信息，支持查询环境列表、指定环境详情和安全域名。（原工具名：listEnvs/getEnvInfo/getEnvAuthDomains，为兼容旧AI规则可继续使用这些名称）当 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 等计费字段）。",
-        inputSchema: {
-            action: zod_1.z
-                .enum(["list", "info", "domains"])
-                .describe("查询类型：list=环境列表/摘要筛选（按 DescribeEnvs 语义筛选，支持通过 envId 筛选，返回 EnvId、Alias、Status、EnvType、Region、PackageId、PackageName、IsDefault，不支持 expiry），info=指定环境的详细信息（必须传入 envId，返回资源字段和计费信息），domains=安全域名列表"),
-            alias: zod_1.z.string().optional().describe("按环境别名筛选。action=list 时可选"),
-            aliasExact: zod_1.z.boolean().optional().describe("按环境别名精确筛选。action=list 时可选；与 alias 配合使用"),
-            envId: zod_1.z.string().optional().describe("按环境 ID 筛选。action=list 时可选（仅按 DescribeEnvs 语义做筛选，仍返回摘要）；action=info 时必填（返回该环境的详细信息，包含资源字段和计费信息）。如果任务已经给出了明确的 EnvId 并要求查询详情，请直接使用 action=info + envId，而不是 action=list"),
-            limit: zod_1.z.number().int().positive().optional().describe("返回数量上限。action=list 时可选"),
-            offset: zod_1.z.number().int().min(0).optional().describe("分页偏移。action=list 时可选"),
-            fields: zod_1.z
-                .array(zod_1.z.enum(DEFAULT_ENV_FIELDS))
-                .optional()
-                .describe("返回字段白名单。仅支持 EnvId、Alias、Status、EnvType、Region、PackageId、PackageName、IsDefault。action=list 时可选"),
-        },
-        annotations: {
-            readOnlyHint: true,
-            openWorldHint: true,
-            category: "env",
-        },
-    }, async ({ action, alias, aliasExact, envId, limit, offset, fields, }) => {
+        });
+    } // end: wxide guard for auth tool
+    // queryEnv - 环境查询（合并 listEnvs + getEnvInfo + getEnvAuthDomains）
+    const queryEnvHandler = async ({ action, alias, aliasExact, envId, limit, offset, fields, }) => {
         try {
             let result;
             switch (action) {
@@ -2889,7 +2870,8 @@ function registerEnvTools(server) {
                         // 当环境变量设置了 CLOUDBASE_ENV_ID 时（如 API Key 模式），
                         // 避免调用 DescribeEnvs（临时密钥可能不支持该接口），
                         // 改为通过 DescribeEnvInfo 获取单环境信息
-                        const envIdFromEnv = process.env.CLOUDBASE_ENV_ID;
+                        // 注意：requestFn 模式（如微信 IDE）使用 DescribeEnvs，不走此分支
+                        const envIdFromEnv = !cloudBaseOptions?.requestFn && process.env.CLOUDBASE_ENV_ID;
                         if (envIdFromEnv) {
                             try {
                                 const envInfo = await cloudbaseList.env.describeEnvInfo({ EnvId: envIdFromEnv });
@@ -3056,61 +3038,91 @@ function registerEnvTools(server) {
                 ],
             };
         }
-    });
-    // envDomainManagement - 环境域名管理（合并 createEnvDomain + deleteEnvDomain）
-    server.registerTool?.("envDomainManagement", {
-        title: "CloudBase 环境域名管理（安全域名 / CORS 白名单）",
-        description: "管理 CloudBase 环境的安全域名（安全域名 / CORS 白名单），支持添加和删除操作。（原工具名：createEnvDomain/deleteEnvDomain，为兼容旧AI规则可继续使用这些名称）当浏览器 Web 应用需要从本地 Vite / dev server 直接访问 CloudBase 资源时，应先用 envQuery(action=domains) 检查当前实际浏览器 origin 对应的 host:port 是否已在白名单中，再按该实际值添加。新增或删除后通常需要继续轮询 envQuery(action=domains) 确认状态收敛；安全域名一般约 10 分钟生效。⚠️ 重要：此工具仅用于 CORS/请求来源验证，不涉及 SSL 证书。如需绑定自定义域名供公网 HTTPS 访问，请使用 manageGateway(action=\"bindCustomDomain\")。",
+    };
+    // 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 等计费字段）。",
         inputSchema: {
             action: zod_1.z
-                .enum(["create", "delete"])
-                .describe("操作类型：create=添加安全域名，delete=删除安全域名"),
-            domains: zod_1.z.array(zod_1.z.string()).describe("安全域名数组（格式：host:port，例如 localhost:5173 或 127.0.0.1:4173）。注意：不是自定义域名，不需要证书。"),
+                .enum(["list", "info", "domains"])
+                .describe("查询类型：list=环境列表/摘要筛选（按 DescribeEnvs 语义筛选，支持通过 envId 筛选，返回 EnvId、Alias、Status、EnvType、Region、PackageId、PackageName、IsDefault，不支持 expiry），info=指定环境的详细信息（必须传入 envId，返回资源字段和计费信息），domains=安全域名列表"),
+            alias: zod_1.z.string().optional().describe("按环境别名筛选。action=list 时可选"),
+            aliasExact: zod_1.z.boolean().optional().describe("按环境别名精确筛选。action=list 时可选；与 alias 配合使用"),
+            envId: zod_1.z.string().optional().describe("按环境 ID 筛选。action=list 时可选（仅按 DescribeEnvs 语义做筛选，仍返回摘要）；action=info 时必填（返回该环境的详细信息，包含资源字段和计费信息）。如果任务已经给出了明确的 EnvId 并要求查询详情，请直接使用 action=info + envId，而不是 action=list"),
+            limit: zod_1.z.number().int().positive().optional().describe("返回数量上限。action=list 时可选"),
+            offset: zod_1.z.number().int().min(0).optional().describe("分页偏移。action=list 时可选"),
+            fields: zod_1.z
+                .array(zod_1.z.enum(DEFAULT_ENV_FIELDS))
+                .optional()
+                .describe("返回字段白名单。仅支持 EnvId、Alias、Status、EnvType、Region、PackageId、PackageName、IsDefault。action=list 时可选"),
         },
         annotations: {
-            readOnlyHint: false,
-            destructiveHint: false, // 注意：delete操作虽然是破坏性的，但这里采用较宽松的标注
-            idempotentHint: false,
+            readOnlyHint: true,
             openWorldHint: true,
             category: "env",
         },
-    }, async ({ action, domains, }) => {
-        try {
-            const cloudbase = await getManager();
-            let result;
-            switch (action) {
-                case "create":
-                    result = await cloudbase.env.createEnvDomain(domains);
-                    (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-                    break;
-                case "delete":
-                    result = await cloudbase.env.deleteEnvDomain(domains);
-                    (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-                    break;
-                default:
-                    throw new Error(`不支持的操作类型: ${action}`);
+    };
+    server.registerTool?.("queryEnv", queryEnvToolSchema, queryEnvHandler);
+    // 向后兼容：envQuery 作为 queryEnv 的别名注册
+    server.registerTool?.("envQuery", queryEnvToolSchema, queryEnvHandler);
+    // envDomainManagement - 环境域名管理（合并 createEnvDomain + deleteEnvDomain）
+    // 微信 IDE 场景不需要域名管理
+    if (server.ide !== 'wxide') {
+        server.registerTool?.("envDomainManagement", {
+            title: "CloudBase 环境域名管理（安全域名 / CORS 白名单）",
+            description: "管理 CloudBase 环境的安全域名（安全域名 / CORS 白名单），支持添加和删除操作。（原工具名：createEnvDomain/deleteEnvDomain，为兼容旧AI规则可继续使用这些名称）当浏览器 Web 应用需要从本地 Vite / dev server 直接访问 CloudBase 资源时，应先用 queryEnv(action=domains) 检查当前实际浏览器 origin 对应的 host:port 是否已在白名单中，再按该实际值添加。新增或删除后通常需要继续轮询 queryEnv(action=domains) 确认状态收敛；安全域名一般约 10 分钟生效。⚠️ 重要：此工具仅用于 CORS/请求来源验证，不涉及 SSL 证书。如需绑定自定义域名供公网 HTTPS 访问，请使用 manageGateway(action=\"bindCustomDomain\")。",
+            inputSchema: {
+                action: zod_1.z
+                    .enum(["create", "delete"])
+                    .describe("操作类型：create=添加安全域名，delete=删除安全域名"),
+                domains: zod_1.z.array(zod_1.z.string()).describe("安全域名数组（格式：host:port，例如 localhost:5173 或 127.0.0.1:4173）。注意：不是自定义域名，不需要证书。"),
+            },
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: false, // 注意：delete操作虽然是破坏性的，但这里采用较宽松的标注
+                idempotentHint: false,
+                openWorldHint: true,
+                category: "env",
+            },
+        }, async ({ action, domains, }) => {
+            try {
+                const cloudbase = await getManager();
+                let result;
+                switch (action) {
+                    case "create":
+                        result = await cloudbase.env.createEnvDomain(domains);
+                        (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+                        break;
+                    case "delete":
+                        result = await cloudbase.env.deleteEnvDomain(domains);
+                        (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+                        break;
+                    default:
+                        throw new Error(`不支持的操作类型: ${action}`);
+                }
+                return (0, tool_result_js_1.buildJsonToolResult)(buildEnvDomainManagementResult({
+                    action,
+                    domains,
+                    result,
+                }));
             }
-            return (0, tool_result_js_1.buildJsonToolResult)(buildEnvDomainManagementResult({
-                action,
-                domains,
-                result,
-            }));
-        }
-        catch (error) {
-            const toolPayloadResult = (0, tool_result_js_1.toolPayloadErrorToResult)(error);
-            if (toolPayloadResult) {
-                return toolPayloadResult;
+            catch (error) {
+                const toolPayloadResult = (0, tool_result_js_1.toolPayloadErrorToResult)(error);
+                if (toolPayloadResult) {
+                    return toolPayloadResult;
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `域名管理操作失败: ${error instanceof Error ? error.message : String(error)}`,
+                        },
+                    ],
+                };
             }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `域名管理操作失败: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
-        }
-    });
+        });
+    } // end: wxide guard for envDomainManagement
 }
 
 
@@ -24985,8 +24997,9 @@ async function getDatabaseInstanceId(options) {
 async function getCloudBaseManager(options = {}) {
     const { requireEnvId = true, cloudBaseOptions, authStrategy = 'fail_fast', } = options;
     const hasDirectCredentials = !!(cloudBaseOptions?.secretId && cloudBaseOptions?.secretKey);
-    // 如果传入了完整凭据，优先使用显式 CloudBase 配置
-    if (cloudBaseOptions && hasDirectCredentials) {
+    const hasRequestFn = !!(cloudBaseOptions?.requestFn);
+    // 如果传入了完整凭据或 requestFn，优先使用显式 CloudBase 配置
+    if (cloudBaseOptions && (hasDirectCredentials || hasRequestFn)) {
         let resolvedEnvId = cloudBaseOptions.envId;
         if (requireEnvId && !resolvedEnvId) {
             const envCandidates = await listAvailableEnvCandidates({ cloudBaseOptions });
@@ -40929,8 +40942,8 @@ function registerSQLDatabaseTools(server) {
         server,
     };
     server.registerTool?.(QUERY_SQL_DATABASE, {
-        title: "Query SQL database state or execute read-only SQL",
-        description: "Query SQL database information. Supports read-only SQL execution, MySQL provisioning result lookup, MySQL task status lookup, and current instance context discovery.",
+        title: "查询 CloudBase MySQL 数据库状态或执行只读 SQL",
+        description: "查询 CloudBase MySQL 数据库信息。支持执行只读 SQL、查询 MySQL 开通结果、查询 MySQL 任务状态，以及获取当前实例上下文信息。",
         inputSchema: {
             action: zod_1.z
                 .enum(QUERY_ACTIONS)
@@ -40972,8 +40985,8 @@ function registerSQLDatabaseTools(server) {
         }
     });
     server.registerTool?.(MANAGE_SQL_DATABASE, {
-        title: "Manage SQL database lifecycle or execute write SQL",
-        description: "Manage SQL database resources. Supports MySQL provisioning, MySQL destruction, write SQL/DDL execution, and schema initialization. IMPORTANT: MySQL must be provisioned first (action=provisionMySQL with confirm=true) before any runStatement or initializeSchema call. If MySQL is not yet provisioned, the tool will return MYSQL_NOT_CREATED with a nextAction to provision first.",
+        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: {
             action: zod_1.z
                 .enum(MANAGE_ACTIONS)
@@ -55763,7 +55776,7 @@ if (shouldUseConsole()) {
         stderrLevels: ['error', 'warn', 'info', 'debug'], // All logs go to stderr
     }));
 }
-if (!(0, cloud_mode_js_1.isCloudMode)()) {
+if (!(0, cloud_mode_js_1.isCloudMode)() && process.env.CLOUDBASE_MCP_DISABLE_LOG_FILE !== 'true') {
     // File transport with daily rotation
     transports.push(new DailyRotateFile({
         dirname: logDir,
@@ -88853,6 +88866,7 @@ exports.MANAGE_FUNCTION_ACTIONS = [
     "attachLayer",
     "detachLayer",
     "updateFunctionLayers",
+    "incrementalDeployFunction", // 增量部署，需通过 pluginOptions.functions 注入实现
 ];
 const VPC_SCHEMA = zod_1.z.object({
     vpcId: zod_1.z.string(),
@@ -89034,6 +89048,7 @@ function wrapFunctionOperationError(operation, functionName, functionRootPath, e
 }
 function registerFunctionTools(server) {
     const cloudBaseOptions = server.cloudBaseOptions;
+    const deployOverrides = server.pluginOptions?.functions;
     const getManager = () => (0, cloudbase_manager_js_1.getCloudBaseManager)({ cloudBaseOptions });
     const buildEnvelope = (data, message, nextActions) => ({
         success: true,
@@ -89398,6 +89413,16 @@ function registerFunctionTools(server) {
         ensureActionAllowedInCloudMode(input);
         switch (input.action) {
             case "createFunction": {
+                if (deployOverrides?.createFunction) {
+                    const result = await deployOverrides.createFunction({
+                        functionName: String(input.func?.name ?? input.functionName ?? ''),
+                        functionRootPath: input.functionRootPath ?? '',
+                        runtime: input.func?.runtime,
+                        force: input.force,
+                        installDependency: input.func?.installDependency,
+                    });
+                    return buildEnvelope({ action: input.action, result }, '云函数部署成功（override）');
+                }
                 if (!input.func?.name || typeof input.func.name !== "string") {
                     throw new Error("createFunction 操作时，func.name 参数是必需的");
                 }
@@ -89485,6 +89510,15 @@ function registerFunctionTools(server) {
                 }, message, nextActions);
             }
             case "updateFunctionCode": {
+                if (deployOverrides?.updateFunctionCode) {
+                    const result = await deployOverrides.updateFunctionCode({
+                        functionName: input.functionName ?? '',
+                        functionRootPath: input.functionRootPath ?? '',
+                        force: input.force,
+                        installDependency: input.func?.installDependency,
+                    });
+                    return buildEnvelope({ action: input.action, result }, '云函数代码更新成功（override）');
+                }
                 if (!input.functionName) {
                     throw new Error("updateFunctionCode 操作时，functionName 参数是必需的");
                 }
@@ -89818,6 +89852,19 @@ function registerFunctionTools(server) {
                 ]);
             }
             default:
+                // incrementalDeployFunction：无默认实现，必须通过 pluginOptions 注入
+                if (input.action === 'incrementalDeployFunction') {
+                    const fn = deployOverrides?.incrementalDeployFunction;
+                    if (!fn) {
+                        throw new Error('incrementalDeployFunction 需要通过 pluginOptions.functions.incrementalDeployFunction 注入实现（仅在支持的 IDE 环境中可用）');
+                    }
+                    const result = await fn({
+                        functionName: input.functionName ?? '',
+                        functionRootPath: input.functionRootPath ?? '',
+                        incrementalFile: input.incrementalFile ?? '',
+                    });
+                    return buildEnvelope({ action: input.action, result }, '云函数增量部署成功');
+                }
                 throw new Error(`不支持的操作类型: ${input.action}`);
         }
     };
@@ -89890,7 +89937,7 @@ function registerFunctionTools(server) {
         inputSchema: {
             action: zod_1.z
                 .enum(exports.MANAGE_FUNCTION_ACTIONS)
-                .describe("写操作类型，例如 createFunction、updateFunctionCode、invokeFunction、deleteFunction、" +
+                .describe("写操作类型，例如 createFunction、updateFunctionCode、incrementalDeployFunction、invokeFunction、deleteFunction、" +
                 "createFunctionTrigger（定时任务 / cron / timer）、deleteFunctionTrigger、attachLayer、detachLayer"),
             func: CREATE_FUNCTION_SCHEMA.optional().describe("createFunction 操作的函数配置"),
             functionRootPath: zod_1.z.string().optional().describe("创建或更新函数代码时默认推荐的本地目录方式。" +
@@ -89926,6 +89973,7 @@ function registerFunctionTools(server) {
                 .describe("updateFunctionLayers 的目标层列表，顺序即最终顺序"),
             codeSecret: zod_1.z.string().optional().describe("层绑定时的代码保护密钥"),
             confirm: zod_1.z.boolean().optional().describe("危险操作确认开关。deleteFunction、deleteFunctionTrigger、deleteLayerVersion、detachLayer 等删除类操作需要显式传入 confirm=true"),
+            incrementalFile: zod_1.z.string().optional().describe("incrementalDeployFunction 增量部署时的变更文件路径"),
         },
         annotations: {
             readOnlyHint: false,
@@ -102126,10 +102174,19 @@ function registerDatabase(server) {
     (0, databaseSQL_js_1.registerSQLDatabaseTools)(server);
     (0, dataModel_js_1.registerDataModelTools)(server);
 }
+function registerNoSQLDatabase(server) {
+    const region = server.cloudBaseOptions?.region || process.env.TCB_REGION;
+    if (!(0, tencent_cloud_js_1.isInternationalRegion)(region)) {
+        (0, databaseNoSQL_js_1.registerDatabaseTools)(server);
+    }
+}
 // 可用插件映射
 const AVAILABLE_PLUGINS = {
     env: { name: "env", register: env_js_1.registerEnvTools },
     database: { name: "database", register: registerDatabase },
+    "database-nosql": { name: "database-nosql", register: registerNoSQLDatabase },
+    "database-sql": { name: "database-sql", register: databaseSQL_js_1.registerSQLDatabaseTools },
+    "data-model": { name: "data-model", register: dataModel_js_1.registerDataModelTools },
     functions: { name: "functions", register: functions_js_1.registerFunctionTools },
     hosting: { name: "hosting", register: hosting_js_1.registerHostingTools },
     storage: { name: "storage", register: storage_js_1.registerStorageTools },
@@ -102217,7 +102274,7 @@ function parseEnabledPlugins(pluginsEnabled, pluginsDisabled) {
  * await server.connect(transport);
  */
 async function createCloudBaseMcpServer(options) {
-    const { name = "cloudbase-mcp", version = "1.0.0", enableTelemetry = true, cloudBaseOptions, authOptions, cloudMode = false, ide, logger, pluginsEnabled, pluginsDisabled, } = options ?? {};
+    const { name = "cloudbase-mcp", version = "1.0.0", enableTelemetry = true, cloudBaseOptions, authOptions, cloudMode = false, ide, logger, pluginsEnabled, pluginsDisabled, pluginOptions, } = options ?? {};
     // Enable cloud mode if specified
     if (cloudMode) {
         (0, cloud_mode_js_1.enableCloudMode)();
@@ -102232,20 +102289,31 @@ async function createCloudBaseMcpServer(options) {
             ...(ide === "CodeBuddy" ? { logging: {} } : {}),
         },
     });
+    // 初始化 toolDefs，用于外部提取工具列表（如微信 IDE）
+    server.toolDefs = [];
     const originalRegisterTool = server.registerTool.bind(server);
-    server.registerTool = ((name, meta, handler) => originalRegisterTool(name, meta, async (args) => {
-        try {
-            return await handler(args);
-        }
-        catch (error) {
-            if ((0, tool_result_js_1.isToolPayloadError)(error)) {
-                // 在结构化错误返回中注入 MCP 版本号
-                const payload = { ...error.payload, mcpVersion: version };
-                return (0, tool_result_js_1.buildJsonToolResult)(payload);
+    server.registerTool = ((name, meta, handler) => {
+        // 同步记录到 toolDefs
+        server.toolDefs.push({
+            name,
+            description: meta?.description ?? meta?.title ?? '',
+            inputSchema: meta?.inputSchema ?? {},
+            handler,
+        });
+        return originalRegisterTool(name, meta, async (args) => {
+            try {
+                return await handler(args);
             }
-            throw error;
-        }
-    }));
+            catch (error) {
+                if ((0, tool_result_js_1.isToolPayloadError)(error)) {
+                    // 在结构化错误返回中注入 MCP 版本号
+                    const payload = { ...error.payload, mcpVersion: version };
+                    return (0, tool_result_js_1.buildJsonToolResult)(payload);
+                }
+                throw error;
+            }
+        });
+    });
     // Only set logging handler if logging capability is declared
     if (ide === "CodeBuddy") {
         server.server.setRequestHandler(types_js_1.SetLevelRequestSchema, (request, extra) => {
@@ -102260,6 +102328,10 @@ async function createCloudBaseMcpServer(options) {
     if (authOptions) {
         server.authOptions = authOptions;
     }
+    // Store pluginOptions in server instance for plugins to access
+    if (pluginOptions) {
+        server.pluginOptions = pluginOptions;
+    }
     // Store ide in server instance for telemetry
     if (ide) {
         server.ide = ide;
@@ -117979,13 +118051,16 @@ async function resolveHostingStaticDomain(cloudbase, logger) {
         return undefined;
     }
 }
-async function assertHostingUploadEnvironmentReady(cloudbase, cloudBaseOptions, logger) {
+// Returns the first hosting store record from DescribeStaticStore, which is
+// the authoritative source for Mini Program-sourced environments (those envs
+// do not populate StaticStorages in DescribeEnvs / getEnvInfo).
+// Throws when no valid store is found so upload can fail fast with a clear msg.
+async function getHostingStoreOrThrow(cloudbase, cloudBaseOptions, logger) {
     const envId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
-    const envInfo = await cloudbase.env.getEnvInfo();
-    (0, cloudbase_manager_js_1.logCloudBaseResult)(logger, envInfo);
-    const staticStorage = envInfo.EnvInfo?.StaticStorages?.[0];
-    if (staticStorage?.Bucket) {
-        return;
+    const result = await callTcbHostingAction(cloudbase, 'DescribeStaticStore', { EnvId: envId }, logger);
+    const hostingInfo = extractStaticStores(result);
+    if (hostingInfo.length > 0 && hostingInfo[0].Bucket) {
+        return hostingInfo[0];
     }
     throw new Error(`当前环境 ${envId} 未发现静态托管资源配置，无法上传文件。请先确认 MCP 已绑定到已开通静态托管的 CloudBase 环境；如需切换环境，请调用 auth(action="set_env", envId="目标环境ID") 后重试。`);
 }
@@ -118193,8 +118268,9 @@ function registerHostingTools(server) {
                         throw new Error('manageHosting(action="upload") 需要提供 localPath + cloudPath，或提供 files 多文件上传列表。');
                     }
                     let result;
+                    let store;
                     try {
-                        await assertHostingUploadEnvironmentReady(cloudbase, cloudBaseOptions, server.logger);
+                        store = await getHostingStoreOrThrow(cloudbase, cloudBaseOptions, server.logger);
                         result = await cloudbase.hosting.uploadFiles({
                             localPath: input.localPath,
                             cloudPath: input.cloudPath,
@@ -118206,7 +118282,11 @@ function registerHostingTools(server) {
                         throw new Error(buildUploadErrorMessage(error, input.localPath));
                     }
                     (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-                    const staticDomain = await resolveHostingStaticDomain(cloudbase, server.logger);
+                    // Prefer CdnDomain from the DescribeStaticStore result we already
+                    // fetched; fall back to getEnvInfo for environments that populate
+                    // StaticDomain there but not in DescribeStaticStore.
+                    const cdnFromStore = (store.CdnDomain ?? store.StaticDomain);
+                    const staticDomain = cdnFromStore || await resolveHostingStaticDomain(cloudbase, server.logger);
                     const accessUrl = buildHostingAccessUrl(staticDomain, input.cloudPath, input.localPath);
                     try {
                         const envId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
@@ -135149,7 +135229,7 @@ class TelemetryReporter {
         const nodeVersion = process.version; // Node.js版本
         const arch = os_1.default.arch(); // 系统架构
         // 从构建时注入的版本号获取MCP版本信息
-        const mcpVersion = process.env.npm_package_version || "2.21.0" || 0;
+        const mcpVersion = process.env.npm_package_version || "2.21.1-beta.1" || 0;
         return {
             userAgent: `${osType} ${osRelease} ${arch} ${nodeVersion} CloudBase-MCP/${mcpVersion}`,
             deviceId: this.deviceId,
@@ -180374,99 +180454,6 @@ async function downloadResources() {
     return resourceDownloadPromise;
 }
 async function registerRagTools(server) {
-    // 联网搜索
-    server.registerTool?.("searchWeb", {
-        title: "联网搜索",
-        description: "使用联网来进行信息检索，如查询最新的新闻、文章、股价、天气等。支持自然语言查询，也可以直接输入网址获取网页内容",
-        inputSchema: {
-            query: zod_1.z.string().describe("搜索关键词、问题或网址，支持自然语言"),
-        },
-        annotations: {
-            readOnlyHint: true,
-            openWorldHint: true,
-            category: "web",
-        },
-    }, async ({ query }) => {
-        try {
-            // 使用混元进行联网搜索
-            const signInRes = await fetch("https://tcb-advanced-a656fc.api.tcloudbasegateway.com/auth/v1/signin/anonymously", {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Accept: "application/json",
-                    "x-device-id": "cloudbase-ai-toolkit",
-                },
-                body: safeStringify({}),
-            });
-            const { access_token } = await signInRes.json();
-            // 调用混元API进行联网搜索
-            const searchRes = await fetch("https://tcb-advanced-a656fc.api.tcloudbasegateway.com/v1/ai/hunyuan-beta/openapi/v1/chat/completions", {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: `Bearer ${access_token}`,
-                },
-                body: safeStringify({
-                    model: "hunyuan",
-                    messages: [
-                        {
-                            role: "user",
-                            content: `你好，你将扮演一个知识库的角色，联网查询到问题的答案之后回答给我`,
-                        },
-                        {
-                            role: "assistant",
-                            content: "好的",
-                        },
-                        {
-                            role: "user",
-                            content: query,
-                        },
-                    ],
-                    enable_enhancement: true,
-                    search_info: true,
-                    enable_speed_search: true,
-                    force_search_enhancement: true,
-                }),
-            });
-            const result = await searchRes.json();
-            if (result.error) {
-                throw new Error(result.error.message || "联网搜索失败");
-            }
-            const content = result.choices?.[0]?.message?.content || "";
-            const searchResults = result.search_info?.search_results || [];
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: safeStringify({
-                            type: "web_search",
-                            content: content,
-                            search_results: searchResults.map((item) => ({
-                                title: item.title,
-                                url: item.url,
-                                snippet: item.snippet,
-                            })),
-                            status: "success",
-                        }),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: safeStringify({
-                            type: "error",
-                            message: error instanceof Error ? error.message : "联网搜索失败",
-                            status: "error",
-                        }),
-                    },
-                ],
-            };
-        }
-    });
     let openapis = [];
     let skills = [];
     let fallbackSkillsRoot;
@@ -185849,7 +185836,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.CloudBaseContext = void 0;
 const constant_1 = __webpack_require__(40762);
 class CloudBaseContext {
-    constructor({ secretId = '', secretKey = '', token = '', proxy = '', region = '', envType = '', useInternalEndpoint = undefined, internalEndpointRegion = undefined }) {
+    constructor({ secretId = '', secretKey = '', token = '', proxy = '', region = '', envType = '', useInternalEndpoint = undefined, internalEndpointRegion = undefined, requestFn = undefined }) {
         this.secretId = secretId;
         this.secretKey = secretKey;
         this.token = token;
@@ -185858,6 +185845,7 @@ class CloudBaseContext {
         this.envType = envType;
         this.useInternalEndpoint = useInternalEndpoint;
         this.internalEndpointRegion = internalEndpointRegion;
+        this.requestFn = requestFn;
     }
     isInternalEndpoint() {
         return this.useInternalEndpoint !== undefined ? this.useInternalEndpoint : constant_1.USE_INTERNAL_ENDPOINT;
@@ -193754,7 +193742,7 @@ ${envIdSection}
 ## 环境信息
 - 操作系统: ${os_1.default.type()} ${os_1.default.release()}
 - Node.js版本: ${process.version}
-- MCP 版本：${process.env.npm_package_version || "2.21.0" || 0}
+- MCP 版本：${process.env.npm_package_version || "2.21.1-beta.1" || 0}
 - 系统架构: ${os_1.default.arch()}
 - 时间: ${new Date().toISOString()}
 - 请求ID: ${requestId}
@@ -193835,7 +193823,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.21.0" : 0;
+            const mcpVersion =  true ? "2.21.1-beta.1" : 0;
             const requestIdSuffix = requestId ? `\n🆔 RequestId: ${requestId}` : '';
             const enhancedErrorMessage = `${errorMessage}${requestIdSuffix}\n\n📦 CloudBase MCP v${mcpVersion}\n🔗 遇到问题？请复制以下链接到浏览器打开\n即可自动携带错误详情快速创建 GitHub Issue：\n${issueLink}`;
             // 创建新的错误对象，保持原有的错误类型但更新消息
@@ -203264,6 +203252,13 @@ async function callNoSqlContentApi(options) {
             instanceIdSource: "envId",
             requestId: result?.RequestId,
         });
+        // 检查 API 层返回的业务错误（如集合不存在）并抛出
+        if (result?.Error) {
+            const err = new Error(`${result.Error.Code}: ${result.Error.Message}`);
+            err.code = result.Error.Code;
+            err.requestId = result.RequestId;
+            throw err;
+        }
         return result;
     }
     catch (error) {
@@ -203277,7 +203272,7 @@ async function callNoSqlContentApi(options) {
         throw error;
     }
 }
-async function waitForCollectionReady({ cloudbase, collectionName, logger, timeoutMs = COLLECTION_READY_TIMEOUT_MS, pollIntervalMs = COLLECTION_READY_POLL_INTERVAL_MS, }) {
+async function waitForCollectionReady({ cloudbase, collectionName, logger, cloudBaseOptions, timeoutMs = COLLECTION_READY_TIMEOUT_MS, pollIntervalMs = COLLECTION_READY_POLL_INTERVAL_MS, }) {
     const startedAt = Date.now();
     const deadline = startedAt + timeoutMs;
     let lastError;
@@ -203291,17 +203286,40 @@ async function waitForCollectionReady({ cloudbase, collectionName, logger, timeo
     });
     while (Date.now() <= deadline) {
         try {
-            // 直接用 commonService 调用 DescribeTable 检查集合是否存在，避免 SDK lazyInit → DescribeEnvs
-            const envId = await (0, cloudbase_manager_js_1.getEnvId)();
-            const result = await cloudbase.commonService("tcb", "2018-06-08").call({
-                Action: "DescribeTable",
+            // 用 PutItem 探测集合是否真正就绪（DescribeTable 可能误报），插入一个空占位文档
+            // 如果成功，立即删除该文档；如果仍 ResourceNotFound，继续等待
+            const envId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+            const probeDoc = JSON.stringify({ _readyProbe: true, _ts: Date.now() });
+            const probeResult = await cloudbase.commonService("tcb", "2018-06-08").call({
+                Action: "PutItem",
                 Param: {
                     EnvId: envId,
                     TableName: collectionName,
+                    MgoDocs: [probeDoc],
                 },
             });
-            (0, cloudbase_manager_js_1.logCloudBaseResult)(logger, result);
-            // DescribeTable 成功返回即表示集合存在
+            (0, cloudbase_manager_js_1.logCloudBaseResult)(logger, probeResult);
+            if (probeResult?.Error) {
+                // 集合还未就绪，继续轮询
+                throw new Error(probeResult.Error.Message);
+            }
+            // 集合就绪，清理探测文档
+            if (Array.isArray(probeResult?.InsertedIds) && probeResult.InsertedIds.length > 0) {
+                try {
+                    await cloudbase.commonService("tcb", "2018-06-08").call({
+                        Action: "DeleteItem",
+                        Param: {
+                            EnvId: envId,
+                            TableName: collectionName,
+                            MgoQuery: JSON.stringify({ _readyProbe: true }),
+                            MgoIsMulti: true,
+                        },
+                    });
+                }
+                catch {
+                    // 清理失败不影响主流程
+                }
+            }
             logger?.({
                 type: "toolInfo",
                 toolName: "writeNoSqlDatabaseStructure",
@@ -203340,8 +203358,8 @@ function registerDatabaseTools(server) {
     const getManager = () => (0, cloudbase_manager_js_1.getCloudBaseManager)({ cloudBaseOptions });
     // readNoSqlDatabaseStructure
     server.registerTool?.("readNoSqlDatabaseStructure", {
-        title: "读取 NoSQL 数据库结构",
-        description: "读取 NoSQL 数据库集合与索引结构，支持列出集合、查看集合详情、列出索引以及检查索引是否存在。本工具为服务端管理工具，用于管理端查询数据库结构，不用于编写客户端代码。",
+        title: "读取 CloudBase NoSQL 数据库结构",
+        description: "读取 CloudBase NoSQL 数据库集合与索引结构，支持列出集合、查看集合详情、列出索引以及检查索引是否存在。本工具为服务端管理工具，用于管理端查询数据库结构，不用于编写客户端代码。",
         inputSchema: {
             action: zod_1.z.enum([
                 "listCollections",
@@ -203528,8 +203546,8 @@ checkIndex: 检查指定索引是否存在`),
     });
     // writeNoSqlDatabaseStructure
     server.registerTool?.("writeNoSqlDatabaseStructure", {
-        title: "创建并管理 NoSQL 数据库集合",
-        description: "创建、删除和管理 NoSQL 数据库集合（collection）。支持创建新集合、删除现有集合，以及通过 updateCollection 的 updateOptions.CreateIndexes / updateOptions.DropIndexes 添加索引和删除索引。当需要新建集合时，使用 action=createCollection。本工具为服务端管理工具，用于管理端操作集合和索引结构，不用于编写客户端代码。",
+        title: "创建并管理 CloudBase NoSQL 数据库集合",
+        description: "创建、删除和管理 CloudBase NoSQL 数据库集合（collection）。支持创建新集合、删除现有集合，以及通过 updateCollection 的 updateOptions.CreateIndexes / updateOptions.DropIndexes 添加索引和删除索引。当需要新建集合时，使用 action=createCollection。本工具为服务端管理工具，用于管理端操作集合和索引结构，不用于编写客户端代码。",
         inputSchema: {
             action: zod_1.z.enum([
                 "createCollection",
@@ -203589,8 +203607,14 @@ deleteCollection: 删除集合`),
                     Action: "DescribeTable",
                     Param: { EnvId: envId, TableName: collectionName },
                 });
-                collectionExists = true;
-                existsRequestId = descResult?.RequestId ?? "";
+                if (descResult?.Error) {
+                    // 集合不存在（ResourceNotFound）或其他错误，继续创建
+                    existsRequestId = descResult.RequestId ?? "";
+                }
+                else {
+                    collectionExists = true;
+                    existsRequestId = descResult?.RequestId ?? "";
+                }
             }
             catch (e) {
                 existsRequestId = e?.requestId ?? "";
@@ -203623,6 +203647,7 @@ deleteCollection: 删除集合`),
                 cloudbase,
                 collectionName,
                 logger: server.logger,
+                cloudBaseOptions: server.cloudBaseOptions,
             });
             return {
                 content: [
@@ -203705,8 +203730,8 @@ deleteCollection: 删除集合`),
     });
     // readNoSqlDatabaseContent
     server.registerTool?.("readNoSqlDatabaseContent", {
-        title: "查询并获取 NoSQL 数据库数据记录",
-        description: "查询并获取 NoSQL 数据库数据记录。⚠️ 本工具为服务端管理工具，用于管理端/运维端查询。当任务要求编写客户端应用代码时（例如「用 JS SDK 读取数据」），不应使用本工具，而应在项目代码中编写 @cloudbase/js-sdk 客户端代码（如 db.collection().where().get()）。",
+        title: "查询并获取 CloudBase NoSQL 数据库数据记录",
+        description: "查询 CloudBase NoSQL 数据库中的数据记录。支持按条件筛选、分页、排序，适用于管理端数据查询与运维。",
         inputSchema: {
             collectionName: zod_1.z.string().describe("集合名称"),
             instanceId: zod_1.z
@@ -203792,8 +203817,10 @@ deleteCollection: 删除集合`),
     });
     // writeNoSqlDatabaseContent
     server.registerTool?.("writeNoSqlDatabaseContent", {
-        title: "修改 NoSQL 数据库数据记录",
-        description: "修改 NoSQL 数据库数据记录。⚠️ 本工具为服务端管理工具，用于管理端/运维端操作（如后台脚本、数据迁移、批量修改）。当任务要求编写客户端应用代码时（例如「用 JS SDK 登录并插入数据」、「在前端读写数据库」），不应使用本工具，而应在项目代码中编写 @cloudbase/js-sdk 客户端代码（如 app.database().collection().add()、db.collection().where().get() 等）。可按 MongoDB updateOne/updateMany 的心智模型理解：部分更新必须使用 `$set`、`$inc`、`$push` 等更新操作符；如果直接传「字段到值的普通对象」这类内容，底层会把它当作替换内容，存在覆盖整条文档的风险。⚠️ 嵌套对象部分更新务必使用点号路径：要更新 `shipping.city`，应传 `$set: {\"shipping.city\": \"guangzhou\"}`，绝不能传 `$set: {\"shipping\": {\"city\": \"guangzhou\"}}`（后者会丢失 shipping 下的其他字段）。若集合中的角色/档案文档会在前端通过 `db.collection(...).doc(uid)` 读取，请确保文档 `_id` 就是该 `uid`；不要用按 `uid` 条件查询再配合 `upsert=true` 的方式去更新 `users` / `profiles`，否则经常会生成一个不同的 `_id`，导致后续 `doc(uid)` 读取命中不到。",
+        title: "修改 CloudBase NoSQL 数据库数据记录",
+        description: "修改 CloudBase NoSQL 数据库中的数据记录。支持插入、更新（含 $set/$inc/$push 等操作符）、删除、upsert 等操作，适用于管理端数据写入与运维。" +
+            "⚠️ 服务端写入不含 _openid：若集合依赖客户端 SDK（@cloudbase/js-sdk 或微信小程序 wx.cloud.database()）的行级安全规则（如 doc._openid == auth.openid），服务端写入时需手动补充 _openid 字段，否则客户端将无法读取到该数据。" +
+            "⚠️ 部分更新嵌套字段须使用点号路径，如 `$set: {\"shipping.city\": \"guangzhou\"}`，直接传嵌套对象会覆盖整个字段。",
         inputSchema: {
             action: zod_1.z
                 .enum(["insert", "update", "delete"])
@@ -209808,7 +209835,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.21.0" : 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.21.1-beta.1" : 0}），便于后续维护和版本追踪\n- 下载 rules 模板时，如果项目中已存在 README.md 文件，系统会自动保护该文件不被覆盖（除非设置 overwrite=true）`,
         inputSchema: {
             template: zod_1.z
                 .enum(["react", "vue", "miniprogram", "uniapp", "rules"])
@@ -219995,12 +220022,13 @@ function getDate(timestamp) {
 }
 class CloudService {
     /* eslint-disable-next-line */
-    constructor(context, service, version, baseParams) {
+    constructor(context, service, version, baseParams, requestFn) {
         this.service = service;
         this.version = version;
         this.timeout = 60000;
         this.baseParams = baseParams || {};
         this.cloudBaseContext = context;
+        this.requestFn = requestFn !== null && requestFn !== void 0 ? requestFn : context.requestFn;
     }
     get baseUrl() {
         const internalEndpoint = this.cloudBaseContext.isInternalEndpoint();
@@ -220032,8 +220060,31 @@ class CloudService {
         }
     }
     async request(action, data = {}, method = 'POST') {
+        var _a;
         this.action = action;
         this.data = deepRemoveVoid(Object.assign(Object.assign({}, data), this.baseParams));
+        // 如果注入了 requestFn，直接委托，跳过 TC3 签名逻辑
+        if (this.requestFn) {
+            try {
+                const result = await this.requestFn({
+                    service: this.service,
+                    action,
+                    version: this.version,
+                    region: (_a = this.cloudBaseContext.region) !== null && _a !== void 0 ? _a : '',
+                    payload: this.data,
+                });
+                return result;
+            }
+            catch (e) {
+                if (e.name === 'CloudBaseError') {
+                    throw e;
+                }
+                throw new error_1.CloudBaseError(e.message, {
+                    action,
+                    code: e.code
+                });
+            }
+        }
         this.method = method;
         this.url = this.baseUrl;
         let { secretId, secretKey, token } = this.cloudBaseContext;
@@ -244772,8 +244823,8 @@ function registerLogTools(server) {
     const cloudBaseOptions = server.cloudBaseOptions;
     const getManager = () => (0, cloudbase_manager_js_1.getCloudBaseManager)({ cloudBaseOptions });
     server.registerTool?.("queryLogs", {
-        title: "查询日志服务",
-        description: "日志域统一只读入口。支持检查日志服务状态并搜索 CLS 日志。" +
+        title: "查询 CloudBase 日志服务",
+        description: "CloudBase 日志域统一只读入口。支持检查日志服务状态并搜索 CLS 日志。" +
             "\n\n**重要区分**：" +
             "\n- 查询云函数日志：使用 `queryFunctions(action=\"listFunctionLogs\", functionName=\"xxx\")`" +
             "\n- 查询 CLS 日志（跨服务日志聚合）：使用本工具 `queryLogs(action=\"searchLogs\")`" +
@@ -250850,6 +250901,7 @@ async function resolveStoragePublicAccess(params) {
 function registerStorageTools(server) {
     // 获取 cloudBaseOptions，如果没有则为 undefined
     const cloudBaseOptions = server.cloudBaseOptions;
+    const storageOverrides = server.pluginOptions?.storage;
     // 创建闭包函数来获取 CloudBase Manager
     const getManager = () => (0, cloudbase_manager_js_1.getCloudBaseManager)({ cloudBaseOptions });
     // Tool 1: queryStorage - 查询存储信息（只读操作）
@@ -250871,7 +250923,14 @@ function registerStorageTools(server) {
         const storageService = manager.storage;
         switch (input.action) {
             case 'list': {
-                const result = await storageService.listDirectoryFiles(input.cloudPath);
+                let files;
+                if (storageOverrides?.listFiles) {
+                    files = await storageOverrides.listFiles({ cloudPath: input.cloudPath });
+                }
+                else {
+                    const result = await storageService.listDirectoryFiles(input.cloudPath);
+                    files = result || [];
+                }
                 return {
                     content: [
                         {
@@ -250881,17 +250940,23 @@ function registerStorageTools(server) {
                                 data: {
                                     action: 'list',
                                     cloudPath: input.cloudPath,
-                                    files: result || [],
-                                    totalCount: result?.length || 0
+                                    files,
+                                    totalCount: files.length
                                 },
-                                message: `Successfully listed ${result?.length || 0} files in directory '${input.cloudPath}'`
+                                message: `Successfully listed ${files.length} files in directory '${input.cloudPath}'`
                             }, null, 2)
                         }
                     ]
                 };
             }
             case 'info': {
-                const result = await storageService.getFileInfo(input.cloudPath);
+                let fileInfo;
+                if (storageOverrides?.getFileInfo) {
+                    fileInfo = await storageOverrides.getFileInfo({ cloudPath: input.cloudPath });
+                }
+                else {
+                    fileInfo = await storageService.getFileInfo(input.cloudPath);
+                }
                 return {
                     content: [
                         {
@@ -250901,7 +250966,7 @@ function registerStorageTools(server) {
                                 data: {
                                     action: 'info',
                                     cloudPath: input.cloudPath,
-                                    fileInfo: result
+                                    fileInfo
                                 },
                                 message: `Successfully retrieved file info for '${input.cloudPath}'`
                             }, null, 2)
@@ -250945,10 +251010,15 @@ function registerStorageTools(server) {
                 const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), STORAGE_READ_TEMP_PREFIX));
                 const localPath = path.join(tempDir, getStorageTempFileName(input.cloudPath));
                 try {
-                    await storageService.downloadFile({
-                        cloudPath: input.cloudPath,
-                        localPath
-                    });
+                    if (storageOverrides?.downloadFile) {
+                        await storageOverrides.downloadFile({ cloudPath: input.cloudPath, localPath });
+                    }
+                    else {
+                        await storageService.downloadFile({
+                            cloudPath: input.cloudPath,
+                            localPath
+                        });
+                    }
                     const buffer = await fs.readFile(localPath);
                     const decoded = decodeInlineTextContent(buffer);
                     return {
@@ -251003,22 +251073,32 @@ function registerStorageTools(server) {
         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);
-                        }
-                    });
+                    if (storageOverrides?.uploadDirectory) {
+                        await storageOverrides.uploadDirectory({ localPath: input.localPath, cloudPath: input.cloudPath });
+                    }
+                    else {
+                        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);
-                        }
-                    });
+                    if (storageOverrides?.uploadFile) {
+                        await storageOverrides.uploadFile({ localPath: input.localPath, cloudPath: input.cloudPath });
+                    }
+                    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,
@@ -251054,16 +251134,26 @@ function registerStorageTools(server) {
             }
             case 'download': {
                 if (input.isDirectory) {
-                    await storageService.downloadDirectory({
-                        cloudPath: input.cloudPath,
-                        localPath: input.localPath
-                    });
+                    if (storageOverrides?.downloadDirectory) {
+                        await storageOverrides.downloadDirectory({ cloudPath: input.cloudPath, localPath: input.localPath });
+                    }
+                    else {
+                        await storageService.downloadDirectory({
+                            cloudPath: input.cloudPath,
+                            localPath: input.localPath
+                        });
+                    }
                 }
                 else {
-                    await storageService.downloadFile({
-                        cloudPath: input.cloudPath,
-                        localPath: input.localPath
-                    });
+                    if (storageOverrides?.downloadFile) {
+                        await storageOverrides.downloadFile({ cloudPath: input.cloudPath, localPath: input.localPath });
+                    }
+                    else {
+                        await storageService.downloadFile({
+                            cloudPath: input.cloudPath,
+                            localPath: input.localPath
+                        });
+                    }
                 }
                 return {
                     content: [
@@ -251099,10 +251189,20 @@ function registerStorageTools(server) {
                     };
                 }
                 if (input.isDirectory) {
-                    await storageService.deleteDirectory(input.cloudPath);
+                    if (storageOverrides?.deleteDirectory) {
+                        await storageOverrides.deleteDirectory({ cloudPath: input.cloudPath });
+                    }
+                    else {
+                        await storageService.deleteDirectory(input.cloudPath);
+                    }
                 }
                 else {
-                    await storageService.deleteFile([input.cloudPath]);
+                    if (storageOverrides?.deleteFiles) {
+                        await storageOverrides.deleteFiles({ cloudPaths: [input.cloudPath] });
+                    }
+                    else {
+                        await storageService.deleteFile([input.cloudPath]);
+                    }
                 }
                 return {
                     content: [
@@ -259387,9 +259487,9 @@ class CloudBase {
     }
     constructor(config = {}) {
         this.cloudBaseConfig = {};
-        let { secretId, secretKey, token, envId, proxy, region, envType, useInternalEndpoint, internalEndpointRegion } = config;
-        // config 中传入的 secretId secretkey 必须同时存在
-        if ((secretId && !secretKey) || (!secretId && secretKey)) {
+        let { secretId, secretKey, token, envId, proxy, region, envType, useInternalEndpoint, internalEndpointRegion, requestFn } = config;
+        // config 中传入的 secretId secretkey 必须同时存在（有 requestFn 时可以不传）
+        if (!requestFn && ((secretId && !secretKey) || (!secretId && secretKey))) {
             throw new Error('secretId and secretKey must be a pair');
         }
         this.cloudBaseConfig = {
@@ -259402,6 +259502,7 @@ class CloudBase {
             region,
             useInternalEndpoint,
             internalEndpointRegion,
+            requestFn,
         };
         // 初始化 context
         this.context = new context_1.CloudBaseContext(this.cloudBaseConfig);