@microsoft/m365-spec-parser 0.2.5 → 0.2.6-alpha.0b985f7da.0

package/dist/index.esm2017.mjs

@@ -38,11 +38,8 @@ var ErrorType;
     ErrorType["PostBodyContainMultipleMediaTypes"] = "post-body-contain-multiple-media-types";
     ErrorType["ResponseContainMultipleMediaTypes"] = "response-contain-multiple-media-types";
     ErrorType["ResponseJsonIsEmpty"] = "response-json-is-empty";
-    ErrorType["PostBodySchemaIsNotJson"] = "post-body-schema-is-not-json";
     ErrorType["PostBodyContainsRequiredUnsupportedSchema"] = "post-body-contains-required-unsupported-schema";
     ErrorType["ParamsContainRequiredUnsupportedSchema"] = "params-contain-required-unsupported-schema";
-    ErrorType["ParamsContainsNestedObject"] = "params-contains-nested-object";
-    ErrorType["RequestBodyContainsNestedObject"] = "request-body-contains-nested-object";
     ErrorType["ExceededRequiredParamsLimit"] = "exceeded-required-params-limit";
     ErrorType["NoParameter"] = "no-parameter";
     ErrorType["NoAPIInfo"] = "no-api-info";
@@ -62,6 +59,7 @@ var WarningType;
     WarningType["ConvertSwaggerToOpenAPI"] = "convert-swagger-to-openapi";
     WarningType["FuncDescriptionTooLong"] = "function-description-too-long";
     WarningType["OperationIdContainsSpecialCharacters"] = "operationid-contains-special-characters";
+    WarningType["UnsupportedAuthType"] = "unsupported-auth-type";
     WarningType["GenerateJsonDataFailed"] = "generate-json-data-failed";
     WarningType["Unknown"] = "unknown";
 })(WarningType || (WarningType = {}));
@@ -101,6 +99,7 @@ ConstantString.SwaggerNotSupported = "Swagger 2.0 is not supported. Please conve
 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.OperationIdContainsSpecialCharacters = "Operation id '%s' in OpenAPI description document contained special characters and was renamed to '%s'.";
+ConstantString.AuthTypeIsNotSupported = "Unsupported authorization type in API '%s'. No authorization will be used.";
 ConstantString.UnsupportedSchema = "Unsupported schema in %s %s: %s";
 ConstantString.FuncDescriptionTooLong = "The description of the function '%s' is too long. The current length is %s characters, while the maximum allowed length is %s characters.";
 ConstantString.GenerateJsonDataFailed = "Failed to generate JSON data for api: %s due to %s.";
@@ -110,17 +109,12 @@ ConstantString.WrappedCardResponseLayout = "list";
 ConstantString.GetMethod = "get";
 ConstantString.PostMethod = "post";
 ConstantString.AdaptiveCardVersion = "1.5";
-ConstantString.AdaptiveCardSchema = "http://adaptivecards.io/schemas/adaptive-card.json";
+ConstantString.AdaptiveCardSchema = "https://adaptivecards.io/schemas/adaptive-card.json";
 ConstantString.AdaptiveCardType = "AdaptiveCard";
 ConstantString.TextBlockType = "TextBlock";
 ConstantString.ImageType = "Image";
 ConstantString.ContainerType = "Container";
