@microsoft/teamsfx-core 3.1.0 → 3.1.1

package/build/core/FxCore.declarativeAgent.js

@@ -2,22 +2,91 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FxCoreDeclarativeAgentPart = void 0;
+exports.FxCoreDeclarativeAgentPart = exports.fxCoreDeclarativeAgentDeps = void 0;
 const tslib_1 = require("tslib");
 const hooks_1 = require("@feathersjs/hooks");
+const m365_spec_parser_1 = require("@microsoft/m365-spec-parser");
 const teamsfx_api_1 = require("@microsoft/teamsfx-api");
-const axios_1 = tslib_1.__importDefault(require("axios"));
 const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
 const path = tslib_1.__importStar(require("path"));
+const daSpecParser_1 = require("../common/daSpecParser");
+const featureFlags_1 = require("../common/featureFlags");
 const globalVars_1 = require("../common/globalVars");
 const localizeUtils_1 = require("../common/localizeUtils");
-const actionInjector_1 = require("../component/configManager/actionInjector");
+const telemetry_1 = require("../common/telemetry");
+const versionMetadata_1 = require("../common/versionMetadata");
 const constants_1 = require("../component/constants");
+const errors_1 = require("../component/driver/teamsApp/errors");
+const results_1 = require("../component/driver/teamsApp/results");
+const CopilotGptManifestUtils_1 = require("../component/driver/teamsApp/utils/CopilotGptManifestUtils");
+const ManifestUtils_1 = require("../component/driver/teamsApp/utils/ManifestUtils");
+const PluginManifestUtils_1 = require("../component/driver/teamsApp/utils/PluginManifestUtils");
+const utils_1 = require("../component/driver/teamsApp/utils/utils");
+const declarativeAgentHelperModule = tslib_1.__importStar(require("../component/generator/declarativeAgent/helper"));
+const helper_1 = require("../component/generator/declarativeAgent/helper");
+const generator_1 = require("../component/generator/generator");
+const openApiSpecHelperModule = tslib_1.__importStar(require("../component/generator/openApiSpec/helper"));
+const helper_2 = require("../component/generator/openApiSpec/helper");
+const v4TemplateBridge_1 = require("../component/generator/v4TemplateBridge");
 const questionMW_1 = require("../component/middleware/questionMW");
+const common_1 = require("../component/utils/common");
+const mcpAuthScaffolder_1 = require("../component/utils/mcpAuthScaffolder");
 const pathUtils_1 = require("../component/utils/pathUtils");
+const common_2 = require("../error/common");
 const constants_2 = require("../question/constants");
+const teamsProjectTypeNode_1 = require("../question/scaffold/vsc/teamsProjectTypeNode");
 const concurrentLocker_1 = require("./middleware/concurrentLocker");
 const errorHandler_1 = require("./middleware/errorHandler");
