@microsoft/m365-spec-parser 0.1.1-alpha.8d8f5a0bb.0 → 0.1.1-alpha.a277dba4e.0

package/dist/index.esm2017.mjs

@@ -19,7 +19,8 @@ var ErrorType;
     ErrorType["NoExtraAPICanBeAdded"] = "no-extra-api-can-be-added";
     ErrorType["ResolveServerUrlFailed"] = "resolve-server-url-failed";
     ErrorType["SwaggerNotSupported"] = "swagger-not-supported";
-    ErrorType["MultipleAPIKeyNotSupported"] = "multiple-api-key-not-supported";
+    ErrorType["MultipleAuthNotSupported"] = "multiple-auth-not-supported";
+    ErrorType["SpecVersionNotSupported"] = "spec-version-not-supported";
     ErrorType["ListFailed"] = "list-failed";
     ErrorType["listSupportedAPIInfoFailed"] = "list-supported-api-info-failed";
     ErrorType["FilterSpecFailed"] = "filter-spec-failed";
@@ -50,7 +51,13 @@ var ValidationStatus;
     ValidationStatus[ValidationStatus["Valid"] = 0] = "Valid";
     ValidationStatus[ValidationStatus["Warning"] = 1] = "Warning";
     ValidationStatus[ValidationStatus["Error"] = 2] = "Error";