-ConstantString.RegistrationIdPostfix = {
-    apiKey: "REGISTRATION_ID",
-    oauth2: "CONFIGURATION_ID",
-    http: "REGISTRATION_ID",
-    openIdConnect: "REGISTRATION_ID",
-};
+ConstantString.RegistrationIdPostfix = "REGISTRATION_ID";
 ConstantString.ResponseCodeFor20X = [
     "200",
     "201",
@@ -132,6 +126,7 @@ ConstantString.ResponseCodeFor20X = [
     "207",
     "208",
     "226",
+    "2XX",
     "default",
 ];
 ConstantString.AllOperationMethods = [
@@ -197,17 +192,6 @@ class SpecParserError extends Error {
 
 // Copyright (c) Microsoft Corporation.
 class Utils {
-    static hasNestedObjectInSchema(schema) {
-        if (this.isObjectSchema(schema)) {
-            for (const property in schema.properties) {
-                const nestedSchema = schema.properties[property];
-                if (this.isObjectSchema(nestedSchema)) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
     static isObjectSchema(schema) {
         return schema.type === "object" || (!schema.type && !!schema.properties);
     }
@@ -220,11 +204,32 @@ class Utils {
     static isAPIKeyAuth(authScheme) {
         return authScheme.type === "apiKey";
     }
+    static isAPIKeyAuthButNotInCookie(authScheme) {
+        return authScheme.type === "apiKey" && authScheme.in !== "cookie";
+    }
     static isOAuthWithAuthCodeFlow(authScheme) {
         return !!(authScheme.type === "oauth2" &&
             authScheme.flows &&
             authScheme.flows.authorizationCode);
     }
+    static isNotSupportedAuth(authSchemeArray) {
+        if (authSchemeArray.length === 0) {
+            return false;
+        }
+        if (authSchemeArray.length > 0 && authSchemeArray.every((auths) => auths.length > 1)) {
+            return true;
+        }
+        for (const auths of authSchemeArray) {
+            if (auths.length === 1) {
+                if (Utils.isOAuthWithAuthCodeFlow(auths[0].authScheme) ||
+                    Utils.isBearerTokenAuth(auths[0].authScheme) ||
+                    Utils.isAPIKeyAuthButNotInCookie(auths[0].authScheme)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
     static getAuthArray(securities, spec) {
         var _a;
         const result = [];
@@ -249,6 +254,20 @@ class Utils {
         result.sort((a, b) => a[0].name.localeCompare(b[0].name));
         return result;
     }
+    static getAuthMap(spec) {
+        const authMap = {};
+        for (const url in spec.paths) {
+            for (const method in spec.paths[url]) {
+                const operation = spec.paths[url][method];
+                const authArray = Utils.getAuthArray(operation.security, spec);
+                if (authArray && authArray.length > 0) {
+                    const currentAuth = authArray[0][0];
+                    authMap[operation.operationId] = currentAuth;
+                }
+            }
+        }
+        return authMap;
+    }
     static getAuthInfo(spec) {
         let authInfo = undefined;
         for (const url in spec.paths) {
@@ -277,27 +296,33 @@ class Utils {
         let multipleMediaType = false;
         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];
-            if (responseObject === null || responseObject === void 0 ? void 0 : responseObject.content) {
-                for (const contentType of Object.keys(responseObject.content)) {
-                    // json media type can also be "application/json; charset=utf-8"
-                    if (contentType.indexOf("application/json") >= 0) {
-                        multipleMediaType = false;
-                        json = responseObject.content[contentType];
-                        if (Utils.containMultipleMediaTypes(responseObject)) {
-                            multipleMediaType = true;
-                            if (!allowMultipleMediaType) {
-                                json = {};
-                            }
-                        }
-                        else {
-                            return { json, multipleMediaType };
-                        }
-                    }
-                }
+            if (!responseObject) {
+                continue;
+            }
+            multipleMediaType = Utils.containMultipleMediaTypes(responseObject);
+            if (!allowMultipleMediaType && multipleMediaType) {
+                json = {};
+                continue;
+            }
+            const mediaObj = Utils.getJsonContentType(responseObject);
+            if (Object.keys(mediaObj).length > 0) {
+                json = mediaObj;
+                return { json, multipleMediaType };
             }
         }
         return { json, multipleMediaType };
     }
+    static getJsonContentType(responseObject) {
+        if (responseObject.content) {
+            for (const contentType of Object.keys(responseObject.content)) {
+                // json media type can also be "application/json; charset=utf-8"
+                if (contentType.indexOf("application/json") >= 0) {
+                    return responseObject.content[contentType];
+                }
+            }
+        }
+        return {};
+    }
     static convertPathToCamelCase(path) {
         const pathSegments = path.split(/[./{]/);
         const camelCaseSegments = pathSegments.map((segment) => {
@@ -333,7 +358,7 @@ class Utils {
         }
         return newStr;
     }
-    static checkServerUrl(servers) {
+    static checkServerUrl(servers, allowHttp = false) {
         const errors = [];
         let serverUrl;
         try {
@@ -356,8 +381,7 @@ class Utils {
                 data: servers,
             });
         }
-        else if (protocol !== "https:") {
-            // Http server url is not supported
+        else if (protocol !== "https:" && !(protocol === "http:" && allowHttp)) {
             const protocolString = protocol.slice(0, -1);
             errors.push({
                 type: ErrorType.UrlProtocolNotSupported,
@@ -373,10 +397,11 @@ class Utils {
         let hasTopLevelServers = false;
         let hasPathLevelServers = false;
         let hasOperationLevelServers = false;
+        const allowHttp = options.projectType === ProjectType.Copilot;
         if (spec.servers && spec.servers.length >= 1) {
             hasTopLevelServers = true;
             // for multiple server, we only use the first url
-            const serverErrors = Utils.checkServerUrl(spec.servers);
+            const serverErrors = Utils.checkServerUrl(spec.servers, allowHttp);
             errors.push(...serverErrors);
         }
         const paths = spec.paths;
@@ -384,7 +409,7 @@ class Utils {
             const methods = paths[path];
             if ((methods === null || methods === void 0 ? void 0 : methods.servers) && methods.servers.length >= 1) {
                 hasPathLevelServers = true;
-                const serverErrors = Utils.checkServerUrl(methods.servers);
+                const serverErrors = Utils.checkServerUrl(methods.servers, allowHttp);
                 errors.push(...serverErrors);
             }
             for (const method in methods) {
@@ -392,7 +417,7 @@ class Utils {
                 if (((_a = options.allowMethods) === null || _a === void 0 ? void 0 : _a.includes(method)) && operationObject) {
                     if ((operationObject === null || operationObject === void 0 ? void 0 : operationObject.servers) && operationObject.servers.length >= 1) {
                         hasOperationLevelServers = true;
-                        const serverErrors = Utils.checkServerUrl(operationObject.servers);
+                        const serverErrors = Utils.checkServerUrl(operationObject.servers, allowHttp);
                         errors.push(...serverErrors);
                     }
                 }
@@ -681,22 +706,6 @@ class Validator {
         }
         return result;
     }
-    validateResponse(method, path) {
-        const result = { isValid: true, reason: [] };
-        const operationObject = this.spec.paths[path][method];
-        const { json, multipleMediaType } = Utils.getResponseJson(operationObject);
-        if (this.options.projectType === ProjectType.SME) {
-            // only support response body only contains “application/json” content type
-            if (multipleMediaType) {
-                result.reason.push(ErrorType.ResponseContainMultipleMediaTypes);
-            }
-            else if (Object.keys(json).length === 0) {
-                // response body should not be empty
-                result.reason.push(ErrorType.ResponseJsonIsEmpty);
-            }
-        }
-        return result;
-    }
     validateServer(method, path) {
         const result = { isValid: true, reason: [] };
         const serverObj = Utils.getServerObject(this.spec, method, path);
@@ -705,8 +714,8 @@ class Validator {
             result.reason.push(ErrorType.NoServerInformation);
         }
         else {
-            // server url should be absolute url with https protocol
-            const serverValidateResult = Utils.checkServerUrl([serverObj]);
+            const allowHttp = this.projectType === ProjectType.Copilot;
+            const serverValidateResult = Utils.checkServerUrl([serverObj], allowHttp);
             result.reason.push(...serverValidateResult.map((item) => item.type));
         }
         return result;
@@ -729,6 +738,9 @@ class Validator {
                     reason: [ErrorType.MultipleAuthNotSupported],
                 };
             }
+            if (this.projectType === ProjectType.Copilot) {
+                return { isValid: true, reason: [] };
+            }
             for (const auths of authSchemeArray) {
                 if (auths.length === 1) {
                     if ((this.options.allowAPIKeyAuth && Utils.isAPIKeyAuth(auths[0].authScheme)) ||
@@ -741,114 +753,6 @@ class Validator {
         }
         return { isValid: false, reason: [ErrorType.AuthTypeIsNotSupported] };
     }
-    checkPostBodySchema(schema, isRequired = false) {
-        var _a;
-        const paramResult = {
-            requiredNum: 0,
-            optionalNum: 0,
-            isValid: true,
-            reason: [],
-        };
-        if (Object.keys(schema).length === 0) {
-            return paramResult;
-        }
-        const isRequiredWithoutDefault = isRequired && schema.default === undefined;
-        const isCopilot = this.projectType === ProjectType.Copilot;
-        if (isCopilot && Utils.hasNestedObjectInSchema(schema)) {
-            paramResult.isValid = false;
-            paramResult.reason = [ErrorType.RequestBodyContainsNestedObject];
-            return paramResult;
-        }
-        if (schema.type === "string" ||
-            schema.type === "integer" ||
-            schema.type === "boolean" ||
-            schema.type === "number") {
-            if (isRequiredWithoutDefault) {
-                paramResult.requiredNum = paramResult.requiredNum + 1;
-            }
-            else {
-                paramResult.optionalNum = paramResult.optionalNum + 1;
-            }
-        }
-        else if (Utils.isObjectSchema(schema)) {
-            const { properties } = schema;
-            for (const property in properties) {
-                let isRequired = false;
-                if (schema.required && ((_a = schema.required) === null || _a === void 0 ? void 0 : _a.indexOf(property)) >= 0) {
-                    isRequired = true;
-                }
-                const result = this.checkPostBodySchema(properties[property], isRequired);
-                paramResult.requiredNum += result.requiredNum;
-                paramResult.optionalNum += result.optionalNum;
-                paramResult.isValid = paramResult.isValid && result.isValid;
-                paramResult.reason.push(...result.reason);
-            }
-        }
-        else {
-            if (isRequiredWithoutDefault && !isCopilot) {
-                paramResult.isValid = false;
-                paramResult.reason.push(ErrorType.PostBodyContainsRequiredUnsupportedSchema);
-            }
-        }
-        return paramResult;
-    }
-    checkParamSchema(paramObject) {
-        const paramResult = {
-            requiredNum: 0,
-            optionalNum: 0,
-            isValid: true,
-            reason: [],
-        };
-        if (!paramObject) {
-            return paramResult;
-        }
-        const isCopilot = this.projectType === ProjectType.Copilot;
-        for (let i = 0; i < paramObject.length; i++) {
-            const param = paramObject[i];
-            const schema = param.schema;
-            if (isCopilot && Utils.hasNestedObjectInSchema(schema)) {
-                paramResult.isValid = false;
-                paramResult.reason.push(ErrorType.ParamsContainsNestedObject);
-                continue;
-            }
-            const isRequiredWithoutDefault = param.required && schema.default === undefined;
-            if (isCopilot) {
-                if (isRequiredWithoutDefault) {
-                    paramResult.requiredNum = paramResult.requiredNum + 1;
-                }
-                else {
-                    paramResult.optionalNum = paramResult.optionalNum + 1;
-                }
-                continue;
-            }
-            if (param.in === "header" || param.in === "cookie") {
-                if (isRequiredWithoutDefault) {
-                    paramResult.isValid = false;
-                    paramResult.reason.push(ErrorType.ParamsContainRequiredUnsupportedSchema);
-                }
-                continue;
-            }
-            if (schema.type !== "boolean" &&
-                schema.type !== "string" &&
-                schema.type !== "number" &&
-                schema.type !== "integer") {
-                if (isRequiredWithoutDefault) {
-                    paramResult.isValid = false;
-                    paramResult.reason.push(ErrorType.ParamsContainRequiredUnsupportedSchema);
-                }
-                continue;
-            }
-            if (param.in === "query" || param.in === "path") {
-                if (isRequiredWithoutDefault) {
-                    paramResult.requiredNum = paramResult.requiredNum + 1;
-                }
-                else {
-                    paramResult.optionalNum = paramResult.optionalNum + 1;
-                }
-            }
-        }
-        return paramResult;
-    }
 }
 
 // Copyright (c) Microsoft Corporation.
@@ -858,7 +762,6 @@ class CopilotValidator extends Validator {
         this.projectType = ProjectType.Copilot;
         this.options = options;
         this.spec = spec;
-        this.checkCircularReference();
     }
     validateSpec() {
         const result = { errors: [], warnings: [] };
@@ -884,10 +787,6 @@ class CopilotValidator extends Validator {
         if (!methodAndPathResult.isValid) {
             return methodAndPathResult;
         }
-        const circularReferenceResult = this.validateCircularReference(method, path);
-        if (!circularReferenceResult.isValid) {
-            return circularReferenceResult;
-        }
         const operationObject = this.spec.paths[path][method];
         // validate auth
         const authCheckResult = this.validateAuth(method, path);
@@ -899,24 +798,6 @@ class CopilotValidator extends Validator {
         // validate server
         const validateServerResult = this.validateServer(method, path);
         result.reason.push(...validateServerResult.reason);
-        // validate response
-        const validateResponseResult = this.validateResponse(method, path);
-        result.reason.push(...validateResponseResult.reason);
-        // validate requestBody
-        const requestBody = operationObject.requestBody;
-        const requestJsonBody = requestBody === null || requestBody === void 0 ? void 0 : requestBody.content["application/json"];
-        if (requestJsonBody) {
-            const requestBodySchema = requestJsonBody.schema;
-            if (!Utils.isObjectSchema(requestBodySchema)) {
-                result.reason.push(ErrorType.PostBodySchemaIsNotJson);
-            }
-            const requestBodyParamResult = this.checkPostBodySchema(requestBodySchema, requestBody.required);
-            result.reason.push(...requestBodyParamResult.reason);
-        }
-        // validate parameters
-        const paramObject = operationObject.parameters;
-        const paramResult = this.checkParamSchema(paramObject);
-        result.reason.push(...paramResult.reason);
         if (result.reason.length > 0) {
             result.isValid = false;
         }
@@ -1008,6 +889,108 @@ class SMEValidator extends Validator {
         }
         return result;
     }
+    validateResponse(method, path) {
+        const result = { isValid: true, reason: [] };
+        const operationObject = this.spec.paths[path][method];
+        const { json, multipleMediaType } = Utils.getResponseJson(operationObject);
+        // only support response body only contains “application/json” content type
+        if (multipleMediaType) {
+            result.reason.push(ErrorType.ResponseContainMultipleMediaTypes);
+        }
+        else if (Object.keys(json).length === 0) {
+            // response body should not be empty
+            result.reason.push(ErrorType.ResponseJsonIsEmpty);
+        }
+        return result;
+    }
+    checkPostBodySchema(schema, isRequired = false) {
+        var _a;
+        const paramResult = {
+            requiredNum: 0,
+            optionalNum: 0,
+            isValid: true,
+            reason: [],
+        };
+        if (Object.keys(schema).length === 0) {
+            return paramResult;
+        }
+        const isRequiredWithoutDefault = isRequired && schema.default === undefined;
+        const isCopilot = this.projectType === ProjectType.Copilot;
+        if (schema.type === "string" ||
+            schema.type === "integer" ||
+            schema.type === "boolean" ||
+            schema.type === "number") {
+            if (isRequiredWithoutDefault) {
+                paramResult.requiredNum = paramResult.requiredNum + 1;
+            }
+            else {
+                paramResult.optionalNum = paramResult.optionalNum + 1;
+            }
+        }
+        else if (Utils.isObjectSchema(schema)) {
+            const { properties } = schema;
+            for (const property in properties) {
+                let isRequired = false;
+                if (schema.required && ((_a = schema.required) === null || _a === void 0 ? void 0 : _a.indexOf(property)) >= 0) {
+                    isRequired = true;
+                }
+                const result = this.checkPostBodySchema(properties[property], isRequired);
+                paramResult.requiredNum += result.requiredNum;
+                paramResult.optionalNum += result.optionalNum;
+                paramResult.isValid = paramResult.isValid && result.isValid;
+                paramResult.reason.push(...result.reason);
+            }
+        }
+        else {
+            if (isRequiredWithoutDefault && !isCopilot) {
+                paramResult.isValid = false;
+                paramResult.reason.push(ErrorType.PostBodyContainsRequiredUnsupportedSchema);
+            }
+        }
+        return paramResult;
+    }
+    checkParamSchema(paramObject) {
+        const paramResult = {
+            requiredNum: 0,
+            optionalNum: 0,
+            isValid: true,
+            reason: [],
+        };
+        if (!paramObject) {
+            return paramResult;
+        }
+        for (let i = 0; i < paramObject.length; i++) {
+            const param = paramObject[i];
+            const schema = param.schema;
+            const isRequiredWithoutDefault = param.required && schema.default === undefined;
+            if (param.in === "header" || param.in === "cookie") {
+                if (isRequiredWithoutDefault) {
+                    paramResult.isValid = false;
+                    paramResult.reason.push(ErrorType.ParamsContainRequiredUnsupportedSchema);
+                }
+                continue;
+            }
+            if (schema.type !== "boolean" &&
+                schema.type !== "string" &&
+                schema.type !== "number" &&
+                schema.type !== "integer") {
+                if (isRequiredWithoutDefault) {
+                    paramResult.isValid = false;
+                    paramResult.reason.push(ErrorType.ParamsContainRequiredUnsupportedSchema);
+                }
+                continue;
+            }
+            if (param.in === "query" || param.in === "path") {
+                if (isRequiredWithoutDefault) {
+                    paramResult.requiredNum = paramResult.requiredNum + 1;
+                }
+                else {
+                    paramResult.optionalNum = paramResult.optionalNum + 1;
+                }
+            }
+        }
+        return paramResult;
+    }
     validateParamCount(postBodyResult, paramResult) {
         const result = { isValid: true, reason: [] };
         const totalRequiredParams = postBodyResult.requiredNum + paramResult.requiredNum;
@@ -1709,7 +1692,7 @@ function inferProperties(card) {
 
 // Copyright (c) Microsoft Corporation.
 class ManifestUpdater {
-    static async updateManifestWithAiPlugin(manifestPath, outputSpecPath, apiPluginFilePath, spec, options, authInfo, existingPluginManifestInfo) {
+    static async updateManifestWithAiPlugin(manifestPath, outputSpecPath, apiPluginFilePath, spec, options, authMap, existingPluginManifestInfo) {
         const manifest = await fs.readJSON(manifestPath);
         const apiPluginRelativePath = ManifestUpdater.getRelativePath(manifestPath, apiPluginFilePath);
         const useCopilotExtensionsInSchema = await ManifestUtil.useCopilotExtensionsInSchema(manifest);
@@ -1739,7 +1722,7 @@ class ManifestUpdater {
         }
         const appName = this.removeEnvs(manifest.name.short);
         const specRelativePath = ManifestUpdater.getRelativePath(manifestPath, outputSpecPath);
-        const [apiPlugin, warnings] = await ManifestUpdater.generatePluginManifestSchema(spec, specRelativePath, apiPluginFilePath, appName, authInfo, options, existingPluginManifestInfo);
+        const [apiPlugin, warnings] = await ManifestUpdater.generatePluginManifestSchema(spec, specRelativePath, apiPluginFilePath, appName, authMap, options, existingPluginManifestInfo);
         return [manifest, apiPlugin, warnings];
     }
     static updateManifestDescription(manifest, spec) {
@@ -1761,28 +1744,13 @@ class ManifestUpdater {
             throw new SpecParserError(Utils.format(ConstantString.UnsupportedSchema, method, pathUrl, JSON.stringify(schema)), ErrorType.UpdateManifestFailed);
         }
     }
-    static async generatePluginManifestSchema(spec, specRelativePath, apiPluginFilePath, appName, authInfo, options, existingPluginManifestInfo) {
+    static async generatePluginManifestSchema(spec, specRelativePath, apiPluginFilePath, appName, authMap, options, existingPluginManifestInfo) {
         var _a, _b, _c, _d;
         const warnings = [];
         const functions = [];
-        const functionNames = [];
+        const functionNamesMap = {};
         const conversationStarters = [];
         const paths = spec.paths;
-        const pluginAuthObj = {
-            type: "None",
-        };
-        if (authInfo) {
-            if (Utils.isOAuthWithAuthCodeFlow(authInfo.authScheme)) {
-                pluginAuthObj.type = "OAuthPluginVault";
-            }
-            else if (Utils.isBearerTokenAuth(authInfo.authScheme)) {
-                pluginAuthObj.type = "ApiKeyPluginVault";
-            }
-            if (pluginAuthObj.type !== "None") {
-                const safeRegistrationIdName = Utils.getSafeRegistrationIdEnvName(`${authInfo.name}_${ConstantString.RegistrationIdPostfix[authInfo.authScheme.type]}`);
-                pluginAuthObj.reference_id = `\${{${safeRegistrationIdName}}}`;
-            }
-        }
         for (const pathUrl in paths) {
             const pathItem = paths[pathUrl];
             if (pathItem) {
@@ -1790,36 +1758,11 @@ class ManifestUpdater {
                 for (const method in operations) {
                     if (options.allowMethods.includes(method)) {
                         const operationItem = operations[method];
-                        const confirmationBodies = [];
                         if (operationItem) {
                             const operationId = operationItem.operationId;
                             const safeFunctionName = operationId.replace(/[^a-zA-Z0-9]/g, "_");
                             const description = (_a = operationItem.description) !== null && _a !== void 0 ? _a : "";
                             const summary = operationItem.summary;
-                            const paramObject = operationItem.parameters;
-                            const requestBody = operationItem.requestBody;
-                            if (paramObject) {
-                                for (let i = 0; i < paramObject.length; i++) {
-                                    const param = paramObject[i];
-                                    const schema = param.schema;
-                                    ManifestUpdater.checkSchema(schema, method, pathUrl);
-                                    confirmationBodies.push(ManifestUpdater.getConfirmationBodyItem(param.name));
-                                }
-                            }
-                            if (requestBody) {
-                                const requestJsonBody = requestBody.content["application/json"];
-                                const requestBodySchema = requestJsonBody.schema;
-                                if (Utils.isObjectSchema(requestBodySchema)) {
-                                    for (const property in requestBodySchema.properties) {
-                                        const schema = requestBodySchema.properties[property];
-                                        ManifestUpdater.checkSchema(schema, method, pathUrl);
-                                        confirmationBodies.push(ManifestUpdater.getConfirmationBodyItem(property));
-                                    }
-                                }
-                                else {
-                                    throw new SpecParserError(Utils.format(ConstantString.UnsupportedSchema, method, pathUrl, JSON.stringify(requestBodySchema)), ErrorType.UpdateManifestFailed);
-                                }
-                            }
                             let funcDescription = operationItem.description || operationItem.summary || "";
                             if (funcDescription.length > ConstantString.FunctionDescriptionMaxLens) {
                                 warnings.push({
@@ -1853,19 +1796,66 @@ class ManifestUpdater {
                                 }
                             }
                             if (options.allowConfirmation && method !== ConstantString.GetMethod) {
-                                if (!funcObj.capabilities) {
-                                    funcObj.capabilities = {};
+                                const paramObject = operationItem.parameters;
+                                const requestBody = operationItem.requestBody;
+                                const confirmationBodies = [];
+                                if (paramObject) {
+                                    for (let i = 0; i < paramObject.length; i++) {
+                                        const param = paramObject[i];
+                                        const schema = param.schema;
+                                        ManifestUpdater.checkSchema(schema, method, pathUrl);
+                                        confirmationBodies.push(ManifestUpdater.getConfirmationBodyItem(param.name));
+                                    }
+                                }
+                                if (requestBody) {
+                                    const requestJsonBody = Utils.getJsonContentType(requestBody);
+                                    const requestBodySchema = requestJsonBody.schema;
+                                    if (Utils.isObjectSchema(requestBodySchema)) {
+                                        for (const property in requestBodySchema.properties) {
+                                            const schema = requestBodySchema.properties[property];
+                                            ManifestUpdater.checkSchema(schema, method, pathUrl);
+                                            confirmationBodies.push(ManifestUpdater.getConfirmationBodyItem(property));
+                                        }
+                                    }
+                                    else {
+                                        throw new SpecParserError(Utils.format(ConstantString.UnsupportedSchema, method, pathUrl, JSON.stringify(requestBodySchema)), ErrorType.UpdateManifestFailed);
+                                    }
                                 }
-                                funcObj.capabilities.confirmation = {
-                                    type: "AdaptiveCard",
-                                    title: (_b = operationItem.summary) !== null && _b !== void 0 ? _b : description,
-                                };
                                 if (confirmationBodies.length > 0) {
+                                    if (!funcObj.capabilities) {
+                                        funcObj.capabilities = {};
+                                    }
+                                    funcObj.capabilities.confirmation = {
+                                        type: "AdaptiveCard",
+                                        title: (_b = operationItem.summary) !== null && _b !== void 0 ? _b : description,
+                                    };
                                     funcObj.capabilities.confirmation.body = confirmationBodies.join("\n");
                                 }
                             }
                             functions.push(funcObj);
-                            functionNames.push(safeFunctionName);
+                            const authInfo = authMap[operationId];
+                            let key = "None";
+                            let authName = "None";
+                            if (authInfo) {
+                                if (Utils.isOAuthWithAuthCodeFlow(authInfo.authScheme)) {
+                                    key = "OAuthPluginVault";
+                                    authName = authInfo.name;
+                                }
+                                else if (Utils.isBearerTokenAuth(authInfo.authScheme) ||
+                                    Utils.isAPIKeyAuthButNotInCookie(authInfo.authScheme)) {
+                                    key = "ApiKeyPluginVault";
+                                    authName = authInfo.name;
+                                }
+                            }
+                            if (functionNamesMap[key]) {
+                                functionNamesMap[key].functionNames.push(safeFunctionName);
+                            }
+                            else {
+                                functionNamesMap[key] = {
+                                    functionNames: [safeFunctionName],
+                                    authName: authName,
+                                };
+                            }
                             const conversationStarterStr = (summary !== null && summary !== void 0 ? summary : description).slice(0, ConstantString.ConversationStarterMaxLens);
                             if (conversationStarterStr) {
                                 conversationStarters.push(conversationStarterStr);
@@ -1875,6 +1865,12 @@ class ManifestUpdater {
                 }
             }
         }
+        if (Object.keys(functionNamesMap).length === 0) {
+            functionNamesMap["None"] = {
+                functionNames: [],
+                authName: "None",
+            };
+        }
         let apiPlugin;
         if (await fs.pathExists(apiPluginFilePath)) {
             apiPlugin = await fs.readJSON(apiPluginFilePath);
@@ -1910,24 +1906,35 @@ class ManifestUpdater {
             const relativePath = ManifestUpdater.getRelativePath(existingPluginManifestInfo.manifestPath, existingPluginManifestInfo.specPath);
             apiPlugin.runtimes = apiPlugin.runtimes.filter((runtime) => runtime.spec.url !== relativePath);
         }
-        const index = apiPlugin.runtimes.findIndex((runtime) => {
-            var _a, _b;
-            return runtime.spec.url === specRelativePath &&
-                runtime.type === "OpenApi" &&
-                ((_b = (_a = runtime.auth) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : "None") === pluginAuthObj.type;
-        });
-        if (index === -1) {
-            apiPlugin.runtimes.push({
-                type: "OpenApi",
-                auth: pluginAuthObj,
-                spec: {
-                    url: specRelativePath,
-                },
-                run_for_functions: functionNames,
+        for (const authType in functionNamesMap) {
+            const pluginAuthObj = {
+                type: authType,
+            };
+            const authName = functionNamesMap[authType].authName;
+            if (pluginAuthObj.type !== "None") {
+                const safeRegistrationIdName = Utils.getSafeRegistrationIdEnvName(`${authName}_${ConstantString.RegistrationIdPostfix}`);
+                pluginAuthObj.reference_id = `\${{${safeRegistrationIdName}}}`;
+            }
+            const functionNamesInfo = functionNamesMap[authType];
+            const index = apiPlugin.runtimes.findIndex((runtime) => {
+                var _a, _b;
+                return runtime.spec.url === specRelativePath &&
+                    runtime.type === "OpenApi" &&
+                    ((_b = (_a = runtime.auth) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : "None") === authType;
             });
-        }
-        else {
-            apiPlugin.runtimes[index].run_for_functions = functionNames;
+            if (index === -1) {
+                apiPlugin.runtimes.push({
+                    type: "OpenApi",
+                    auth: pluginAuthObj,
+                    spec: {
+                        url: specRelativePath,
+                    },
+                    run_for_functions: functionNamesInfo.functionNames,
+                });
+            }
+            else {
+                apiPlugin.runtimes[index].run_for_functions = functionNamesInfo.functionNames;
+            }
         }
         if (!apiPlugin.name_for_human) {
             apiPlugin.name_for_human = appName;
@@ -1968,7 +1975,7 @@ class ManifestUpdater {
                 };
                 if (authInfo) {
                     const auth = authInfo.authScheme;
-                    const safeRegistrationIdName = Utils.getSafeRegistrationIdEnvName(`${authInfo.name}_${ConstantString.RegistrationIdPostfix[authInfo.authScheme.type]}`);
+                    const safeRegistrationIdName = Utils.getSafeRegistrationIdEnvName(`${authInfo.name}_${ConstantString.RegistrationIdPostfix}`);
                     if (Utils.isAPIKeyAuth(auth) || Utils.isBearerTokenAuth(auth)) {
                         composeExtension.authorization = {
                             authType: "apiSecretServiceAuth",
@@ -2111,8 +2118,11 @@ class SpecParser {
                     await this.parser.validate(this.spec);
                 }
                 else {
+                    // The following code still hangs for Graph API, support will be added when SwaggerParser is updated.
+                    /*
                     const clonedUnResolveSpec = JSON.parse(JSON.stringify(this.unResolveSpec));
                     await this.parser.validate(clonedUnResolveSpec);
+                    */
                 }
             }
             catch (e) {
@@ -2269,7 +2279,7 @@ class SpecParser {
                 throw new SpecParserError(ConstantString.CancelledMessage, ErrorType.Cancelled);
             }
             const clonedUnResolveSpec = JSON.parse(JSON.stringify(newUnResolvedSpec));
-            const newSpec = (await this.parser.dereference(clonedUnResolveSpec));
+            const newSpec = await this.deReferenceSpec(clonedUnResolveSpec);
             return [newUnResolvedSpec, newSpec];
         }
         catch (err) {
@@ -2279,6 +2289,10 @@ class SpecParser {
             throw new SpecParserError(err.toString(), ErrorType.GetSpecFailed);
         }
     }
+    async deReferenceSpec(spec) {
+        const result = await this.parser.dereference(spec);
+        return result;
+    }
     /**
      * Generates and update artifacts from the OpenAPI specification file. Generate Adaptive Cards, update Teams app manifest, and generate a new OpenAPI specification file.
      * @param manifestPath A file path of the Teams app manifest file to update.
@@ -2295,7 +2309,6 @@ class SpecParser {
             const newSpecs = await this.getFilteredSpecs(filter, signal);
             const newUnResolvedSpec = newSpecs[0];
             const newSpec = newSpecs[1];
-            const authInfo = Utils.getAuthInfo(newSpec);
             const paths = newUnResolvedSpec.paths;
             for (const pathUrl in paths) {
                 const operations = paths[pathUrl];
@@ -2303,15 +2316,22 @@ class SpecParser {
                     const operationItem = operations[method];
                     const operationId = operationItem.operationId;
                     const containsSpecialCharacters = /[^a-zA-Z0-9_]/.test(operationId);
-                    if (!containsSpecialCharacters) {
-                        continue;
+                    if (containsSpecialCharacters) {
+                        operationItem.operationId = operationId.replace(/[^a-zA-Z0-9]/g, "_");
+                        result.warnings.push({
+                            type: WarningType.OperationIdContainsSpecialCharacters,
+                            content: Utils.format(ConstantString.OperationIdContainsSpecialCharacters, operationId, operationItem.operationId),
+                            data: operationId,
+                        });
+                    }
+                    const authArray = Utils.getAuthArray(operationItem.security, newSpec);
+                    if (Utils.isNotSupportedAuth(authArray)) {
+                        result.warnings.push({
+                            type: WarningType.UnsupportedAuthType,
+                            content: Utils.format(ConstantString.AuthTypeIsNotSupported, operationId),
+                            data: operationId,
+                        });
                     }
-                    operationItem.operationId = operationId.replace(/[^a-zA-Z0-9]/g, "_");
-                    result.warnings.push({
-                        type: WarningType.OperationIdContainsSpecialCharacters,
-                        content: Utils.format(ConstantString.OperationIdContainsSpecialCharacters, operationId, operationItem.operationId),
-                        data: operationId,
-                    });
                 }
             }
             await this.saveFilterSpec(outputSpecPath, newUnResolvedSpec);
@@ -2324,7 +2344,8 @@ class SpecParser {
                     specPath: this.pathOrSpec,
                 }
                 : undefined;
-            const [updatedManifest, apiPlugin, warnings] = await ManifestUpdater.updateManifestWithAiPlugin(manifestPath, outputSpecPath, pluginFilePath, newSpec, this.options, authInfo, existingPluginManifestInfo);
+            const authMap = Utils.getAuthMap(newSpec);
+            const [updatedManifest, apiPlugin, warnings] = await ManifestUpdater.updateManifestWithAiPlugin(manifestPath, outputSpecPath, pluginFilePath, newSpec, this.options, authMap, existingPluginManifestInfo);
             result.warnings.push(...warnings);
             await fs.outputJSON(manifestPath, updatedManifest, { spaces: 4 });
             await fs.outputJSON(pluginFilePath, apiPlugin, { spaces: 4 });
@@ -2401,6 +2422,52 @@ class SpecParser {
         }
         return result;
     }
+    /**
+     * Generates and update artifacts from the OpenAPI specification file. Generate Adaptive Cards, update Teams app manifest, and generate a new OpenAPI specification file.
+     * @param pluginFilePath A file path of the plugin manifest file to update.
+     * @param filter An array of strings that represent the filters to apply when generating the artifacts. If filter is empty, it would process nothing.
+     */
+    async generateAdaptiveCardInPlugin(pluginFilePath, filter, signal) {
+        if (!this.options.allowResponseSemantics) {
+            return;
+        }
+        const newSpecs = await this.getFilteredSpecs(filter, signal);
+        const newSpec = newSpecs[1];
+        const apiPlugin = (await fs.readJSON(pluginFilePath));
+        const paths = newSpec.paths;
+        for (const pathUrl in paths) {
+            const pathItem = paths[pathUrl];
+            if (pathItem) {
+                const operations = pathItem;
+                for (const method in operations) {
+                    if (this.options.allowMethods.includes(method)) {
+                        const operationItem = operations[method];
+                        if (operationItem) {
+                            try {
+                                const operationId = operationItem.operationId;
+                                const safeFunctionName = operationId.replace(/[^a-zA-Z0-9]/g, "_");
+                                if (apiPlugin.functions.findIndex((func) => func.name === safeFunctionName) === -1) {
+                                    continue;
+                                }
+                                const { json } = Utils.getResponseJson(operationItem);
+                                if (json.schema) {
+                                    const [card, jsonPath] = AdaptiveCardGenerator.generateAdaptiveCard(operationItem, false, 5);
+                                    const responseSemantic = wrapResponseSemantics(card, jsonPath);
+                                    apiPlugin.functions.find((func) => func.name === safeFunctionName).capabilities = {
+                                        response_semantics: responseSemantic,
+                                    };
+                                }
+                            }
+                            catch (err) {
+                                throw new SpecParserError(err.toString(), ErrorType.GenerateAdaptiveCardFailed);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        await fs.outputJSON(pluginFilePath, apiPlugin, { spaces: 4 });
+    }
     async loadSpec() {
         if (!this.spec) {
             const spec = (await this.parser.parse(this.pathOrSpec));
@@ -2412,7 +2479,7 @@ class SpecParser {
                 this.isSwaggerFile = true;
             }
             const clonedUnResolveSpec = JSON.parse(JSON.stringify(this.unResolveSpec));
-            this.spec = (await this.parser.dereference(clonedUnResolveSpec));
+            this.spec = await this.deReferenceSpec(clonedUnResolveSpec);
         }
     }
     getAPIs(spec) {