+const modifyProjectFrontDoor_1 = require("./modifyProjectFrontDoor");
+const v4ArtifactSnapshot_1 = require("./v4ArtifactSnapshot");
+function targetRelativePath(projectPath, filePath) {
+    const absolute = path.isAbsolute(filePath) ? filePath : path.resolve(projectPath, filePath);
+    return path.relative(projectPath, absolute).replace(/\\/g, "/");
+}
+async function scaffoldAddMcpServerFromV4(options) {
+    const context = {
+        name: options.appName,
+        language: "common",
+        platform: options.platform,
+        destination: options.projectPath,
+        logProvider: globalVars_1.TOOLS.logProvider,
+        onActionError: generator_1.templateDefaultOnActionError,
+    };
+    try {
+        const source = await (0, v4TemplateBridge_1.scaffoldDeclarativeFromV4Channel)(context, { kind: "modify", templateId: options.templateId }, {
+            mcpServerUrl: options.mcpServerUrl,
+            teamsManifestPath: targetRelativePath(options.projectPath, options.teamsManifestPath),
+            authType: options.authType,
+        }, { appName: options.appName, language: "common" }, undefined, undefined, options.resolvedPackage);
+        if (source.warning) {
+            globalVars_1.TOOLS.logProvider.warning(source.warning);
+        }
+        // Like the shipped add-action flow, this path has no scaffolding summary to fall back on,
+        // so an m365agents.yml left with auth placeholders has to be said out loud — otherwise
+        // provision fails later with an opaque error.
+        for (const warning of context.warnings ?? []) {
+            if (mcpAuthScaffolder_1.MCP_AUTH_PLACEHOLDER_WARNING_TYPES.includes(warning.type)) {
+                void globalVars_1.TOOLS.ui.showMessage("warn", warning.content, false);
+            }
+        }
+    }
+    catch (error) {
+        return (0, teamsfx_api_1.err)((0, common_2.assembleError)(error));
+    }
+    return (0, teamsfx_api_1.ok)(undefined);
+}
+// Non-translatable CLI command template used in warning messages
+const mcpAddActionHint = "atk add action --api-plugin-type mcp --mcp-da-server-url <server-url> --mcp-tools-file-path <path-to-tools-json> --interactive false";
+exports.fxCoreDeclarativeAgentDeps = {
+    addExistingPlugin: declarativeAgentHelperModule.addExistingPlugin,
+    createNewActionPluginManifest: declarativeAgentHelperModule.createNewActionPluginManifest,
+    deriveMCPServerNameFromUrl: helper_1.deriveMCPServerNameFromUrl,
+    generateFromApiSpec: openApiSpecHelperModule.generateFromApiSpec,
+    generateScaffoldingSummary: openApiSpecHelperModule.generateScaffoldingSummary,
+    modifyProjectFrontDoor: modifyProjectFrontDoor_1.modifyProjectFrontDoor,
+    resolveV4TemplateArtifactSnapshot: v4ArtifactSnapshot_1.resolveV4TemplateArtifactSnapshot,
+    scaffoldAddMcpServerFromV4,
+};
 class FxCoreDeclarativeAgentPart {
     async updateActionWithMCP(inputs) {
         const context = (0, globalVars_1.createContext)();
@@ -25,7 +94,31 @@ class FxCoreDeclarativeAgentPart {
         if (!projectPath) {
             throw new Error("projectPath is undefined"); // should never happen
         }
-        const aiPluginFilePath = inputs[constants_2.QuestionNames.PluginManifestFilePath];
+        let aiPluginFilePath = inputs[constants_2.QuestionNames.PluginManifestFilePath];
+        // If the user picked the "Create a new ai-plugin.json" option in the question,
+        // the value will be the sentinel. Generate a fresh skeleton manifest under
+        // appPackage using the file name from the follow-up text question and
+        // register it as a new action of the declarative agent before continuing
+        // with the regular update flow.
+        if (aiPluginFilePath === teamsProjectTypeNode_1.CreateNewPluginManifestSentinel) {
+            const desiredFileName = inputs[constants_2.QuestionNames.NewPluginManifestFileName] || "ai-plugin.json";
+            const teamsManifestPath = path.join(projectPath, teamsfx_api_1.AppPackageFolderName, teamsfx_api_1.ManifestTemplateFileName);
+            const manifestRes = await ManifestUtils_1.manifestUtils._readAppManifest(teamsManifestPath);
+            if (manifestRes.isErr()) {
+                return (0, teamsfx_api_1.err)(manifestRes.error);
+            }
+            const declarativeAgentRelativePath = manifestRes.value?.copilotAgents?.declarativeAgents?.[0]?.file;
+            if (!declarativeAgentRelativePath) {
+                return (0, teamsfx_api_1.err)(results_1.AppStudioResultFactory.UserError(errors_1.AppStudioError.TeamsAppRequiredPropertyMissingError.name, errors_1.AppStudioError.TeamsAppRequiredPropertyMissingError.message("declarativeAgents", teamsManifestPath)));
+            }
+            const declarativeAgentManifestPath = path.join(projectPath, teamsfx_api_1.AppPackageFolderName, declarativeAgentRelativePath);
+            const createRes = await declarativeAgentHelperModule.createNewActionPluginManifest(projectPath, desiredFileName, declarativeAgentManifestPath);
+            if (createRes.isErr()) {
+                return (0, teamsfx_api_1.err)(createRes.error);
+            }
+            aiPluginFilePath = createRes.value.pluginManifestPath;
+            inputs[constants_2.QuestionNames.PluginManifestFilePath] = aiPluginFilePath;
+        }
         if (!(await fs_extra_1.default.pathExists(aiPluginFilePath))) {
             const error = new teamsfx_api_1.SystemError("MCPForDAPluginManifestNotFound", "PluginManifestNotFound", (0, localizeUtils_1.getDefaultString)("core.MCPForDA.pluginManifestNotFound", aiPluginFilePath), (0, localizeUtils_1.getLocalizedString)("core.MCPForDA.pluginManifestNotFound", aiPluginFilePath));
             return (0, teamsfx_api_1.err)(error);
@@ -35,46 +128,12 @@ class FxCoreDeclarativeAgentPart {
         const serverName = inputs[constants_2.QuestionNames.MCPForDAServerName];
         const mcpAuth = inputs[constants_2.QuestionNames.MCPForDAAuth];
         const authType = inputs[constants_2.QuestionNames.MCPForDAAuthType];
-        let oauthAuthorizationUrl = undefined;
-        let oauthTokenUrl = undefined;
-        let oauthRefreshUrl = undefined;
+        let mcpAuthEndpoints = {};
         let registrationId = undefined;
         if (mcpAuth === "OAuthPluginVault") {
             try {
                 registrationId = `MCP_DA_AUTH_ID_${serverName.toUpperCase()}`;
-                if (authType === "oauth") {
-                    let wellKnownMetadataUrl = inputs[constants_2.QuestionNames.MCPForDAAuthWellKnownUrl];
-                    if (!wellKnownMetadataUrl) {
-                        const mcpAuthMetadataUrl = inputs[constants_2.QuestionNames.MCPForDAAuthMetadataUrl];
-                        if (!mcpAuthMetadataUrl) {
-                            throw new Error((0, localizeUtils_1.getLocalizedString)("core.MCPForDA.mcpAuthMetadataUrlNotFound"));
-                        }
-                        const response = await axios_1.default.get(mcpAuthMetadataUrl);
-                        if (response.status === 200 &&
-                            response.data &&
-                            response.data.authorization_servers &&
-                            response.data.authorization_servers.length > 0) {
-                            const mcpServerMetadataUrl = response.data.authorization_servers?.[0];
-                            // Transform the URL to the proper OAuth authorization server metadata endpoint
-                            // According to RFC 8414, the well-known endpoint should be constructed as:
-                            // https://{domain}/.well-known/oauth-authorization-server{path}
-                            const serverUrl = new URL(mcpServerMetadataUrl);
-                            wellKnownMetadataUrl = `${serverUrl.protocol}//${serverUrl.host}/.well-known/oauth-authorization-server${serverUrl.pathname}`;
-                        }
-                        else {
-                            throw new Error((0, localizeUtils_1.getLocalizedString)("core.MCPForDA.mcpServerMetadataUrlNotFound"));
-                        }
-                    }
-                    const metadataResponse = await axios_1.default.get(wellKnownMetadataUrl);
-                    if (metadataResponse.status === 200) {
-                        oauthAuthorizationUrl = metadataResponse.data.authorization_endpoint;
-                        oauthTokenUrl = metadataResponse.data.token_endpoint;
-                        oauthRefreshUrl = metadataResponse.data.refresh_endpoint;
-                    }
-                    if (!oauthAuthorizationUrl || !oauthTokenUrl) {
-                        throw new Error((0, localizeUtils_1.getLocalizedString)("core.MCPForDA.authUrlNotFound"));
-                    }
-                }
+                mcpAuthEndpoints = await (0, mcpAuthScaffolder_1.resolveMCPAuthEndpoints)(authType, inputs);
             }
             catch (error) {
                 void context.userInteraction.showMessage("error", (0, localizeUtils_1.getLocalizedString)("core.MCPForDA.mcpAuthMetadataMissingError", error.message), false);
@@ -90,14 +149,20 @@ class FxCoreDeclarativeAgentPart {
             const error = new teamsfx_api_1.UserError("MCPForDAPreFetchToolsNotFound", "PreFetchToolsNotFound", (0, localizeUtils_1.getDefaultString)("core.MCPForDA.preFetchToolsNotFound"), (0, localizeUtils_1.getLocalizedString)("core.MCPForDA.preFetchToolsNotFound"));
             return (0, teamsfx_api_1.err)(error);
         }
+        const pluginFunctions = Array.isArray(aiPluginContent.functions)
+            ? aiPluginContent.functions
+            : [];
+        const pluginRuntimes = Array.isArray(aiPluginContent.runtimes) ? aiPluginContent.runtimes : [];
         const toolsSelectedPrevious = [];
-        aiPluginContent.runtimes
-            .filter((runtime) => (runtime.type === "RemoteMCPServer" && runtime.spec.url === mcpServerUrl) ||
+        pluginRuntimes
+            .filter((runtime) => (runtime.type === "RemoteMCPServer" && runtime.spec?.url === mcpServerUrl) ||
             runtime.type === "LocalPlugin")
             .forEach((runtime) => {
-            toolsSelectedPrevious.push(...runtime.run_for_functions);
+            if (Array.isArray(runtime.run_for_functions)) {
+                toolsSelectedPrevious.push(...runtime.run_for_functions);
+            }
         });
-        aiPluginContent.functions = aiPluginContent.functions.filter((func) => !toolsSelectedPrevious.includes(func.name));
+        aiPluginContent.functions = pluginFunctions.filter((func) => !toolsSelectedPrevious.includes(func.name));
         aiPluginContent.functions = [
             ...aiPluginContent.functions,
             ...mcpToolsDetail
@@ -122,9 +187,9 @@ class FxCoreDeclarativeAgentPart {
                 }
             }),
         ];
-        const matchedRuntime = aiPluginContent.runtimes.find((runtime) => runtime.type === "RemoteMCPServer" && runtime.spec.url === mcpServerUrl);
-        aiPluginContent.runtimes = aiPluginContent.runtimes.filter((runtime) => (runtime.type !== "RemoteMCPServer" && runtime.type !== "LocalPlugin") ||
-            runtime.spec.url !== mcpServerUrl);
+        const matchedRuntime = pluginRuntimes.find((runtime) => runtime.type === "RemoteMCPServer" && runtime.spec?.url === mcpServerUrl);
+        aiPluginContent.runtimes = pluginRuntimes.filter((runtime) => (runtime.type !== "RemoteMCPServer" && runtime.type !== "LocalPlugin") ||
+            runtime.spec?.url !== mcpServerUrl);
         if (inputs[constants_2.QuestionNames.MCPLocalServerIdentifier] != null) {
             aiPluginContent.runtimes.push({
                 type: "LocalPlugin",
@@ -167,19 +232,29 @@ class FxCoreDeclarativeAgentPart {
                     },
                 },
                 run_for_functions: mcpToolsSelected,
-                auth: mcpAuth === "OAuthPluginVault" && !!registrationId
-                    ? {
-                        type: "OAuthPluginVault",
-                        reference_id: `$\{\{${registrationId}\}\}`,
-                    }
-                    : {
-                        type: "None",
-                    },
+                auth: (0, mcpAuthScaffolder_1.deriveMCPManifestOAuth)(authType, registrationId) ?? {
+                    type: "None",
+                },
             });
         }
         if (mcpAuth === "OAuthPluginVault" && !!registrationId) {
             // insert oauth info in teamsapp.yaml
-            await actionInjector_1.ActionInjector.injectCreateOAuthActionForMCP(pathUtils_1.pathUtils.getYmlFilePath(projectPath), authType, serverName, registrationId, mcpServerUrl, oauthAuthorizationUrl, oauthTokenUrl, oauthRefreshUrl);
+            const injectResult = await (0, mcpAuthScaffolder_1.injectMCPAuthActionToYml)({
+                ymlPath: pathUtils_1.pathUtils.getYmlFilePath(projectPath),
+                authType,
+                authName: serverName,
+                registrationId,
+                mcpServerUrl,
+                endpoints: mcpAuthEndpoints,
+            });
+            // This flow has no scaffolding summary to fall back on, so surface the placeholders
+            // directly — otherwise provision fails later with an opaque error.
+            if (injectResult.wellKnownUrlPlaceholderUsed) {
+                void context.userInteraction.showMessage("warn", (0, localizeUtils_1.getLocalizedString)("core.MCPForDA.mcpAuthDcrPlaceholderWarning"), false);
+            }
+            if (injectResult.oauthUrlPlaceholderUsed) {
+                void context.userInteraction.showMessage("warn", (0, localizeUtils_1.getLocalizedString)("core.MCPForDA.mcpAuthOAuthPlaceholderWarning"), false);
+            }
         }
         void context.userInteraction
             .showMessage("info", (0, localizeUtils_1.getLocalizedString)("core.MCPForDA.updatePluginManifest", aiPluginFilePathRelative), false, "Provision")
@@ -196,6 +271,611 @@ class FxCoreDeclarativeAgentPart {
     provisionResources(_inputs) {
         throw new Error("Method not implemented.");
     }
+    // These methods will be implemented by FxCore
+    parseAuthNameAndScheme(_listResult, _inputs) {
+        throw new Error("Method not implemented.");
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async updateAuthActionInYaml(_authName, _authScheme, _projectPath, _apSpecPath, _pluginManifestPath, _forceToAddNew) {
+        throw new Error("Method not implemented.");
+    }
+    /**
+     * Add plugin
+     */
+    async addPlugin(inputs) {
+        if (!inputs.projectPath) {
+            throw new Error("projectPath is undefined"); // should never happen
+        }
+        const projectPath = inputs.projectPath;
+        const context = (0, globalVars_1.createContext)();
+        const isGenerateFromApiSpec = inputs[constants_2.QuestionNames.ActionType] === constants_2.ActionStartOptions.apiSpec().id;
+        const isGenerateFromMCP = inputs[constants_2.QuestionNames.ActionType] === constants_2.ActionStartOptions.mcp().id;
+        const useMCPDTModifyFlow = isGenerateFromMCP && featureFlags_1.featureFlagManager.getBooleanValue(featureFlags_1.FeatureFlags.MCPForDADT);
+        // VS Code MCP "Add Action" flow: aligned with the "DA with MCP" scaffolding
+        // behavior. Only the MCP server URL is collected from the user. The toolkit
+        // writes the URL into .vscode/mcp.json and signals the caller to open the
+        // file and surface the "start MCP server / Fetch Action" notification, which
+        // already exists for the scaffolding flow. The actual plugin manifest and DA
+        // action are produced later by the "Update Action with MCP" command.
+        //
+        // The CLI flow (below) keeps the original non-interactive behavior of
+        // probing the MCP server, fetching tools and writing ai-plugin.json + yaml
+        // OAuth registration, since the CLI has no equivalent notification UX.
+        //
+        // Under the Dynamic Tool Discovery (DT) flag this early redirect is skipped
+        // so that VS Code runs the same inline scaffolder as the CLI. DT owns the
+        // generated content shape; it must not depend on the global v4 feature flag.
+        if (isGenerateFromMCP && inputs.platform === teamsfx_api_1.Platform.VSCode && !useMCPDTModifyFlow) {
+            return await this.addPluginFromMCP(inputs, context);
+        }
+        // VS Code MCP inline flow (DT on) skips the Teams-manifest picker; infer
+        // the path from `projectPath/appPackage/manifest.json` to match the leaner
+        // `updateActionWithMCP` UX. CLI and non-MCP flows still supply ManifestPath
+        // via the question tree / `--manifest-file`.
+        const teamsManifestPath = inputs[constants_2.QuestionNames.ManifestPath] ??
+            path.join(inputs.projectPath, teamsfx_api_1.AppPackageFolderName, teamsfx_api_1.ManifestTemplateFileName);
+        const appPackageFolder = path.dirname(teamsManifestPath);
+        // validate the project is valid for adding plugin
+        const manifestRes = await ManifestUtils_1.manifestUtils._readAppManifest(teamsManifestPath);
+        if (manifestRes.isErr()) {
+            return (0, teamsfx_api_1.err)(manifestRes.error);
+        }
+        const teamsManifest = manifestRes.value;
+        const declarativeGpt = teamsManifest.copilotExtensions
+            ? teamsManifest.copilotExtensions.declarativeCopilots?.[0]
+            : teamsManifest.copilotAgents?.declarativeAgents?.[0];
+        if (!declarativeGpt?.file) {
+            return (0, teamsfx_api_1.err)(results_1.AppStudioResultFactory.UserError(errors_1.AppStudioError.TeamsAppRequiredPropertyMissingError.name, errors_1.AppStudioError.TeamsAppRequiredPropertyMissingError.message("declarativeAgents", teamsManifestPath)));
+        }
+        if (useMCPDTModifyFlow && featureFlags_1.featureFlagManager.getBooleanValue(featureFlags_1.FeatureFlags.V4Enabled)) {
+            const entryParams = {
+                teamsManifestPath: targetRelativePath(projectPath, teamsManifestPath),
+            };
+            const mcpServerUrl = inputs[constants_2.QuestionNames.MCPForDAServerUrl];
+            if (typeof mcpServerUrl === "string") {
+                entryParams.mcpServerUrl = mcpServerUrl;
+            }
+            const authType = inputs[constants_2.QuestionNames.MCPForDAAuthType];
+            if (typeof authType === "string") {
+                entryParams.authType = authType;
+            }
+            const appName = teamsManifest.name.short.replace("${{APP_NAME_SUFFIX}}", "");
+            return await exports.fxCoreDeclarativeAgentDeps.modifyProjectFrontDoor(inputs, { addCapability: "add-action", actionSource: "mcp" }, entryParams, {
+                resolveArtifactSnapshot: exports.fxCoreDeclarativeAgentDeps.resolveV4TemplateArtifactSnapshot,
+                scaffoldV4: async (frontDoorInputs, target, answers, resolvedPackage) => {
+                    const resolvedMcpServerUrl = answers.mcpServerUrl;
+                    const resolvedTeamsManifestPath = answers.teamsManifestPath;
+                    const resolvedAuthType = answers.authType;
+                    if (typeof resolvedMcpServerUrl !== "string" ||
+                        typeof resolvedTeamsManifestPath !== "string" ||
+                        typeof resolvedAuthType !== "string") {
+                        return (0, teamsfx_api_1.err)(new teamsfx_api_1.SystemError({
+                            source: "FxCore",
+                            name: "InvalidAddMcpServerAnswers",
+                            message: "The MCP add-action inputs are incomplete.",
+                        }));
+                    }
+                    return await exports.fxCoreDeclarativeAgentDeps.scaffoldAddMcpServerFromV4({
+                        templateId: target.templateId,
+                        projectPath,
+                        platform: frontDoorInputs.platform,
+                        teamsManifestPath: resolvedTeamsManifestPath,
+                        appName,
+                        mcpServerUrl: resolvedMcpServerUrl,
+                        authType: resolvedAuthType,
+                        resolvedPackage,
+                    });
+                },
+            });
+        }
+        const gptManifestFilePathRes = await CopilotGptManifestUtils_1.copilotGptManifestUtils.getManifestPath(teamsManifestPath);
+        if (gptManifestFilePathRes.isErr()) {
+            return (0, teamsfx_api_1.err)(gptManifestFilePathRes.error);
+        }
+        const declarativeCopilotManifestPath = gptManifestFilePathRes.value;
+        const declarativeCopilotManifesRes = await CopilotGptManifestUtils_1.copilotGptManifestUtils.readCopilotGptManifestFile(declarativeCopilotManifestPath);
+        if (declarativeCopilotManifesRes.isErr()) {
+            return (0, teamsfx_api_1.err)(declarativeCopilotManifesRes.error);
+        }
+        const declarativeCopilotManifest = declarativeCopilotManifesRes.value;
+        const mcpAuthTypeChoice = inputs[constants_2.QuestionNames.MCPForDAAuthType];
+        const mcpTouchesYml = isGenerateFromMCP && mcpAuthTypeChoice && mcpAuthTypeChoice !== "none";
+        let confirmMessage = (0, localizeUtils_1.getLocalizedString)(isGenerateFromMCP
+            ? mcpTouchesYml
+                ? "core.addApi.confirm.mcp.teamsYaml"
+                : "core.addApi.confirm.mcp"
+            : "core.addApi.confirm", path.relative(inputs.projectPath, appPackageFolder), ...(mcpTouchesYml ? [versionMetadata_1.MetadataV4.configFile] : []));
+        // Will be used if generating from API spec
+        let specParser = undefined;
+        let authNameAndSchemes = [];
+        if (isGenerateFromApiSpec) {
+            specParser = new m365_spec_parser_1.SpecParser(inputs[constants_2.QuestionNames.ApiSpecLocation].trim(), (0, helper_2.getParserOptions)(m365_spec_parser_1.ProjectType.Copilot, true));
+            const listResult = await (0, daSpecParser_1.listAPIInfo)(inputs[constants_2.QuestionNames.ApiSpecLocation].trim());
+            authNameAndSchemes = this.parseAuthNameAndScheme(listResult, inputs);
+            if (authNameAndSchemes.length > 0) {
+                const doesLocalYamlPathExists = await fs_extra_1.default.pathExists(path.join(inputs.projectPath, versionMetadata_1.MetadataV3.localConfigFile));
+                confirmMessage = doesLocalYamlPathExists
+                    ? (0, localizeUtils_1.getLocalizedString)("core.addApi.confirm.localTeamsYaml", path.relative(inputs.projectPath, appPackageFolder), versionMetadata_1.MetadataV4.localConfigFile, versionMetadata_1.MetadataV4.configFile)
+                    : (0, localizeUtils_1.getLocalizedString)("core.addApi.confirm.teamsYaml", path.relative(inputs.projectPath, appPackageFolder), versionMetadata_1.MetadataV4.configFile);
+            }
+        }
+        // confirm
+        // VS Code MCP inline flow (DT on) skips the confirmation modal to match
+        // the leaner `updateActionWithMCP` UX; writes happen as soon as the last
+        // required answer is provided. CLI interactive and other flows still show it.
+        const skipConfirmModal = useMCPDTModifyFlow && inputs.platform === teamsfx_api_1.Platform.VSCode;
+        if (!skipConfirmModal) {
+            const confirmRes = await context.userInteraction.showMessage("warn", confirmMessage, true, (0, localizeUtils_1.getLocalizedString)("core.addApi.continue"));
+            if (confirmRes.isErr()) {
+                return (0, teamsfx_api_1.err)(confirmRes.error);
+            }
+            else if (confirmRes.value !== (0, localizeUtils_1.getLocalizedString)("core.addApi.continue")) {
+                return (0, teamsfx_api_1.err)(new common_2.UserCancelError());
+            }
+        }
+        // find the next available action id
+        let actionId = "";
+        let suffix = 1;
+        actionId = `action_${suffix}`;
+        const existingActionIds = declarativeCopilotManifest.actions?.map((action) => action.id);
+        while (existingActionIds?.includes(actionId)) {
+            suffix += 1;
+            actionId = `action_${suffix}`;
+        }
+        let destinationPluginManifestPath;
+        // generate files
+        if (isGenerateFromApiSpec && specParser) {
+            destinationPluginManifestPath =
+                await CopilotGptManifestUtils_1.copilotGptManifestUtils.getDefaultNextAvailablePluginManifestPath(appPackageFolder, undefined);
+            const destinationApiSpecPath = await PluginManifestUtils_1.pluginManifestUtils.getDefaultNextAvailableApiSpecPath(inputs[constants_2.QuestionNames.ApiSpecLocation].trim(), path.join(appPackageFolder, teamsfx_api_1.DefaultApiSpecFolderName));
+            const generateRes = await openApiSpecHelperModule.generateFromApiSpec(specParser, teamsManifestPath, inputs, context, teamsfx_api_1.Stage.addPlugin, m365_spec_parser_1.ProjectType.Copilot, {
+                destinationApiSpecFilePath: destinationApiSpecPath,
+                pluginManifestFilePath: destinationPluginManifestPath,
+            }, inputs[constants_2.QuestionNames.ApiSpecLocation].trim());
+            if (generateRes.isErr()) {
+                return (0, teamsfx_api_1.err)(generateRes.error);
+            }
+            const warnings = generateRes.value.warnings;
+            if (warnings && warnings.length > 0) {
+                const warnSummary = await openApiSpecHelperModule.generateScaffoldingSummary(warnings, manifestRes.value, path.relative(inputs.projectPath, destinationApiSpecPath), path.relative(inputs.projectPath, destinationPluginManifestPath), inputs.projectPath);
+                context.logProvider.info(warnSummary + "\n");
+            }
+            const addActionRes = await CopilotGptManifestUtils_1.copilotGptManifestUtils.addAction(declarativeCopilotManifestPath, actionId, (0, utils_1.normalizePath)(path.relative(appPackageFolder, destinationPluginManifestPath), true));
+            if (addActionRes.isErr()) {
+                return (0, teamsfx_api_1.err)(addActionRes.error);
+            }
+            for (const authNameAndScheme of authNameAndSchemes) {
+                await this.updateAuthActionInYaml(authNameAndScheme.authName, authNameAndScheme.authScheme, inputs.projectPath, destinationApiSpecPath, destinationPluginManifestPath);
+            }
+        }
+        else if (isGenerateFromMCP) {
+            // CLI MCP action: create ai-plugin.json with MCP runtime config.
+            // (VS Code path is handled earlier by addPluginFromMCP.)
+            const mcpServerUrl = inputs[constants_2.QuestionNames.MCPForDAServerUrl];
+            const toolsFilePath = inputs[constants_2.QuestionNames.MCPToolsFilePath];
+            const mcpWarnings = [];
+            // Validate: --mcp-da-server-url is required for MCP actions
+            if (!mcpServerUrl) {
+                return (0, teamsfx_api_1.err)(new teamsfx_api_1.UserError(teamsfx_api_1.Stage.addPlugin, "MissingMCPServerUrl", (0, localizeUtils_1.getLocalizedString)("core.MCPForDA.missingServerUrl"), (0, localizeUtils_1.getLocalizedString)("core.MCPForDA.missingServerUrl")));
+            }
+            // Dynamic Tool Discovery flow: write a URL-only plugin manifest directly
+            // and reuse the shared MCP auth injector. DT owns the generated content
+            // and must NOT depend on the v4 modify front door. The runtime carries
+            // only the MCP server URL (dynamic discovery is the host default) — no
+            // static tools list, no `mcp_tool_description`, no
+            // `enable_dynamic_discovery`.
+            if (useMCPDTModifyFlow) {
+                const authType = inputs[constants_2.QuestionNames.MCPForDAAuthType];
+                // Name the plugin namespace + oauth/register action after the MCP server
+                // URL (shared verbatim with the create flow via deriveMCPNamespaceFromUrl
+                // / deriveMCPRegistrationIdFromUrl). This keeps one registration per
+                // server: re-adding the same server reuses the same `oauth/register`
+                // (idempotent on registrationId), while a different server gets its own.
+                const namespace = (0, helper_1.deriveMCPNamespaceFromUrl)(mcpServerUrl);
+                const registrationId = (0, helper_1.deriveMCPRegistrationIdFromUrl)(mcpServerUrl);
+                destinationPluginManifestPath =
+                    await CopilotGptManifestUtils_1.copilotGptManifestUtils.getDefaultNextAvailablePluginManifestPath(appPackageFolder, undefined);
+                const pluginManifest = {
+                    $schema: "https://developer.microsoft.com/json-schemas/copilot/plugin/v2.4/schema.json",
+                    schema_version: "v2.4",
+                    name_for_human: manifestRes.value.name?.short ?? path.basename(projectPath),
+                    description_for_human: "Action powered by MCP server",
+                    contact_email: "publisher-email@example.com",
+                    namespace,
+                    functions: [],
+                    runtimes: [
+                        {
+                            type: "RemoteMCPServer",
+                            spec: { url: mcpServerUrl },
+                            run_for_functions: ["*"],
+                            auth: (0, mcpAuthScaffolder_1.deriveMCPManifestOAuth)(authType, registrationId) ?? { type: "None" },
+                        },
+                    ],
+                };
+                if (authType && authType !== "none") {
+                    // Uppercased server name drives the credential env-var suffix
+                    // (`MCP_DA_OAUTH_CLIENT_ID_<NAME>` ...). Shared with the create flow so
+                    // a created project and a re-add of the same server reuse the same vars.
+                    const serverName = (0, helper_1.deriveMCPServerNameFromUrl)(mcpServerUrl).toUpperCase();
+                    // The add question tree does not collect the auth-server metadata /
+                    // well-known URL, so — mirroring the create flow — probe the MCP
+                    // server to discover it when the caller didn't pass one. The result
+                    // feeds resolveMCPAuthEndpoints so oauth/register + dcr/register get
+                    // real authorization/token/well-known URLs. Only oauth / oauth-dynamic
+                    // consume metadata; entra-sso resolves no endpoints, so skip the
+                    // (10s-timeout) probe for it.
+                    const needsMetadataProbe = authType === "oauth" || authType === "oauth-dynamic";
+                    if (needsMetadataProbe && !inputs[constants_2.QuestionNames.MCPForDAAuthMetadataUrl]) {
+                        try {
+                            const { probeMCPServerAuth } = await Promise.resolve().then(() => tslib_1.__importStar(require("../component/utils/mcpToolFetcher")));
+                            const authProbe = await probeMCPServerAuth(mcpServerUrl);
+                            if (authProbe.authMetadataUrl) {
+                                inputs[constants_2.QuestionNames.MCPForDAAuthMetadataUrl] = authProbe.authMetadataUrl;
+                            }
+                            // Same advisory warning the create flow raises on its DT branch: this branch
+                            // never fetches tools, so a URL that is not an MCP endpoint would otherwise
+                            // leave no trace — endpoint discovery falls back to the host and the action
+                            // looks complete.
+                            if (authProbe.endpointStatus === "notEndpoint") {
+                                mcpWarnings.push({
+                                    type: "mcpServerUrlNotAnEndpoint",
+                                    content: (0, localizeUtils_1.getLocalizedString)("core.MCPForDA.mcpServerUrlNotAnEndpoint", mcpServerUrl, String(authProbe.responseStatus)),
+                                });
+                            }
+                        }
+                        catch {
+                            // best-effort probe; endpoint resolution below tolerates undefined
+                        }
+                    }
+                    // Endpoint resolution is best-effort and MUST NOT block the
+                    // oauth/register injection: an unreachable server or missing metadata
+                    // leaves endpoints empty and the injector still writes the action
+                    // (with placeholder URLs) so the developer can fill them in later.
+                    let endpoints = {};
+                    try {
+                        endpoints = await (0, mcpAuthScaffolder_1.resolveMCPAuthEndpoints)(authType, inputs);
+                    }
+                    catch (error) {
+                        mcpWarnings.push({
+                            type: "mcpAuthMetadataError",
+                            content: (0, localizeUtils_1.getLocalizedString)("core.MCPForDA.mcpAuthMetadataMissingError", error.message),
+                        });
+                    }
+                    try {
+                        const ymlPath = pathUtils_1.pathUtils.getYmlFilePath(inputs.projectPath);
+                        if (ymlPath) {
+                            const injectResult = await (0, mcpAuthScaffolder_1.injectMCPAuthActionToYml)({
+                                ymlPath,
+                                authType,
+                                authName: namespace,
+                                registrationId,
+                                mcpServerUrl,
+                                endpoints,
+                                persistCredentialEnvRefs: true,
+                                serverName,
+                                scopes: inputs[constants_2.QuestionNames.MCPForDAScopes],
+                            });
+                            if (injectResult.wellKnownUrlPlaceholderUsed) {
+                                mcpWarnings.push({
+                                    type: "mcpAuthDcrWellKnownUrlPlaceholder",
+                                    content: (0, localizeUtils_1.getLocalizedString)("core.MCPForDA.mcpAuthDcrPlaceholderWarning"),
+                                });
+                            }
+                            if (injectResult.oauthUrlPlaceholderUsed) {
+                                mcpWarnings.push({
+                                    type: "mcpAuthOAuthUrlPlaceholder",
+                                    content: (0, localizeUtils_1.getLocalizedString)("core.MCPForDA.mcpAuthOAuthPlaceholderWarning"),
+                                });
+                            }
+                        }
+                    }
+                    catch (error) {
+                        mcpWarnings.push({
+                            type: "mcpAuthMetadataError",
+                            content: (0, localizeUtils_1.getLocalizedString)("core.MCPForDA.mcpAuthMetadataMissingError", error.message),
+                        });
+                    }
+                    // Persist the client id / secret / scopes the user entered into env
+                    // files so the `${{...}}` refs stamped above resolve at provision time.
+                    // No-op for oauth-dynamic / none. Mirrors the create flow.
+                    try {
+                        await (0, mcpAuthScaffolder_1.persistMCPAuthCredentialEnvVars)({
+                            projectPath,
+                            authType,
+                            serverName,
+                            clientId: inputs[constants_2.QuestionNames.MCPForDAClientId],
+                            clientSecret: inputs[constants_2.QuestionNames.MCPForDAClientSecret],
+                            scopes: inputs[constants_2.QuestionNames.MCPForDAScopes],
+                        });
+                    }
+                    catch (error) {
+                        mcpWarnings.push({
+                            type: "mcpAuthEnvPersistError",
+                            content: (0, localizeUtils_1.getLocalizedString)("core.MCPForDA.mcpAuthMetadataMissingError", error.message),
+                        });
+                    }
+                }
+                await fs_extra_1.default.ensureFile(destinationPluginManifestPath);
+                await fs_extra_1.default.writeJSON(destinationPluginManifestPath, pluginManifest, { spaces: 4 });
+                const addActionRes = await CopilotGptManifestUtils_1.copilotGptManifestUtils.addAction(declarativeCopilotManifestPath, actionId, (0, utils_1.normalizePath)(path.relative(appPackageFolder, destinationPluginManifestPath), true));
+                if (addActionRes.isErr()) {
+                    return (0, teamsfx_api_1.err)(addActionRes.error);
+                }
+                for (const warning of mcpWarnings) {
+                    context.logProvider.warning(warning.content);
+                }
+            }
+            else {
+                // Load tools from file if provided and not yet loaded
+                const existingTools = inputs[constants_2.QuestionNames.MCPForDAAvailableTools];
+                if (toolsFilePath && (!existingTools || existingTools.length === 0)) {
+                    try {
+                        const { readMCPToolsFromFile } = await Promise.resolve().then(() => tslib_1.__importStar(require("../component/utils/mcpToolFetcher")));
+                        const fileTools = await readMCPToolsFromFile(toolsFilePath);
+                        inputs[constants_2.QuestionNames.MCPForDAAvailableTools] = fileTools;
+                        if (!inputs[constants_2.QuestionNames.MCPForDAPreFetchTools]) {
+                            inputs[constants_2.QuestionNames.MCPForDAPreFetchTools] = fileTools.map((t) => t.name);
+                        }
+                    }
+                    catch {
+                        mcpWarnings.push({
+                            type: "mcpToolsFileReadError",
+                            content: (0, localizeUtils_1.getLocalizedString)("core.MCPForDA.toolsFileReadError", toolsFilePath, mcpAddActionHint),
+                        });
+                    }
+                }
+                // Probe auth if tools were loaded from file but auth not yet detected
+                if (inputs[constants_2.QuestionNames.MCPForDAAvailableTools]?.length > 0 &&
+                    !inputs[constants_2.QuestionNames.MCPForDAAuth] &&
+                    mcpServerUrl) {
+                    try {
+                        const { probeMCPServerAuth } = await Promise.resolve().then(() => tslib_1.__importStar(require("../component/utils/mcpToolFetcher")));
+                        const authProbe = await probeMCPServerAuth(mcpServerUrl);
+                        if (authProbe.requiresAuth) {
+                            inputs[constants_2.QuestionNames.MCPForDAAuth] = "OAuthPluginVault";
+                            if (authProbe.authMetadataUrl) {
+                                inputs[constants_2.QuestionNames.MCPForDAAuthMetadataUrl] = authProbe.authMetadataUrl;
+                            }
+                        }
+                    }
+                    catch {
+                        // Auth probe failed - continue without auth
+                    }
+                }
+                // Auto-fetch tools if not yet loaded (CLI flow for no-auth servers)
+                const currentTools = inputs[constants_2.QuestionNames.MCPForDAAvailableTools];
+                if ((!currentTools || currentTools.length === 0) && mcpServerUrl) {
+                    try {
+                        const { fetchMCPTools } = await Promise.resolve().then(() => tslib_1.__importStar(require("../component/utils/mcpToolFetcher")));
+                        const result = await fetchMCPTools(mcpServerUrl);
+                        if (!result.requiresAuth && result.tools.length > 0) {
+                            inputs[constants_2.QuestionNames.MCPForDAAvailableTools] = result.tools;
+                            if (!inputs[constants_2.QuestionNames.MCPForDAPreFetchTools]) {
+                                inputs[constants_2.QuestionNames.MCPForDAPreFetchTools] = result.tools.map((t) => t.name);
+                            }
+                        }
+                        else if (result.requiresAuth) {
+                            // Store auth metadata for later use
+                            inputs[constants_2.QuestionNames.MCPForDAAuth] = "OAuthPluginVault";
+                            if (result.authMetadataUrl) {
+                                inputs[constants_2.QuestionNames.MCPForDAAuthMetadataUrl] = result.authMetadataUrl;
+                            }
+                            mcpWarnings.push({
+                                type: "mcpAuthRequired",
+                                content: (0, localizeUtils_1.getLocalizedString)("core.MCPForDA.authRequired", mcpServerUrl, mcpAddActionHint),
+                            });
+                        }
+                        else {
+                            mcpWarnings.push({
+                                type: "mcpNoToolsFetched",
+                                content: (0, localizeUtils_1.getLocalizedString)("core.MCPForDA.noToolsFetched", mcpServerUrl, mcpAddActionHint),
+                            });
+                        }
+                    }
+                    catch {
+                        mcpWarnings.push({
+                            type: "mcpFetchError",
+                            content: (0, localizeUtils_1.getLocalizedString)("core.MCPForDA.fetchError", mcpServerUrl, mcpAddActionHint),
+                        });
+                    }
+                }
+                // If no tools available (auth required or fetch failed), skip creating plugin - just warn
+                const mcpTools = inputs[constants_2.QuestionNames.MCPForDAAvailableTools];
+                const mcpToolsSelected = inputs[constants_2.QuestionNames.MCPForDAPreFetchTools] || [];
+                if (!mcpTools || mcpTools.length === 0 || mcpToolsSelected.length === 0) {
+                    if (mcpWarnings.length > 0) {
+                        for (const warning of mcpWarnings) {
+                            context.logProvider.warning(warning.content);
+                        }
+                    }
+                    return (0, teamsfx_api_1.ok)(undefined);
+                }
+                destinationPluginManifestPath =
+                    await CopilotGptManifestUtils_1.copilotGptManifestUtils.getDefaultNextAvailablePluginManifestPath(appPackageFolder, undefined);
+                const pluginManifest = {
+                    $schema: "https://developer.microsoft.com/json-schemas/copilot/plugin/v2.4/schema.json",
+                    schema_version: "v2.4",
+                    name_for_human: "MCP Action",
+                    description_for_human: "Action powered by MCP server",
+                    contact_email: "publisher-email@example.com",
+                    namespace: "mcpAction",
+                    functions: [],
+                    runtimes: [],
+                };
+                if (mcpTools && mcpTools.length > 0 && mcpToolsSelected.length > 0) {
+                    const selectedTools = mcpTools.filter((tool) => mcpToolsSelected.includes(tool.name));
+                    pluginManifest.functions = selectedTools.map((tool) => ({
+                        name: tool.name,
+                        description: tool.description || "",
+                    }));
+                    // Write mcp-tools file with full tool definitions (no field filtering)
+                    const mcpToolsFile = `mcp-tools-${suffix}.json`;
+                    const mcpToolsOutputPath = path.join(appPackageFolder, mcpToolsFile);
+                    await fs_extra_1.default.writeJSON(mcpToolsOutputPath, { tools: selectedTools }, { spaces: 4 });
+                    pluginManifest.runtimes = [
+                        {
+                            type: "RemoteMCPServer",
+                            spec: {
+                                url: mcpServerUrl,
+                                mcp_tool_description: {
+                                    file: mcpToolsFile,
+                                },
+                            },
+                            run_for_functions: pluginManifest.functions.map((f) => f.name),
+                        },
+                    ];
+                    // Auth handling
+                    const mcpAuth = inputs[constants_2.QuestionNames.MCPForDAAuth];
+                    if (mcpAuth === "OAuthPluginVault") {
+                        const authType = inputs[constants_2.QuestionNames.MCPForDAAuthType];
+                        if (!authType) {
+                            return (0, teamsfx_api_1.err)(new teamsfx_api_1.UserError(teamsfx_api_1.Stage.addPlugin, "MissingMCPAuthType", (0, localizeUtils_1.getLocalizedString)("core.MCPForDA.missingAuthType"), (0, localizeUtils_1.getLocalizedString)("core.MCPForDA.missingAuthType")));
+                        }
+                        const registrationId = `MCP_DA_AUTH_ID_${actionId.toUpperCase()}`;
+                        const manifestOAuth = (0, mcpAuthScaffolder_1.deriveMCPManifestOAuth)(authType, registrationId);
+                        if (manifestOAuth) {
+                            pluginManifest.runtimes[0].auth = manifestOAuth;
+                        }
+                        // Resolve OAuth metadata and inject oauth/register into m365agents.yml
+                        try {
+                            const endpoints = await (0, mcpAuthScaffolder_1.resolveMCPAuthEndpoints)(authType, inputs);
+                            const ymlPath = pathUtils_1.pathUtils.getYmlFilePath(inputs.projectPath);
+                            if (ymlPath) {
+                                const injectResult = await (0, mcpAuthScaffolder_1.injectMCPAuthActionToYml)({
+                                    ymlPath,
+                                    authType,
+                                    authName: actionId,
+                                    registrationId,
+                                    mcpServerUrl,
+                                    endpoints,
+                                });
+                                if (injectResult.wellKnownUrlPlaceholderUsed) {
+                                    mcpWarnings.push({
+                                        type: "mcpAuthDcrWellKnownUrlPlaceholder",
+                                        content: (0, localizeUtils_1.getLocalizedString)("core.MCPForDA.mcpAuthDcrPlaceholderWarning"),
+                                    });
+                                }
+                                if (injectResult.oauthUrlPlaceholderUsed) {
+                                    mcpWarnings.push({
+                                        type: "mcpAuthOAuthUrlPlaceholder",
+                                        content: (0, localizeUtils_1.getLocalizedString)("core.MCPForDA.mcpAuthOAuthPlaceholderWarning"),
+                                    });
+                                }
+                            }
+                        }
+                        catch (error) {
+                            mcpWarnings.push({
+                                type: "mcpAuthMetadataError",
+                                content: (0, localizeUtils_1.getLocalizedString)("core.MCPForDA.mcpAuthMetadataMissingError", error.message),
+                            });
+                        }
+                    }
+                }
+                await fs_extra_1.default.ensureFile(destinationPluginManifestPath);
+                await fs_extra_1.default.writeJSON(destinationPluginManifestPath, pluginManifest, { spaces: 4 });
+                const addActionRes = await CopilotGptManifestUtils_1.copilotGptManifestUtils.addAction(declarativeCopilotManifestPath, actionId, (0, utils_1.normalizePath)(path.relative(appPackageFolder, destinationPluginManifestPath), true));
+                if (addActionRes.isErr()) {
+                    return (0, teamsfx_api_1.err)(addActionRes.error);
+                }
+                // Surface warnings for CLI
+                if (mcpWarnings.length > 0) {
+                    for (const warning of mcpWarnings) {
+                        context.logProvider.warning(warning.content);
+                    }
+                }
+            }
+            // An unreplaced placeholder guarantees a provision failure later, and the output channel
+            // is easy to miss — more so here, where the action is about to report success. Raise this
+            // one case to a notification, as the create flow does.
+            const placeholderWarning = mcpWarnings.find((warning) => warning.type === "mcpAuthDcrWellKnownUrlPlaceholder" ||
+                warning.type === "mcpAuthOAuthUrlPlaceholder");
+            if (placeholderWarning && inputs.platform === teamsfx_api_1.Platform.VSCode) {
+                const openYml = (0, localizeUtils_1.getLocalizedString)("core.MCPForDA.openYmlFile");
+                const ymlPath = pathUtils_1.pathUtils.getYmlFilePath(inputs.projectPath);
+                void context.userInteraction
+                    .showMessage("warn", placeholderWarning.content, false, openYml)
+                    .then((userRes) => {
+                    if (userRes.isOk() && userRes.value === openYml && ymlPath) {
+                        void globalVars_1.TOOLS?.ui?.openFile?.(ymlPath);
+                    }
+                });
+            }
+        }
+        else {
+            const addPluginRes = await declarativeAgentHelperModule.addExistingPlugin(declarativeCopilotManifestPath, inputs[constants_2.QuestionNames.PluginManifestFilePath].trim(), inputs[constants_2.QuestionNames.PluginOpenApiSpecFilePath].trim(), actionId, context, teamsfx_api_1.Stage.addPlugin);
+            if (addPluginRes.isErr()) {
+                return (0, teamsfx_api_1.err)(addPluginRes.error);
+            }
+            destinationPluginManifestPath = addPluginRes.value.destinationPluginManifestPath;
+            const warningMessage = (0, common_1.outputScaffoldingWarningMessage)(addPluginRes.value.warnings);
+            context.logProvider.info(warningMessage);
+        }
+        if (inputs.platform === teamsfx_api_1.Platform.VSCode) {
+            const successMessage = (0, localizeUtils_1.getLocalizedString)("core.addPlugin.success.vsc", actionId);
+            const viewPluginManifest = (0, localizeUtils_1.getLocalizedString)("core.addPlugin.success.viewPluginManifest");
+            void context.userInteraction
+                .showMessage("info", successMessage, false, viewPluginManifest)
+                .then((userRes) => {
+                if (userRes.isOk() && userRes.value === viewPluginManifest) {
+                    context.telemetryReporter.sendTelemetryEvent(telemetry_1.TelemetryEvent.ViewPluginManifestAfterAdded);
+                    void globalVars_1.TOOLS?.ui?.openFile?.(destinationPluginManifestPath);
+                }
+            });
+        }
+        else {
+            const successMessage = (0, localizeUtils_1.getLocalizedString)("core.addPlugin.success", actionId, destinationPluginManifestPath);
+            void context.userInteraction.showMessage("info", successMessage, false);
+        }
+        return (0, teamsfx_api_1.ok)(undefined);
+    }
+    /**
+     * Adds an MCP server entry to the project's `.vscode/mcp.json` and returns
+     * a marker so the caller (vscode-extension) can open the file and surface
+     * the same "start MCP server / Fetch Action" notification used by the
+     * "DA with MCP" scaffolding flow.
+     */
+    async addPluginFromMCP(inputs, context) {
+        const projectPath = inputs.projectPath;
+        const mcpServerUrl = inputs[constants_2.QuestionNames.MCPForDAServerUrl]?.trim();
+        if (!mcpServerUrl) {
+            return (0, teamsfx_api_1.err)(new teamsfx_api_1.UserError(teamsfx_api_1.Stage.addPlugin, "MissingMCPServerUrl", (0, localizeUtils_1.getDefaultString)("core.MCPForDA.missingServerUrl"), (0, localizeUtils_1.getLocalizedString)("core.MCPForDA.missingServerUrl")));
+        }
+        // Derive a server entry name from the URL host using the same logic as the
+        // "DA with MCP" scaffolding template variable `ServerName`.
+        const serverName = (0, helper_1.deriveMCPServerNameFromUrl)(mcpServerUrl);
+        const mcpConfigDir = path.join(projectPath, ".vscode");
+        const mcpConfigPath = path.join(mcpConfigDir, "mcp.json");
+        let mcpConfig = { servers: {} };
+        if (await fs_extra_1.default.pathExists(mcpConfigPath)) {
+            try {
+                const existing = (await fs_extra_1.default.readJSON(mcpConfigPath));
+                if (existing && typeof existing === "object") {
+                    mcpConfig = {
+                        ...existing,
+                        servers: existing.servers && typeof existing.servers === "object" ? existing.servers : {},
+                    };
+                }
+            }
+            catch {
+                // Existing file is unreadable/invalid JSON — overwrite with a fresh config.
+                mcpConfig = { servers: {} };
+            }
+        }
+        // Ensure unique server entry name to avoid overwriting an existing one.
+        let uniqueName = serverName;
+        let suffix = 1;
+        while (Object.prototype.hasOwnProperty.call(mcpConfig.servers, uniqueName)) {
+            uniqueName = `${serverName}${suffix++}`;
+        }
+        mcpConfig.servers[uniqueName] = {
+            type: "http",
+            url: mcpServerUrl,
+        };
+        await fs_extra_1.default.ensureDir(mcpConfigDir);
+        await fs_extra_1.default.writeJSON(mcpConfigPath, mcpConfig, { spaces: 2 });
+        context.logProvider.info(`MCP server "${uniqueName}" added to ${path.relative(projectPath, mcpConfigPath)}.`);
+        return (0, teamsfx_api_1.ok)({ kind: "mcp", mcpConfigPath });
+    }
 }
 exports.FxCoreDeclarativeAgentPart = FxCoreDeclarativeAgentPart;
 tslib_1.__decorate([
@@ -209,4 +889,15 @@ tslib_1.__decorate([
     tslib_1.__metadata("design:paramtypes", [Object]),
     tslib_1.__metadata("design:returntype", Promise)
 ], FxCoreDeclarativeAgentPart.prototype, "updateActionWithMCP", null);
+tslib_1.__decorate([
+    (0, hooks_1.hooks)([
+        (0, globalVars_1.ErrorContextMW)({ component: "FxCore", stage: teamsfx_api_1.Stage.addPlugin }),
+        errorHandler_1.ErrorHandlerMW,
+        (0, questionMW_1.QuestionMW)("addPlugin"),
+        concurrentLocker_1.ConcurrentLockerMW,
+    ]),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], FxCoreDeclarativeAgentPart.prototype, "addPlugin", null);
 //# sourceMappingURL=FxCore.declarativeAgent.js.map