-})(ValidationStatus || (ValidationStatus = {}));
+})(ValidationStatus || (ValidationStatus = {}));
+var ProjectType;
+(function (ProjectType) {
+    ProjectType[ProjectType["Copilot"] = 0] = "Copilot";
+    ProjectType[ProjectType["SME"] = 1] = "SME";
+    ProjectType[ProjectType["TeamsAi"] = 2] = "TeamsAi";
+})(ProjectType || (ProjectType = {}));
 
 // Copyright (c) Microsoft Corporation.
 class ConstantString {
@@ -69,7 +76,8 @@ ConstantString.ResolveServerUrlFailed = "Unable to resolve the server URL: pleas
 ConstantString.OperationOnlyContainsOptionalParam = "Operation %s contains multiple optional parameters. The first optional parameter is used for this command.";
 ConstantString.ConvertSwaggerToOpenAPI = "The Swagger 2.0 file has been converted to OpenAPI 3.0.";
 ConstantString.SwaggerNotSupported = "Swagger 2.0 is not supported. Please convert to OpenAPI 3.0 manually before proceeding.";
-ConstantString.MultipleAPIKeyNotSupported = "Multiple API keys are not supported. Please make sure that all selected APIs use the same API key.";
+ConstantString.SpecVersionNotSupported = "Unsupported OpenAPI version %s. Please use version 3.0.x.";
+ConstantString.MultipleAuthNotSupported = "Multiple authentication methods are unsupported. Ensure all selected APIs use identical authentication.";
 ConstantString.UnsupportedSchema = "Unsupported schema in %s %s: %s";
 ConstantString.WrappedCardVersion = "devPreview";
 ConstantString.WrappedCardSchema = "https://developer.microsoft.com/json-schemas/teams/vDevPreview/MicrosoftTeams.ResponseRenderingTemplate.schema.json";
@@ -82,6 +90,7 @@ ConstantString.AdaptiveCardType = "AdaptiveCard";
 ConstantString.TextBlockType = "TextBlock";
 ConstantString.ContainerType = "Container";
 ConstantString.RegistrationIdPostfix = "REGISTRATION_ID";
+ConstantString.OAuthRegistrationIdPostFix = "OAUTH_REGISTRATION_ID";
 ConstantString.ResponseCodeFor20X = [
     "200",
     "201",
@@ -141,7 +150,8 @@ ConstantString.FullDescriptionMaxLens = 4000;
 ConstantString.CommandDescriptionMaxLens = 128;
 ConstantString.ParameterDescriptionMaxLens = 128;
 ConstantString.CommandTitleMaxLens = 32;
-ConstantString.ParameterTitleMaxLens = 32;
+ConstantString.ParameterTitleMaxLens = 32;
+ConstantString.SMERequiredParamsMaxNum = 5;
 
 // Copyright (c) Microsoft Corporation.
 class SpecParserError extends Error {
@@ -262,6 +272,9 @@ class Utils {
         }
         return paramResult;
     }
+    static containMultipleMediaTypes(bodyObject) {
+        return Object.keys((bodyObject === null || bodyObject === void 0 ? void 0 : bodyObject.content) || {}).length > 1;
+    }
     /**
      * Checks if the given API is supported.
      * @param {string} method - The HTTP method of the API.
@@ -276,32 +289,40 @@ class Utils {
      * 5. response body should be “application/json” and not empty, and response code should be 20X
      * 6. only support request body with “application/json” content type
      */
-    static isSupportedApi(method, path, spec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2, isCopilot) {
+    static isSupportedApi(method, path, spec, options) {
+        var _a;
         const pathObj = spec.paths[path];
         method = method.toLocaleLowerCase();
         if (pathObj) {
-            if ((method === ConstantString.PostMethod || method === ConstantString.GetMethod) &&
-                pathObj[method]) {
+            if (((_a = options.allowMethods) === null || _a === void 0 ? void 0 : _a.includes(method)) && pathObj[method]) {
                 const securities = pathObj[method].security;
-                const authArray = Utils.getAuthArray(securities, spec);
-                if (!Utils.isSupportedAuth(authArray, allowAPIKeyAuth, allowOauth2)) {
-                    return false;
+                const isTeamsAi = options.projectType === ProjectType.TeamsAi;
+                const isCopilot = options.projectType === ProjectType.Copilot;
+                // Teams AI project doesn't care about auth, it will use authProvider for user to implement
+                if (!isTeamsAi) {
+                    const authArray = Utils.getAuthArray(securities, spec);
+                    if (!Utils.isSupportedAuth(authArray, options)) {
+                        return false;
+                    }
                 }
                 const operationObject = pathObj[method];
-                if (!allowMissingId && !operationObject.operationId) {
+                if (!options.allowMissingId && !operationObject.operationId) {
                     return false;
                 }
                 const paramObject = operationObject.parameters;
                 const requestBody = operationObject.requestBody;
                 const requestJsonBody = requestBody === null || requestBody === void 0 ? void 0 : requestBody.content["application/json"];
-                const mediaTypesCount = Object.keys((requestBody === null || requestBody === void 0 ? void 0 : requestBody.content) || {}).length;
-                if (mediaTypesCount > 1) {
+                if (!isTeamsAi && Utils.containMultipleMediaTypes(requestBody)) {
                     return false;
                 }
-                const responseJson = Utils.getResponseJson(operationObject);
+                const responseJson = Utils.getResponseJson(operationObject, isTeamsAi);
                 if (Object.keys(responseJson).length === 0) {
                     return false;
                 }
+                // Teams AI project doesn't care about request parameters/body
+                if (isTeamsAi) {
+                    return true;
+                }
                 let requestBodyParamResult = {
                     requiredNum: 0,
                     optionalNum: 0,
@@ -326,8 +347,9 @@ class Utils {
                     return true;
                 }
                 if (requestBodyParamResult.requiredNum + paramResult.requiredNum > 1) {
-                    if (allowMultipleParameters &&
-                        requestBodyParamResult.requiredNum + paramResult.requiredNum <= 5) {
+                    if (options.allowMultipleParameters &&
+                        requestBodyParamResult.requiredNum + paramResult.requiredNum <=
+                            ConstantString.SMERequiredParamsMaxNum) {
                         return true;
                     }
                     return false;
@@ -346,29 +368,20 @@ class Utils {
         }
         return false;
     }
-    static isSupportedAuth(authSchemaArray, allowAPIKeyAuth, allowOauth2) {
-        if (authSchemaArray.length === 0) {
+    static isSupportedAuth(authSchemeArray, options) {
+        if (authSchemeArray.length === 0) {
             return true;
         }
-        if (allowAPIKeyAuth || allowOauth2) {
+        if (options.allowAPIKeyAuth || options.allowOauth2 || options.allowBearerTokenAuth) {
             // Currently we don't support multiple auth in one operation
-            if (authSchemaArray.length > 0 && authSchemaArray.every((auths) => auths.length > 1)) {
+            if (authSchemeArray.length > 0 && authSchemeArray.every((auths) => auths.length > 1)) {
                 return false;
             }
-            for (const auths of authSchemaArray) {
+            for (const auths of authSchemeArray) {
                 if (auths.length === 1) {
-                    if (!allowOauth2 && allowAPIKeyAuth && Utils.isAPIKeyAuth(auths[0].authSchema)) {
-                        return true;
-                    }
-                    else if (!allowAPIKeyAuth &&
-                        allowOauth2 &&
-                        Utils.isBearerTokenAuth(auths[0].authSchema)) {
-                        return true;
-                    }
-                    else if (allowAPIKeyAuth &&
-                        allowOauth2 &&
-                        (Utils.isAPIKeyAuth(auths[0].authSchema) ||
-                            Utils.isBearerTokenAuth(auths[0].authSchema))) {
+                    if ((options.allowAPIKeyAuth && Utils.isAPIKeyAuth(auths[0].authScheme)) ||
+                        (options.allowOauth2 && Utils.isOAuthWithAuthCodeFlow(auths[0].authScheme)) ||
+                        (options.allowBearerTokenAuth && Utils.isBearerTokenAuth(auths[0].authScheme))) {
                         return true;
                     }
                 }
@@ -376,13 +389,17 @@ class Utils {
         }
         return false;
     }
-    static isAPIKeyAuth(authSchema) {
-        return authSchema.type === "apiKey";
+    static isBearerTokenAuth(authScheme) {
+        return authScheme.type === "http" && authScheme.scheme === "bearer";
     }
-    static isBearerTokenAuth(authSchema) {
-        return (authSchema.type === "oauth2" ||
-            authSchema.type === "openIdConnect" ||
-            (authSchema.type === "http" && authSchema.scheme === "bearer"));
+    static isAPIKeyAuth(authScheme) {
+        return authScheme.type === "apiKey";
+    }
+    static isOAuthWithAuthCodeFlow(authScheme) {
+        if (authScheme.type === "oauth2" && authScheme.flows && authScheme.flows.authorizationCode) {
+            return true;
+        }
+        return false;
     }
     static getAuthArray(securities, spec) {
         var _a;
@@ -395,7 +412,7 @@ class Utils {
                 for (const name in security) {
                     const auth = securitySchemas[name];
                     authArray.push({
-                        authSchema: auth,
+                        authScheme: auth,
                         name: name,
                     });
                 }
@@ -410,18 +427,19 @@ class Utils {
     static updateFirstLetter(str) {
         return str.charAt(0).toUpperCase() + str.slice(1);
     }
-    static getResponseJson(operationObject) {
+    static getResponseJson(operationObject, isTeamsAiProject = false) {
         var _a, _b;
         let json = {};
         for (const code of ConstantString.ResponseCodeFor20X) {
             const responseObject = (_a = operationObject === null || operationObject === void 0 ? void 0 : operationObject.responses) === null || _a === void 0 ? void 0 : _a[code];
-            const mediaTypesCount = Object.keys((responseObject === null || responseObject === void 0 ? void 0 : responseObject.content) || {}).length;
-            if (mediaTypesCount > 1) {
-                return {};
-            }
             if ((_b = responseObject === null || responseObject === void 0 ? void 0 : responseObject.content) === null || _b === void 0 ? void 0 : _b["application/json"]) {
                 json = responseObject.content["application/json"];
-                break;
+                if (!isTeamsAiProject && Utils.containMultipleMediaTypes(responseObject)) {
+                    json = {};
+                }
+                else {
+                    break;
+                }
             }
         }
         return json;
@@ -495,7 +513,7 @@ class Utils {
         }
         return errors;
     }
-    static validateServer(spec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2, isCopilot) {
+    static validateServer(spec, options) {
         const errors = [];
         let hasTopLevelServers = false;
         let hasPathLevelServers = false;
@@ -516,7 +534,7 @@ class Utils {
             }
             for (const method in methods) {
                 const operationObject = methods[method];
-                if (Utils.isSupportedApi(method, path, spec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2, isCopilot)) {
+                if (Utils.isSupportedApi(method, path, spec, options)) {
                     if ((operationObject === null || operationObject === void 0 ? void 0 : operationObject.servers) && operationObject.servers.length >= 1) {
                         hasOperationLevelServers = true;
                         const serverErrors = Utils.checkServerUrl(operationObject.servers);
@@ -559,6 +577,7 @@ class Utils {
                 Utils.updateParameterWithInputType(schema, parameter);
             }
             if (isRequired && schema.default === undefined) {
+                parameter.isRequired = true;
                 requiredParams.push(parameter);
             }
             else {
@@ -603,7 +622,7 @@ class Utils {
             param.value = schema.default;
         }
     }
-    static parseApiInfo(operationItem, allowMultipleParameters) {
+    static parseApiInfo(operationItem, options) {
         var _a, _b;
         const requiredParams = [];
         const optionalParams = [];
@@ -617,11 +636,12 @@ class Utils {
                     description: ((_a = param.description) !== null && _a !== void 0 ? _a : "").slice(0, ConstantString.ParameterDescriptionMaxLens),
                 };
                 const schema = param.schema;
-                if (allowMultipleParameters && schema) {
+                if (options.allowMultipleParameters && schema) {
                     Utils.updateParameterWithInputType(schema, parameter);
                 }
                 if (param.in !== "header" && param.in !== "cookie") {
                     if (param.required && (schema === null || schema === void 0 ? void 0 : schema.default) === undefined) {
+                        parameter.isRequired = true;
                         requiredParams.push(parameter);
                     }
                     else {
@@ -635,7 +655,7 @@ class Utils {
             const requestJson = requestBody.content["application/json"];
             if (Object.keys(requestJson).length !== 0) {
                 const schema = requestJson.schema;
-                const [requiredP, optionalP] = Utils.generateParametersFromSchema(schema, "requestBody", allowMultipleParameters, requestBody.required);
+                const [requiredP, optionalP] = Utils.generateParametersFromSchema(schema, "requestBody", !!options.allowMultipleParameters, requestBody.required);
                 requiredParams.push(...requiredP);
                 optionalParams.push(...optionalP);
             }
@@ -666,14 +686,13 @@ class Utils {
         }
         return [command, warning];
     }
-    static listSupportedAPIs(spec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2, isCopilot) {
+    static listSupportedAPIs(spec, options) {
         const paths = spec.paths;
         const result = {};
         for (const path in paths) {
             const methods = paths[path];
             for (const method in methods) {
-                // For developer preview, only support GET operation with only 1 parameter without auth
-                if (Utils.isSupportedApi(method, path, spec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2, isCopilot)) {
+                if (Utils.isSupportedApi(method, path, spec, options)) {
                     const operationObject = methods[method];
                     result[`${method.toUpperCase()} ${path}`] = operationObject;
                 }
@@ -681,7 +700,7 @@ class Utils {
         }
         return result;
     }
-    static validateSpec(spec, parser, isSwaggerFile, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2, isCopilot) {
+    static validateSpec(spec, parser, isSwaggerFile, options) {
         const errors = [];
         const warnings = [];
         if (isSwaggerFile) {
@@ -691,7 +710,7 @@ class Utils {
             });
         }
         // Server validation
-        const serverErrors = Utils.validateServer(spec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2, isCopilot);
+        const serverErrors = Utils.validateServer(spec, options);
         errors.push(...serverErrors);
         // Remote reference not supported
         const refPaths = parser.$refs.paths();
@@ -704,7 +723,7 @@ class Utils {
             });
         }
         // No supported API
-        const apiMap = Utils.listSupportedAPIs(spec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2, isCopilot);
+        const apiMap = Utils.listSupportedAPIs(spec, options);
         if (Object.keys(apiMap).length === 0) {
             errors.push({
                 type: ErrorType.NoSupportedApi,
@@ -756,18 +775,31 @@ class Utils {
         }
         return safeRegistrationIdEnvName;
     }
+    static getAllAPICount(spec) {
+        let count = 0;
+        const paths = spec.paths;
+        for (const path in paths) {
+            const methods = paths[path];
+            for (const method in methods) {
+                if (ConstantString.AllOperationMethods.includes(method)) {
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
 }
 
 // Copyright (c) Microsoft Corporation.
 class SpecFilter {
-    static specFilter(filter, unResolveSpec, resolvedSpec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2, isCopilot) {
+    static specFilter(filter, unResolveSpec, resolvedSpec, options) {
         try {
             const newSpec = Object.assign({}, unResolveSpec);
             const newPaths = {};
             for (const filterItem of filter) {
                 const [method, path] = filterItem.split(" ");
                 const methodName = method.toLowerCase();
-                if (!Utils.isSupportedApi(methodName, path, resolvedSpec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2, isCopilot)) {
+                if (!Utils.isSupportedApi(methodName, path, resolvedSpec, options)) {
                     continue;
                 }
                 if (!newPaths[path]) {
@@ -793,7 +825,7 @@ class SpecFilter {
 
 // Copyright (c) Microsoft Corporation.
 class ManifestUpdater {
-    static async updateManifestWithAiPlugin(manifestPath, outputSpecPath, apiPluginFilePath, spec) {
+    static async updateManifestWithAiPlugin(manifestPath, outputSpecPath, apiPluginFilePath, spec, options) {
         const manifest = await fs.readJSON(manifestPath);
         const apiPluginRelativePath = ManifestUpdater.getRelativePath(manifestPath, apiPluginFilePath);
         manifest.plugins = [
@@ -803,7 +835,7 @@ class ManifestUpdater {
         ];
         ManifestUpdater.updateManifestDescription(manifest, spec);
         const specRelativePath = ManifestUpdater.getRelativePath(manifestPath, outputSpecPath);
-        const apiPlugin = ManifestUpdater.generatePluginManifestSchema(spec, specRelativePath);
+        const apiPlugin = ManifestUpdater.generatePluginManifestSchema(spec, specRelativePath, options);
         return [manifest, apiPlugin];
     }
     static updateManifestDescription(manifest, spec) {
@@ -827,7 +859,7 @@ class ManifestUpdater {
         }
         return parameter;
     }
-    static generatePluginManifestSchema(spec, specRelativePath) {
+    static generatePluginManifestSchema(spec, specRelativePath, options) {
         var _a, _b, _c;
         const functions = [];
         const functionNames = [];
@@ -837,7 +869,7 @@ class ManifestUpdater {
             if (pathItem) {
                 const operations = pathItem;
                 for (const method in operations) {
-                    if (ConstantString.AllOperationMethods.includes(method)) {
+                    if (options.allowMethods.includes(method)) {
                         const operationItem = operations[method];
                         if (operationItem) {
                             const operationId = operationItem.operationId;
@@ -910,43 +942,50 @@ class ManifestUpdater {
         };
         return apiPlugin;
     }
-    static async updateManifest(manifestPath, outputSpecPath, adaptiveCardFolder, spec, allowMultipleParameters, auth, isMe) {
+    static async updateManifest(manifestPath, outputSpecPath, spec, options, adaptiveCardFolder, authInfo) {
         try {
             const originalManifest = await fs.readJSON(manifestPath);
             const updatedPart = {};
-            const [commands, warnings] = await ManifestUpdater.generateCommands(spec, adaptiveCardFolder, manifestPath, allowMultipleParameters);
-            const composeExtension = {
-                composeExtensionType: "apiBased",
-                apiSpecificationFile: ManifestUpdater.getRelativePath(manifestPath, outputSpecPath),
-                commands: commands,
-            };
-            if (auth) {
-                if (Utils.isAPIKeyAuth(auth)) {
-                    auth = auth;
-                    const safeApiSecretRegistrationId = Utils.getSafeRegistrationIdEnvName(`${auth.name}_${ConstantString.RegistrationIdPostfix}`);
-                    composeExtension.authorization = {
-                        authType: "apiSecretServiceAuth",
-                        apiSecretServiceAuthConfiguration: {
-                            apiSecretRegistrationId: `\${{${safeApiSecretRegistrationId}}}`,
-                        },
-                    };
-                }
-                else if (Utils.isBearerTokenAuth(auth)) {
-                    composeExtension.authorization = {
-                        authType: "microsoftEntra",
-                        microsoftEntraConfiguration: {
-                            supportsSingleSignOn: true,
-                        },
-                    };
-                    updatedPart.webApplicationInfo = {
-                        id: "${{AAD_APP_CLIENT_ID}}",
-                        resource: "api://${{DOMAIN}}/${{AAD_APP_CLIENT_ID}}",
-                    };
+            updatedPart.composeExtensions = [];
+            let warnings = [];
+            if (options.projectType === ProjectType.SME) {
+                const updateResult = await ManifestUpdater.generateCommands(spec, manifestPath, options, adaptiveCardFolder);
+                const commands = updateResult[0];
+                warnings = updateResult[1];
+                const composeExtension = {
+                    composeExtensionType: "apiBased",
+                    apiSpecificationFile: ManifestUpdater.getRelativePath(manifestPath, outputSpecPath),
+                    commands: commands,
+                };
+                if (authInfo) {
+                    const auth = authInfo.authScheme;
+                    if (Utils.isAPIKeyAuth(auth) || Utils.isBearerTokenAuth(auth)) {
+                        const safeApiSecretRegistrationId = Utils.getSafeRegistrationIdEnvName(`${authInfo.name}_${ConstantString.RegistrationIdPostfix}`);
+                        composeExtension.authorization = {
+                            authType: "apiSecretServiceAuth",
+                            apiSecretServiceAuthConfiguration: {
+                                apiSecretRegistrationId: `\${{${safeApiSecretRegistrationId}}}`,
+                            },
+                        };
+                    }
+                    else if (Utils.isOAuthWithAuthCodeFlow(auth)) {
+                        const safeOAuth2RegistrationId = Utils.getSafeRegistrationIdEnvName(`${authInfo.name}_${ConstantString.OAuthRegistrationIdPostFix}`);
+                        composeExtension.authorization = {
+                            authType: "oAuth2.0",
+                            oAuthConfiguration: {
+                                oauthConfigurationId: `\${{${safeOAuth2RegistrationId}}}`,
+                            },
+                        };
+                        updatedPart.webApplicationInfo = {
+                            id: "${{AAD_APP_CLIENT_ID}}",
+                            resource: "api://${{DOMAIN}}/${{AAD_APP_CLIENT_ID}}",
+                        };
+                    }
                 }
+                updatedPart.composeExtensions = [composeExtension];
             }
             updatedPart.description = originalManifest.description;
             ManifestUpdater.updateManifestDescription(updatedPart, spec);
-            updatedPart.composeExtensions = isMe === undefined || isMe === true ? [composeExtension] : [];
             const updatedManifest = Object.assign(Object.assign({}, originalManifest), updatedPart);
             return [updatedManifest, warnings];
         }
@@ -954,7 +993,8 @@ class ManifestUpdater {
             throw new SpecParserError(err.toString(), ErrorType.UpdateManifestFailed);
         }
     }
-    static async generateCommands(spec, adaptiveCardFolder, manifestPath, allowMultipleParameters) {
+    static async generateCommands(spec, manifestPath, options, adaptiveCardFolder) {
+        var _a;
         const paths = spec.paths;
         const commands = [];
         const warnings = [];
@@ -965,14 +1005,16 @@ class ManifestUpdater {
                     const operations = pathItem;
                     // Currently only support GET and POST method
                     for (const method in operations) {
-                        if (method === ConstantString.PostMethod || method === ConstantString.GetMethod) {
+                        if ((_a = options.allowMethods) === null || _a === void 0 ? void 0 : _a.includes(method)) {
                             const operationItem = operations[method];
                             if (operationItem) {
-                                const [command, warning] = Utils.parseApiInfo(operationItem, allowMultipleParameters);
-                                const adaptiveCardPath = path.join(adaptiveCardFolder, command.id + ".json");
-                                command.apiResponseRenderingTemplateFile = (await fs.pathExists(adaptiveCardPath))
-                                    ? ManifestUpdater.getRelativePath(manifestPath, adaptiveCardPath)
-                                    : "";
+                                const [command, warning] = Utils.parseApiInfo(operationItem, options);
+                                if (adaptiveCardFolder) {
+                                    const adaptiveCardPath = path.join(adaptiveCardFolder, command.id + ".json");
+                                    command.apiResponseRenderingTemplateFile = (await fs.pathExists(adaptiveCardPath))
+                                        ? ManifestUpdater.getRelativePath(manifestPath, adaptiveCardPath)
+                                        : "";
+                                }
                                 if (warning) {
                                     warnings.push(warning);
                                 }
@@ -1255,9 +1297,11 @@ class SpecParser {
             allowMissingId: true,
             allowSwagger: true,
             allowAPIKeyAuth: false,
+            allowBearerTokenAuth: false,
             allowMultipleParameters: false,
             allowOauth2: false,
-            isCopilot: false,
+            allowMethods: ["get", "post"],
+            projectType: ProjectType.SME,
         };
         this.pathOrSpec = pathOrDoc;
         this.parser = new SwaggerParser();
@@ -1290,7 +1334,23 @@ class SpecParser {
                     ],
                 };
             }
-            return Utils.validateSpec(this.spec, this.parser, !!this.isSwaggerFile, this.options.allowMissingId, this.options.allowAPIKeyAuth, this.options.allowMultipleParameters, this.options.allowOauth2, this.options.isCopilot);
+            if (this.options.projectType === ProjectType.SME ||
+                this.options.projectType === ProjectType.Copilot) {
+                if (this.spec.openapi >= "3.1.0") {
+                    return {
+                        status: ValidationStatus.Error,
+                        warnings: [],
+                        errors: [
+                            {
+                                type: ErrorType.SpecVersionNotSupported,
+                                content: Utils.format(ConstantString.SpecVersionNotSupported, this.spec.openapi),
+                                data: this.spec.openapi,
+                            },
+                        ],
+                    };
+                }
+            }
+            return Utils.validateSpec(this.spec, this.parser, !!this.isSwaggerFile, this.options);
         }
         catch (err) {
             throw new SpecParserError(err.toString(), ErrorType.ValidateFailed);
@@ -1311,7 +1371,11 @@ class SpecParser {
             await this.loadSpec();
             const spec = this.spec;
             const apiMap = this.getAllSupportedAPIs(spec);
-            const result = [];
+            const result = {
+                validAPIs: [],
+                allAPICount: 0,
+                validAPICount: 0,
+            };
             for (const apiKey in apiMap) {
                 const apiResult = {
                     api: "",
@@ -1336,13 +1400,15 @@ class SpecParser {
                 const authArray = Utils.getAuthArray(operation.security, spec);
                 for (const auths of authArray) {
                     if (auths.length === 1) {
-                        apiResult.auth = auths[0].authSchema;
+                        apiResult.auth = auths[0];
                         break;
                     }
                 }
                 apiResult.api = apiKey;
-                result.push(apiResult);
+                result.validAPIs.push(apiResult);
             }
+            result.allAPICount = Utils.getAllAPICount(spec);
+            result.validAPICount = result.validAPIs.length;
             return result;
         }
         catch (err) {
@@ -1365,7 +1431,7 @@ class SpecParser {
             if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
                 throw new SpecParserError(ConstantString.CancelledMessage, ErrorType.Cancelled);
             }
-            const newUnResolvedSpec = SpecFilter.specFilter(filter, this.unResolveSpec, this.spec, this.options.allowMissingId, this.options.allowAPIKeyAuth, this.options.allowMultipleParameters, this.options.allowOauth2, this.options.isCopilot);
+            const newUnResolvedSpec = SpecFilter.specFilter(filter, this.unResolveSpec, this.spec, this.options);
             if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
                 throw new SpecParserError(ConstantString.CancelledMessage, ErrorType.Cancelled);
             }
@@ -1406,7 +1472,7 @@ class SpecParser {
             if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
                 throw new SpecParserError(ConstantString.CancelledMessage, ErrorType.Cancelled);
             }
-            const [updatedManifest, apiPlugin] = await ManifestUpdater.updateManifestWithAiPlugin(manifestPath, outputSpecPath, pluginFilePath, newSpec);
+            const [updatedManifest, apiPlugin] = await ManifestUpdater.updateManifestWithAiPlugin(manifestPath, outputSpecPath, pluginFilePath, newSpec, this.options);
             await fs.outputJSON(manifestPath, updatedManifest, { spaces: 2 });
             await fs.outputJSON(pluginFilePath, apiPlugin, { spaces: 2 });
         }
@@ -1424,9 +1490,8 @@ class SpecParser {
      * @param filter An array of strings that represent the filters to apply when generating the artifacts. If filter is empty, it would process nothing.
      * @param outputSpecPath File path of the new OpenAPI specification file to generate. If not specified or empty, no spec file will be generated.
      * @param adaptiveCardFolder Folder path where the Adaptive Card files will be generated. If not specified or empty, Adaptive Card files will not be generated.
-     * @param isMe Boolean that indicates whether the project is an Messaging Extension. For Messaging Extension, composeExtensions will be added in Teams app manifest.
      */
-    async generate(manifestPath, filter, outputSpecPath, adaptiveCardFolder, signal, isMe) {
+    async generate(manifestPath, filter, outputSpecPath, adaptiveCardFolder, signal) {
         const result = {
             allSuccess: true,
             warnings: [],
@@ -1435,23 +1500,23 @@ class SpecParser {
             const newSpecs = await this.getFilteredSpecs(filter, signal);
             const newUnResolvedSpec = newSpecs[0];
             const newSpec = newSpecs[1];
-            const AuthSet = new Set();
-            let hasMultipleAPIKeyAuth = false;
+            const authSet = new Set();
+            let hasMultipleAuth = false;
             for (const url in newSpec.paths) {
                 for (const method in newSpec.paths[url]) {
                     const operation = newSpec.paths[url][method];
                     const authArray = Utils.getAuthArray(operation.security, newSpec);
                     if (authArray && authArray.length > 0) {
-                        AuthSet.add(authArray[0][0].authSchema);
-                        if (AuthSet.size > 1) {
-                            hasMultipleAPIKeyAuth = true;
+                        authSet.add(authArray[0][0]);
+                        if (authSet.size > 1) {
+                            hasMultipleAuth = true;
                             break;
                         }
                     }
                 }
             }
-            if (hasMultipleAPIKeyAuth) {
-                throw new SpecParserError(ConstantString.MultipleAPIKeyNotSupported, ErrorType.MultipleAPIKeyNotSupported);
+            if (hasMultipleAuth && this.options.projectType !== ProjectType.TeamsAi) {
+                throw new SpecParserError(ConstantString.MultipleAuthNotSupported, ErrorType.MultipleAuthNotSupported);
             }
             let resultStr;
             if (outputSpecPath.endsWith(".yaml") || outputSpecPath.endsWith(".yml")) {
@@ -1461,12 +1526,11 @@ class SpecParser {
                 resultStr = JSON.stringify(newUnResolvedSpec, null, 2);
             }
             await fs.outputFile(outputSpecPath, resultStr);
-            if (isMe === undefined || isMe === true) {
-                // Only generate adaptive card for Messaging Extension
+            if (adaptiveCardFolder) {
                 for (const url in newSpec.paths) {
                     for (const method in newSpec.paths[url]) {
-                        // paths object may contain description/summary, so we need to check if it is a operation object
-                        if (method === ConstantString.PostMethod || method === ConstantString.GetMethod) {
+                        // paths object may contain description/summary which is not a http method, so we need to check if it is a operation object
+                        if (this.options.allowMethods.includes(method)) {
                             const operation = newSpec.paths[url][method];
                             try {
                                 const [card, jsonPath] = AdaptiveCardGenerator.generateAdaptiveCard(operation);
@@ -1491,8 +1555,8 @@ class SpecParser {
             if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
                 throw new SpecParserError(ConstantString.CancelledMessage, ErrorType.Cancelled);
             }
-            const auth = Array.from(AuthSet)[0];
-            const [updatedManifest, warnings] = await ManifestUpdater.updateManifest(manifestPath, outputSpecPath, adaptiveCardFolder, newSpec, this.options.allowMultipleParameters, auth, isMe);
+            const authInfo = Array.from(authSet)[0];
+            const [updatedManifest, warnings] = await ManifestUpdater.updateManifest(manifestPath, outputSpecPath, newSpec, this.options, adaptiveCardFolder, authInfo);
             await fs.outputJSON(manifestPath, updatedManifest, { spaces: 2 });
             result.warnings.push(...warnings);
         }
@@ -1521,11 +1585,11 @@ class SpecParser {
         if (this.apiMap !== undefined) {
             return this.apiMap;
         }
-        const result = Utils.listSupportedAPIs(spec, this.options.allowMissingId, this.options.allowAPIKeyAuth, this.options.allowMultipleParameters, this.options.allowOauth2, this.options.isCopilot);
+        const result = Utils.listSupportedAPIs(spec, this.options);
         this.apiMap = result;
         return result;
     }
 }
 
-export { AdaptiveCardGenerator, ConstantString, ErrorType, SpecParser, SpecParserError, Utils, ValidationStatus, WarningType };
+export { AdaptiveCardGenerator, ConstantString, ErrorType, ProjectType, SpecParser, SpecParserError, Utils, ValidationStatus, WarningType };
 //# sourceMappingURL=index.esm2017.mjs.map