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

package/dist/index.esm2017.mjs

@@ -29,6 +29,21 @@ var ErrorType;
     ErrorType["GenerateFailed"] = "generate-failed";
     ErrorType["ValidateFailed"] = "validate-failed";
     ErrorType["GetSpecFailed"] = "get-spec-failed";
+    ErrorType["AuthTypeIsNotSupported"] = "auth-type-is-not-supported";
+    ErrorType["MissingOperationId"] = "missing-operation-id";
+    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";
+    ErrorType["MethodNotAllowed"] = "method-not-allowed";
+    ErrorType["UrlPathNotExist"] = "url-path-not-exist";
     ErrorType["Cancelled"] = "cancelled";
     ErrorType["Unknown"] = "unknown";
 })(ErrorType || (ErrorType = {}));
@@ -68,7 +83,7 @@ ConstantString.RemoteRefNotSupported = "Remote reference is not supported: %s.";
 ConstantString.MissingOperationId = "Missing operationIds: %s.";
 ConstantString.NoSupportedApi = "No supported API is found in the OpenAPI description document: only GET and POST methods are supported, additionally, there can be at most one required parameter, and no auth is allowed.";
 ConstantString.AdditionalPropertiesNotSupported = "'additionalProperties' is not supported, and will be ignored.";
-ConstantString.SchemaNotSupported = "'oneOf', 'anyOf', and 'not' schema are not supported: %s.";
+ConstantString.SchemaNotSupported = "'oneOf', 'allOf', 'anyOf', and 'not' schema are not supported: %s.";
 ConstantString.UnknownSchema = "Unknown schema: %s.";
 ConstantString.UrlProtocolNotSupported = "Server url is not correct: protocol %s is not supported, you should use https protocol instead.";
 ConstantString.RelativeServerUrlNotSupported = "Server url is not correct: relative server url is not supported.";
@@ -88,9 +103,9 @@ ConstantString.AdaptiveCardVersion = "1.5";
 ConstantString.AdaptiveCardSchema = "http://adaptivecards.io/schemas/adaptive-card.json";
 ConstantString.AdaptiveCardType = "AdaptiveCard";
 ConstantString.TextBlockType = "TextBlock";
+ConstantString.ImageType = "Image";
 ConstantString.ContainerType = "Container";
 ConstantString.RegistrationIdPostfix = "REGISTRATION_ID";
-ConstantString.OAuthRegistrationIdPostFix = "OAUTH_REGISTRATION_ID";
 ConstantString.ResponseCodeFor20X = [
     "200",
     "201",
@@ -151,7 +166,8 @@ ConstantString.CommandDescriptionMaxLens = 128;
 ConstantString.ParameterDescriptionMaxLens = 128;
 ConstantString.CommandTitleMaxLens = 32;
 ConstantString.ParameterTitleMaxLens = 32;
-ConstantString.SMERequiredParamsMaxNum = 5;
+ConstantString.SMERequiredParamsMaxNum = 5;
+ConstantString.DefaultPluginId = "plugin_1";
 
 // Copyright (c) Microsoft Corporation.
 class SpecParserError extends Error {
@@ -174,221 +190,9 @@ class Utils {
         }
         return false;
     }
-    static checkParameters(paramObject, isCopilot) {
-        const paramResult = {
-            requiredNum: 0,
-            optionalNum: 0,
-            isValid: true,
-        };
-        if (!paramObject) {
-            return paramResult;
-        }
-        for (let i = 0; i < paramObject.length; i++) {
-            const param = paramObject[i];
-            const schema = param.schema;
-            if (isCopilot && this.hasNestedObjectInSchema(schema)) {
-                paramResult.isValid = false;
-                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;
-                }
-                continue;
-            }
-            if (schema.type !== "boolean" &&
-                schema.type !== "string" &&
-                schema.type !== "number" &&
-                schema.type !== "integer") {
-                if (isRequiredWithoutDefault) {
-                    paramResult.isValid = false;
-                }
-                continue;
-            }
-            if (param.in === "query" || param.in === "path") {
-                if (isRequiredWithoutDefault) {
-                    paramResult.requiredNum = paramResult.requiredNum + 1;
-                }
-                else {
-                    paramResult.optionalNum = paramResult.optionalNum + 1;
-                }
-            }
-        }
-        return paramResult;
-    }
-    static checkPostBody(schema, isRequired = false, isCopilot = false) {
-        var _a;
-        const paramResult = {
-            requiredNum: 0,
-            optionalNum: 0,
-            isValid: true,
-        };
-        if (Object.keys(schema).length === 0) {
-            return paramResult;
-        }
-        const isRequiredWithoutDefault = isRequired && schema.default === undefined;
-        if (isCopilot && this.hasNestedObjectInSchema(schema)) {
-            paramResult.isValid = false;
-            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 (schema.type === "object") {
-            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 = Utils.checkPostBody(properties[property], isRequired, isCopilot);
-                paramResult.requiredNum += result.requiredNum;
-                paramResult.optionalNum += result.optionalNum;
-                paramResult.isValid = paramResult.isValid && result.isValid;
-            }
-        }
-        else {
-            if (isRequiredWithoutDefault && !isCopilot) {
-                paramResult.isValid = false;
-            }
-        }
-        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.
-     * @param {string} path - The path of the API.
-     * @param {OpenAPIV3.Document} spec - The OpenAPI specification document.
-     * @returns {boolean} - Returns true if the API is supported, false otherwise.
-     * @description The following APIs are supported:
-     * 1. only support Get/Post operation without auth property
-     * 2. parameter inside query or path only support string, number, boolean and integer
-     * 3. parameter inside post body only support string, number, boolean, integer and object
-     * 4. request body + required parameters <= 1
-     * 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, options) {
-        var _a;
-        const pathObj = spec.paths[path];
-        method = method.toLocaleLowerCase();
-        if (pathObj) {
-            if (((_a = options.allowMethods) === null || _a === void 0 ? void 0 : _a.includes(method)) && pathObj[method]) {
-                const securities = pathObj[method].security;
-                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 (!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"];
-                if (!isTeamsAi && Utils.containMultipleMediaTypes(requestBody)) {
-                    return false;
-                }
-                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,
-                    isValid: true,
-                };
-                if (requestJsonBody) {
-                    const requestBodySchema = requestJsonBody.schema;
-                    if (isCopilot && requestBodySchema.type !== "object") {
-                        return false;
-                    }
-                    requestBodyParamResult = Utils.checkPostBody(requestBodySchema, requestBody.required, isCopilot);
-                }
-                if (!requestBodyParamResult.isValid) {
-                    return false;
-                }
-                const paramResult = Utils.checkParameters(paramObject, isCopilot);
-                if (!paramResult.isValid) {
-                    return false;
-                }
-                // Copilot support arbitrary parameters
-                if (isCopilot) {
-                    return true;
-                }
-                if (requestBodyParamResult.requiredNum + paramResult.requiredNum > 1) {
-                    if (options.allowMultipleParameters &&
-                        requestBodyParamResult.requiredNum + paramResult.requiredNum <=
-                            ConstantString.SMERequiredParamsMaxNum) {
-                        return true;
-                    }
-                    return false;
-                }
-                else if (requestBodyParamResult.requiredNum +
-                    requestBodyParamResult.optionalNum +
-                    paramResult.requiredNum +
-                    paramResult.optionalNum ===
-                    0) {
-                    return false;
-                }
-                else {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-    static isSupportedAuth(authSchemeArray, options) {
-        if (authSchemeArray.length === 0) {
-            return true;
-        }
-        if (options.allowAPIKeyAuth || options.allowOauth2 || options.allowBearerTokenAuth) {
-            // Currently we don't support multiple auth in one operation
-            if (authSchemeArray.length > 0 && authSchemeArray.every((auths) => auths.length > 1)) {
-                return false;
-            }
-            for (const auths of authSchemeArray) {
-                if (auths.length === 1) {
-                    if ((options.allowAPIKeyAuth && Utils.isAPIKeyAuth(auths[0].authScheme)) ||
-                        (options.allowOauth2 && Utils.isOAuthWithAuthCodeFlow(auths[0].authScheme)) ||
-                        (options.allowBearerTokenAuth && Utils.isBearerTokenAuth(auths[0].authScheme))) {
-                        return true;
-                    }
-                }
-            }
-        }
-        return false;
-    }
     static isBearerTokenAuth(authScheme) {
         return authScheme.type === "http" && authScheme.scheme === "bearer";
     }
@@ -396,18 +200,18 @@ class Utils {
         return authScheme.type === "apiKey";
     }
     static isOAuthWithAuthCodeFlow(authScheme) {
-        if (authScheme.type === "oauth2" && authScheme.flows && authScheme.flows.authorizationCode) {
-            return true;
-        }
-        return false;
+        return !!(authScheme.type === "oauth2" &&
+            authScheme.flows &&
+            authScheme.flows.authorizationCode);
     }
     static getAuthArray(securities, spec) {
         var _a;
         const result = [];
         const securitySchemas = (_a = spec.components) === null || _a === void 0 ? void 0 : _a.securitySchemes;
-        if (securities && securitySchemas) {
-            for (let i = 0; i < securities.length; i++) {
-                const security = securities[i];
+        const securitiesArr = securities !== null && securities !== void 0 ? securities : spec.security;
+        if (securitiesArr && securitySchemas) {
+            for (let i = 0; i < securitiesArr.length; i++) {
+                const security = securitiesArr[i];
                 const authArray = [];
                 for (const name in security) {
                     const auth = securitySchemas[name];
@@ -424,17 +228,39 @@ class Utils {
         result.sort((a, b) => a[0].name.localeCompare(b[0].name));
         return result;
     }
+    static getAuthInfo(spec) {
+        let authInfo = undefined;
+        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];
+                    if (!authInfo) {
+                        authInfo = authArray[0][0];
+                    }
+                    else if (authInfo.name !== currentAuth.name) {
+                        throw new SpecParserError(ConstantString.MultipleAuthNotSupported, ErrorType.MultipleAuthNotSupported);
+                    }
+                }
+            }
+        }
+        return authInfo;
+    }
     static updateFirstLetter(str) {
         return str.charAt(0).toUpperCase() + str.slice(1);
     }
-    static getResponseJson(operationObject, isTeamsAiProject = false) {
+    static getResponseJson(operationObject) {
         var _a, _b;
         let json = {};
+        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 ((_b = responseObject === null || responseObject === void 0 ? void 0 : responseObject.content) === null || _b === void 0 ? void 0 : _b["application/json"]) {
+                multipleMediaType = false;
                 json = responseObject.content["application/json"];
-                if (!isTeamsAiProject && Utils.containMultipleMediaTypes(responseObject)) {
+                if (Utils.containMultipleMediaTypes(responseObject)) {
+                    multipleMediaType = true;
                     json = {};
                 }
                 else {
@@ -442,7 +268,7 @@ class Utils {
                 }
             }
         }
-        return json;
+        return { json, multipleMediaType };
     }
     static convertPathToCamelCase(path) {
         const pathSegments = path.split(/[./{]/);
@@ -462,10 +288,10 @@ class Utils {
             return undefined;
         }
     }
-    static resolveServerUrl(url) {
+    static resolveEnv(str) {
         const placeHolderReg = /\${{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*}}/g;
-        let matches = placeHolderReg.exec(url);
-        let newUrl = url;
+        let matches = placeHolderReg.exec(str);
+        let newStr = str;
         while (matches != null) {
             const envVar = matches[1];
             const envVal = process.env[envVar];
@@ -473,17 +299,17 @@ class Utils {
                 throw new Error(Utils.format(ConstantString.ResolveServerUrlFailed, envVar));
             }
             else {
-                newUrl = newUrl.replace(matches[0], envVal);
+                newStr = newStr.replace(matches[0], envVal);
             }
-            matches = placeHolderReg.exec(url);
+            matches = placeHolderReg.exec(str);
         }
-        return newUrl;
+        return newStr;
     }
     static checkServerUrl(servers) {
         const errors = [];
         let serverUrl;
         try {
-            serverUrl = Utils.resolveServerUrl(servers[0].url);
+            serverUrl = Utils.resolveEnv(servers[0].url);
         }
         catch (err) {
             errors.push({
@@ -514,6 +340,7 @@ class Utils {
         return errors;
     }
     static validateServer(spec, options) {
+        var _a;
         const errors = [];
         let hasTopLevelServers = false;
         let hasPathLevelServers = false;
@@ -534,7 +361,7 @@ class Utils {
             }
             for (const method in methods) {
                 const operationObject = methods[method];
-                if (Utils.isSupportedApi(method, path, spec, options)) {
+                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);
@@ -661,13 +488,7 @@ class Utils {
             }
         }
         const operationId = operationItem.operationId;
-        const parameters = [];
-        if (requiredParams.length !== 0) {
-            parameters.push(...requiredParams);
-        }
-        else {
-            parameters.push(optionalParams[0]);
-        }
+        const parameters = [...requiredParams, ...optionalParams];
         const command = {
             context: ["compose"],
             type: "query",
@@ -676,166 +497,883 @@ class Utils {
             parameters: parameters,
             description: ((_b = operationItem.description) !== null && _b !== void 0 ? _b : "").slice(0, ConstantString.CommandDescriptionMaxLens),
         };
-        let warning = undefined;
-        if (requiredParams.length === 0 && optionalParams.length > 1) {
-            warning = {
-                type: WarningType.OperationOnlyContainsOptionalParam,
-                content: Utils.format(ConstantString.OperationOnlyContainsOptionalParam, operationId),
-                data: operationId,
-            };
+        return command;
+    }
+    static format(str, ...args) {
+        let index = 0;
+        return str.replace(/%s/g, () => {
+            const arg = args[index++];
+            return arg !== undefined ? arg : "";
+        });
+    }
+    static getSafeRegistrationIdEnvName(authName) {
+        if (!authName) {
+            return "";
+        }
+        let safeRegistrationIdEnvName = authName.toUpperCase().replace(/[^A-Z0-9_]/g, "_");
+        if (!safeRegistrationIdEnvName.match(/^[A-Z]/)) {
+            safeRegistrationIdEnvName = "PREFIX_" + safeRegistrationIdEnvName;
         }
-        return [command, warning];
+        return safeRegistrationIdEnvName;
     }
-    static listSupportedAPIs(spec, options) {
-        const paths = spec.paths;
+    static getServerObject(spec, method, path) {
+        const pathObj = spec.paths[path];
+        const operationObject = pathObj[method];
+        const rootServer = spec.servers && spec.servers[0];
+        const methodServer = spec.paths[path].servers && spec.paths[path].servers[0];
+        const operationServer = operationObject.servers && operationObject.servers[0];
+        const serverUrl = operationServer || methodServer || rootServer;
+        return serverUrl;
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+class Validator {
+    listAPIs() {
+        var _a;
+        if (this.apiMap) {
+            return this.apiMap;
+        }
+        const paths = this.spec.paths;
         const result = {};
         for (const path in paths) {
             const methods = paths[path];
             for (const method in methods) {
-                if (Utils.isSupportedApi(method, path, spec, options)) {
-                    const operationObject = methods[method];
-                    result[`${method.toUpperCase()} ${path}`] = operationObject;
+                const operationObject = methods[method];
+                if (((_a = this.options.allowMethods) === null || _a === void 0 ? void 0 : _a.includes(method)) && operationObject) {
+                    const validateResult = this.validateAPI(method, path);
+                    result[`${method.toUpperCase()} ${path}`] = {
+                        operation: operationObject,
+                        isValid: validateResult.isValid,
+                        reason: validateResult.reason,
+                    };
                 }
             }
         }
+        this.apiMap = result;
         return result;
     }
-    static validateSpec(spec, parser, isSwaggerFile, options) {
-        const errors = [];
-        const warnings = [];
-        if (isSwaggerFile) {
-            warnings.push({
-                type: WarningType.ConvertSwaggerToOpenAPI,
-                content: ConstantString.ConvertSwaggerToOpenAPI,
-            });
-        }
-        // Server validation
-        const serverErrors = Utils.validateServer(spec, options);
-        errors.push(...serverErrors);
-        // Remote reference not supported
-        const refPaths = parser.$refs.paths();
-        // refPaths [0] is the current spec file path
-        if (refPaths.length > 1) {
-            errors.push({
-                type: ErrorType.RemoteRefNotSupported,
-                content: Utils.format(ConstantString.RemoteRefNotSupported, refPaths.join(", ")),
-                data: refPaths,
+    validateSpecVersion() {
+        const result = { errors: [], warnings: [] };
+        if (this.spec.openapi >= "3.1.0") {
+            result.errors.push({
+                type: ErrorType.SpecVersionNotSupported,
+                content: Utils.format(ConstantString.SpecVersionNotSupported, this.spec.openapi),
+                data: this.spec.openapi,
             });
         }
-        // No supported API
-        const apiMap = Utils.listSupportedAPIs(spec, options);
-        if (Object.keys(apiMap).length === 0) {
-            errors.push({
+        return result;
+    }
+    validateSpecServer() {
+        const result = { errors: [], warnings: [] };
+        const serverErrors = Utils.validateServer(this.spec, this.options);
+        result.errors.push(...serverErrors);
+        return result;
+    }
+    validateSpecNoSupportAPI() {
+        const result = { errors: [], warnings: [] };
+        const apiMap = this.listAPIs();
+        const validAPIs = Object.entries(apiMap).filter(([, value]) => value.isValid);
+        if (validAPIs.length === 0) {
+            const data = [];
+            for (const key in apiMap) {
+                const { reason } = apiMap[key];
+                const apiInvalidReason = { api: key, reason: reason };
+                data.push(apiInvalidReason);
+            }
+            result.errors.push({
                 type: ErrorType.NoSupportedApi,
                 content: ConstantString.NoSupportedApi,
+                data,
             });
         }
+        return result;
+    }
+    validateSpecOperationId() {
+        const result = { errors: [], warnings: [] };
+        const apiMap = this.listAPIs();
         // OperationId missing
         const apisMissingOperationId = [];
         for (const key in apiMap) {
-            const pathObjectItem = apiMap[key];
-            if (!pathObjectItem.operationId) {
+            const { operation } = apiMap[key];
+            if (!operation.operationId) {
                 apisMissingOperationId.push(key);
             }
         }
         if (apisMissingOperationId.length > 0) {
-            warnings.push({
+            result.warnings.push({
                 type: WarningType.OperationIdMissing,
                 content: Utils.format(ConstantString.MissingOperationId, apisMissingOperationId.join(", ")),
                 data: apisMissingOperationId,
             });
         }
-        let status = ValidationStatus.Valid;
-        if (warnings.length > 0 && errors.length === 0) {
-            status = ValidationStatus.Warning;
+        return result;
+    }
+    validateMethodAndPath(method, path) {
+        const result = { isValid: true, reason: [] };
+        if (this.options.allowMethods && !this.options.allowMethods.includes(method)) {
+            result.isValid = false;
+            result.reason.push(ErrorType.MethodNotAllowed);
+            return result;
         }
-        else if (errors.length > 0) {
-            status = ValidationStatus.Error;
+        const pathObj = this.spec.paths[path];
+        if (!pathObj || !pathObj[method]) {
+            result.isValid = false;
+            result.reason.push(ErrorType.UrlPathNotExist);
+            return result;
         }
-        return {
-            status,
-            warnings,
-            errors,
-        };
+        return result;
     }
-    static format(str, ...args) {
-        let index = 0;
-        return str.replace(/%s/g, () => {
-            const arg = args[index++];
-            return arg !== undefined ? arg : "";
-        });
+    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;
     }
-    static getSafeRegistrationIdEnvName(authName) {
-        if (!authName) {
-            return "";
+    validateServer(method, path) {
+        const result = { isValid: true, reason: [] };
+        const serverObj = Utils.getServerObject(this.spec, method, path);
+        if (!serverObj) {
+            // should contain server URL
+            result.reason.push(ErrorType.NoServerInformation);
         }
-        let safeRegistrationIdEnvName = authName.toUpperCase().replace(/[^A-Z0-9_]/g, "_");
-        if (!safeRegistrationIdEnvName.match(/^[A-Z]/)) {
-            safeRegistrationIdEnvName = "PREFIX_" + safeRegistrationIdEnvName;
+        else {
+            // server url should be absolute url with https protocol
+            const serverValidateResult = Utils.checkServerUrl([serverObj]);
+            result.reason.push(...serverValidateResult.map((item) => item.type));
         }
-        return safeRegistrationIdEnvName;
+        return result;
     }
-    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++;
-                }
-            }
+    validateAuth(method, path) {
+        const pathObj = this.spec.paths[path];
+        const operationObject = pathObj[method];
+        const securities = operationObject.security;
+        const authSchemeArray = Utils.getAuthArray(securities, this.spec);
+        if (authSchemeArray.length === 0) {
+            return { isValid: true, reason: [] };
         }
-        return count;
-    }
-}
-
-// Copyright (c) Microsoft Corporation.
-class SpecFilter {
-    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, options)) {
-                    continue;
-                }
-                if (!newPaths[path]) {
-                    newPaths[path] = Object.assign({}, unResolveSpec.paths[path]);
-                    for (const m of ConstantString.AllOperationMethods) {
-                        delete newPaths[path][m];
+        if (this.options.allowAPIKeyAuth ||
+            this.options.allowOauth2 ||
+            this.options.allowBearerTokenAuth) {
+            // Currently we don't support multiple auth in one operation
+            if (authSchemeArray.length > 0 && authSchemeArray.every((auths) => auths.length > 1)) {
+                return {
+                    isValid: false,
+                    reason: [ErrorType.MultipleAuthNotSupported],
+                };
+            }
+            for (const auths of authSchemeArray) {
+                if (auths.length === 1) {
+                    if ((this.options.allowAPIKeyAuth && Utils.isAPIKeyAuth(auths[0].authScheme)) ||
+                        (this.options.allowOauth2 && Utils.isOAuthWithAuthCodeFlow(auths[0].authScheme)) ||
+                        (this.options.allowBearerTokenAuth && Utils.isBearerTokenAuth(auths[0].authScheme))) {
+                        return { isValid: true, reason: [] };
                     }
                 }
-                newPaths[path][methodName] = unResolveSpec.paths[path][methodName];
-                // Add the operationId if missing
-                if (!newPaths[path][methodName].operationId) {
-                    newPaths[path][methodName].operationId = `${methodName}${Utils.convertPathToCamelCase(path)}`;
-                }
             }
-            newSpec.paths = newPaths;
-            return newSpec;
-        }
-        catch (err) {
-            throw new SpecParserError(err.toString(), ErrorType.FilterSpecFailed);
         }
+        return { isValid: false, reason: [ErrorType.AuthTypeIsNotSupported] };
     }
-}
-
-// Copyright (c) Microsoft Corporation.
-class ManifestUpdater {
-    static async updateManifestWithAiPlugin(manifestPath, outputSpecPath, apiPluginFilePath, spec, options) {
-        const manifest = await fs.readJSON(manifestPath);
-        const apiPluginRelativePath = ManifestUpdater.getRelativePath(manifestPath, apiPluginFilePath);
-        manifest.plugins = [
-            {
-                pluginFile: apiPluginRelativePath,
-            },
-        ];
-        ManifestUpdater.updateManifestDescription(manifest, spec);
-        const specRelativePath = ManifestUpdater.getRelativePath(manifestPath, outputSpecPath);
-        const apiPlugin = ManifestUpdater.generatePluginManifestSchema(spec, specRelativePath, options);
+    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 && this.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 (schema.type === "object") {
+            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 && this.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;
+    }
+    hasNestedObjectInSchema(schema) {
+        if (schema.type === "object") {
+            for (const property in schema.properties) {
+                const nestedSchema = schema.properties[property];
+                if (nestedSchema.type === "object") {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+class CopilotValidator extends Validator {
+    constructor(spec, options) {
+        super();
+        this.projectType = ProjectType.Copilot;
+        this.options = options;
+        this.spec = spec;
+    }
+    validateSpec() {
+        const result = { errors: [], warnings: [] };
+        // validate spec version
+        let validationResult = this.validateSpecVersion();
+        result.errors.push(...validationResult.errors);
+        // validate spec server
+        validationResult = this.validateSpecServer();
+        result.errors.push(...validationResult.errors);
+        // validate no supported API
+        validationResult = this.validateSpecNoSupportAPI();
+        result.errors.push(...validationResult.errors);
+        // validate operationId missing
+        validationResult = this.validateSpecOperationId();
+        result.warnings.push(...validationResult.warnings);
+        return result;
+    }
+    validateAPI(method, path) {
+        const result = { isValid: true, reason: [] };
+        method = method.toLocaleLowerCase();
+        // validate method and path
+        const methodAndPathResult = this.validateMethodAndPath(method, path);
+        if (!methodAndPathResult.isValid) {
+            return methodAndPathResult;
+        }
+        const operationObject = this.spec.paths[path][method];
+        // validate auth
+        const authCheckResult = this.validateAuth(method, path);
+        result.reason.push(...authCheckResult.reason);
+        // validate operationId
+        if (!this.options.allowMissingId && !operationObject.operationId) {
+            result.reason.push(ErrorType.MissingOperationId);
+        }
+        // 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 (requestBodySchema.type !== "object") {
+                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;
+        }
+        return result;
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+class SMEValidator extends Validator {
+    constructor(spec, options) {
+        super();
+        this.projectType = ProjectType.SME;
+        this.options = options;
+        this.spec = spec;
+    }
+    validateSpec() {
+        const result = { errors: [], warnings: [] };
+        // validate spec version
+        let validationResult = this.validateSpecVersion();
+        result.errors.push(...validationResult.errors);
+        // validate spec server
+        validationResult = this.validateSpecServer();
+        result.errors.push(...validationResult.errors);
+        // validate no supported API
+        validationResult = this.validateSpecNoSupportAPI();
+        result.errors.push(...validationResult.errors);
+        // validate operationId missing
+        if (this.options.allowMissingId) {
+            validationResult = this.validateSpecOperationId();
+            result.warnings.push(...validationResult.warnings);
+        }
+        return result;
+    }
+    validateAPI(method, path) {
+        const result = { isValid: true, reason: [] };
+        method = method.toLocaleLowerCase();
+        // validate method and path
+        const methodAndPathResult = this.validateMethodAndPath(method, path);
+        if (!methodAndPathResult.isValid) {
+            return methodAndPathResult;
+        }
+        const operationObject = this.spec.paths[path][method];
+        // validate auth
+        const authCheckResult = this.validateAuth(method, path);
+        result.reason.push(...authCheckResult.reason);
+        // validate operationId
+        if (!this.options.allowMissingId && !operationObject.operationId) {
+            result.reason.push(ErrorType.MissingOperationId);
+        }
+        // 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);
+        let postBodyResult = {
+            requiredNum: 0,
+            optionalNum: 0,
+            isValid: true,
+            reason: [],
+        };
+        // validate requestBody
+        const requestBody = operationObject.requestBody;
+        const requestJsonBody = requestBody === null || requestBody === void 0 ? void 0 : requestBody.content["application/json"];
+        if (Utils.containMultipleMediaTypes(requestBody)) {
+            result.reason.push(ErrorType.PostBodyContainMultipleMediaTypes);
+        }
+        if (requestJsonBody) {
+            const requestBodySchema = requestJsonBody.schema;
+            postBodyResult = this.checkPostBodySchema(requestBodySchema, requestBody.required);
+            result.reason.push(...postBodyResult.reason);
+        }
+        // validate parameters
+        const paramObject = operationObject.parameters;
+        const paramResult = this.checkParamSchema(paramObject);
+        result.reason.push(...paramResult.reason);
+        // validate total parameters count
+        if (paramResult.isValid && postBodyResult.isValid) {
+            const paramCountResult = this.validateParamCount(postBodyResult, paramResult);
+            result.reason.push(...paramCountResult.reason);
+        }
+        if (result.reason.length > 0) {
+            result.isValid = false;
+        }
+        return result;
+    }
+    validateParamCount(postBodyResult, paramResult) {
+        const result = { isValid: true, reason: [] };
+        const totalRequiredParams = postBodyResult.requiredNum + paramResult.requiredNum;
+        const totalParams = totalRequiredParams + postBodyResult.optionalNum + paramResult.optionalNum;
+        if (totalRequiredParams > 1) {
+            if (!this.options.allowMultipleParameters ||
+                totalRequiredParams > SMEValidator.SMERequiredParamsMaxNum) {
+                result.reason.push(ErrorType.ExceededRequiredParamsLimit);
+            }
+        }
+        else if (totalParams === 0) {
+            result.reason.push(ErrorType.NoParameter);
+        }
+        return result;
+    }
+}
+SMEValidator.SMERequiredParamsMaxNum = 5;
+
+// Copyright (c) Microsoft Corporation.
+class TeamsAIValidator extends Validator {
+    constructor(spec, options) {
+        super();
+        this.projectType = ProjectType.TeamsAi;
+        this.options = options;
+        this.spec = spec;
+    }
+    validateSpec() {
+        const result = { errors: [], warnings: [] };
+        // validate spec server
+        let validationResult = this.validateSpecServer();
+        result.errors.push(...validationResult.errors);
+        // validate no supported API
+        validationResult = this.validateSpecNoSupportAPI();
+        result.errors.push(...validationResult.errors);
+        return result;
+    }
+    validateAPI(method, path) {
+        const result = { isValid: true, reason: [] };
+        method = method.toLocaleLowerCase();
+        // validate method and path
+        const methodAndPathResult = this.validateMethodAndPath(method, path);
+        if (!methodAndPathResult.isValid) {
+            return methodAndPathResult;
+        }
+        const operationObject = this.spec.paths[path][method];
+        // validate operationId
+        if (!this.options.allowMissingId && !operationObject.operationId) {
+            result.reason.push(ErrorType.MissingOperationId);
+        }
+        // validate server
+        const validateServerResult = this.validateServer(method, path);
+        result.reason.push(...validateServerResult.reason);
+        if (result.reason.length > 0) {
+            result.isValid = false;
+        }
+        return result;
+    }
+}
+
+class ValidatorFactory {
+    static create(spec, options) {
+        var _a;
+        const type = (_a = options.projectType) !== null && _a !== void 0 ? _a : ProjectType.SME;
+        switch (type) {
+            case ProjectType.SME:
+                return new SMEValidator(spec, options);
+            case ProjectType.Copilot:
+                return new CopilotValidator(spec, options);
+            case ProjectType.TeamsAi:
+                return new TeamsAIValidator(spec, options);
+            default:
+                throw new Error(`Invalid project type: ${type}`);
+        }
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+class SpecFilter {
+    static specFilter(filter, unResolveSpec, resolvedSpec, options) {
+        var _a;
+        try {
+            const newSpec = Object.assign({}, unResolveSpec);
+            const newPaths = {};
+            for (const filterItem of filter) {
+                const [method, path] = filterItem.split(" ");
+                const methodName = method.toLowerCase();
+                const pathObj = (_a = resolvedSpec.paths) === null || _a === void 0 ? void 0 : _a[path];
+                if (ConstantString.AllOperationMethods.includes(methodName) &&
+                    pathObj &&
+                    pathObj[methodName]) {
+                    const validator = ValidatorFactory.create(resolvedSpec, options);
+                    const validateResult = validator.validateAPI(methodName, path);
+                    if (!validateResult.isValid) {
+                        continue;
+                    }
+                    if (!newPaths[path]) {
+                        newPaths[path] = Object.assign({}, unResolveSpec.paths[path]);
+                        for (const m of ConstantString.AllOperationMethods) {
+                            delete newPaths[path][m];
+                        }
+                    }
+                    newPaths[path][methodName] = unResolveSpec.paths[path][methodName];
+                    // Add the operationId if missing
+                    if (!newPaths[path][methodName].operationId) {
+                        newPaths[path][methodName].operationId = `${methodName}${Utils.convertPathToCamelCase(path)}`;
+                    }
+                }
+            }
+            newSpec.paths = newPaths;
+            return newSpec;
+        }
+        catch (err) {
+            throw new SpecParserError(err.toString(), ErrorType.FilterSpecFailed);
+        }
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+class AdaptiveCardGenerator {
+    static generateAdaptiveCard(operationItem) {
+        try {
+            const { json } = Utils.getResponseJson(operationItem);
+            let cardBody = [];
+            let schema = json.schema;
+            let jsonPath = "$";
+            if (schema && Object.keys(schema).length > 0) {
+                jsonPath = AdaptiveCardGenerator.getResponseJsonPathFromSchema(schema);
+                if (jsonPath !== "$") {
+                    schema = schema.properties[jsonPath];
+                }
+                cardBody = AdaptiveCardGenerator.generateCardFromResponse(schema, "");
+            }
+            // if no schema, try to use example value
+            if (cardBody.length === 0 && (json.examples || json.example)) {
+                cardBody = [
+                    {
+                        type: ConstantString.TextBlockType,
+                        text: "${jsonStringify($root)}",
+                        wrap: true,
+                    },
+                ];
+            }
+            // if no example value, use default success response
+            if (cardBody.length === 0) {
+                cardBody = [
+                    {
+                        type: ConstantString.TextBlockType,
+                        text: "success",
+                        wrap: true,
+                    },
+                ];
+            }
+            const fullCard = {
+                type: ConstantString.AdaptiveCardType,
+                $schema: ConstantString.AdaptiveCardSchema,
+                version: ConstantString.AdaptiveCardVersion,
+                body: cardBody,
+            };
+            return [fullCard, jsonPath];
+        }
+        catch (err) {
+            throw new SpecParserError(err.toString(), ErrorType.GenerateAdaptiveCardFailed);
+        }
+    }
+    static generateCardFromResponse(schema, name, parentArrayName = "") {
+        if (schema.type === "array") {
+            // schema.items can be arbitrary object: schema { type: array, items: {} }
+            if (Object.keys(schema.items).length === 0) {
+                return [
+                    {
+                        type: ConstantString.TextBlockType,
+                        text: name ? `${name}: \${jsonStringify(${name})}` : "result: ${jsonStringify($root)}",
+                        wrap: true,
+                    },
+                ];
+            }
+            const obj = AdaptiveCardGenerator.generateCardFromResponse(schema.items, "", name);
+            const template = {
+                type: ConstantString.ContainerType,
+                $data: name ? `\${${name}}` : "${$root}",
+                items: Array(),
+            };
+            template.items.push(...obj);
+            return [template];
+        }
+        // some schema may not contain type but contain properties
+        if (schema.type === "object" || (!schema.type && schema.properties)) {
+            const { properties } = schema;
+            const result = [];
+            for (const property in properties) {
+                const obj = AdaptiveCardGenerator.generateCardFromResponse(properties[property], name ? `${name}.${property}` : property, parentArrayName);
+                result.push(...obj);
+            }
+            if (schema.additionalProperties) {
+                // TODO: better ways to handler warnings.
+                console.warn(ConstantString.AdditionalPropertiesNotSupported);
+            }
+            return result;
+        }
+        if (schema.type === "string" ||
+            schema.type === "integer" ||
+            schema.type === "boolean" ||
+            schema.type === "number") {
+            if (!AdaptiveCardGenerator.isImageUrlProperty(schema, name, parentArrayName)) {
+                // string in root: "ddd"
+                let text = "result: ${$root}";
+                if (name) {
+                    // object { id: "1" }
+                    text = `${name}: \${if(${name}, ${name}, 'N/A')}`;
+                    if (parentArrayName) {
+                        // object types inside array: { tags: ["id": 1, "name": "name"] }
+                        text = `${parentArrayName}.${text}`;
+                    }
+                }
+                else if (parentArrayName) {
+                    // string array: photoUrls: ["1", "2"]
+                    text = `${parentArrayName}: ` + "${$data}";
+                }
+                return [
+                    {
+                        type: ConstantString.TextBlockType,
+                        text,
+                        wrap: true,
+                    },
+                ];
+            }
+            else {
+                if (name) {
+                    return [
+                        {
+                            type: "Image",
+                            url: `\${${name}}`,
+                            $when: `\${${name} != null}`,
+                        },
+                    ];
+                }
+                else {
+                    return [
+                        {
+                            type: "Image",
+                            url: "${$data}",
+                            $when: "${$data != null}",
+                        },
+                    ];
+                }
+            }
+        }
+        if (schema.oneOf || schema.anyOf || schema.not || schema.allOf) {
+            throw new Error(Utils.format(ConstantString.SchemaNotSupported, JSON.stringify(schema)));
+        }
+        throw new Error(Utils.format(ConstantString.UnknownSchema, JSON.stringify(schema)));
+    }
+    // Find the first array property in the response schema object with the well-known name
+    static getResponseJsonPathFromSchema(schema) {
+        if (schema.type === "object" || (!schema.type && schema.properties)) {
+            const { properties } = schema;
+            for (const property in properties) {
+                const schema = properties[property];
+                if (schema.type === "array" &&
+                    Utils.isWellKnownName(property, ConstantString.WellknownResultNames)) {
+                    return property;
+                }
+            }
+        }
+        return "$";
+    }
+    static isImageUrlProperty(schema, name, parentArrayName) {
+        const propertyName = name ? name : parentArrayName;
+        return (!!propertyName &&
+            schema.type === "string" &&
+            Utils.isWellKnownName(propertyName, ConstantString.WellknownImageName) &&
+            (propertyName.toLocaleLowerCase().indexOf("url") >= 0 || schema.format === "uri"));
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+function wrapAdaptiveCard(card, jsonPath) {
+    const result = {
+        version: ConstantString.WrappedCardVersion,
+        $schema: ConstantString.WrappedCardSchema,
+        jsonPath: jsonPath,
+        responseLayout: ConstantString.WrappedCardResponseLayout,
+        responseCardTemplate: card,
+        previewCardTemplate: inferPreviewCardTemplate(card),
+    };
+    return result;
+}
+function wrapResponseSemantics(card, jsonPath) {
+    const props = inferProperties(card);
+    const dataPath = jsonPath === "$" ? "$" : "$." + jsonPath;
+    const result = {
+        data_path: dataPath,
+    };
+    if (props.title || props.subtitle || props.imageUrl) {
+        result.properties = {};
+        if (props.title) {
+            result.properties.title = "$." + props.title;
+        }
+        if (props.subtitle) {
+            result.properties.subtitle = "$." + props.subtitle;
+        }
+        if (props.imageUrl) {
+            result.properties.url = "$." + props.imageUrl;
+        }
+    }
+    result.static_template = card;
+    return result;
+}
+/**
+ * Infers the preview card template from an Adaptive Card and a JSON path.
+ * The preview card template includes a title and an optional subtitle and image.
+ * It populates the preview card template with the first text block that matches
+ * each well-known name, in the order of title, subtitle, and image.
+ * If no text block matches the title or subtitle, it uses the first two text block as the title and subtitle.
+ * If the title is still empty and the subtitle is not empty, it uses subtitle as the title.
+ * @param card The Adaptive Card to infer the preview card template from.
+ * @param jsonPath The JSON path to the root object in the card body.
+ * @returns The inferred preview card template.
+ */
+function inferPreviewCardTemplate(card) {
+    const result = {
+        title: "result",
+    };
+    const inferredProperties = inferProperties(card);
+    if (inferredProperties.title) {
+        result.title = `\${if(${inferredProperties.title}, ${inferredProperties.title}, 'N/A')}`;
+    }
+    if (inferredProperties.subtitle) {
+        result.subtitle = `\${if(${inferredProperties.subtitle}, ${inferredProperties.subtitle}, 'N/A')}`;
+    }
+    if (inferredProperties.imageUrl) {
+        result.image = {
+            url: `\${${inferredProperties.imageUrl}}`,
+            alt: `\${if(${inferredProperties.imageUrl}, ${inferredProperties.imageUrl}, 'N/A')}`,
+            $when: `\${${inferredProperties.imageUrl} != null}`,
+        };
+    }
+    return result;
+}
+function inferProperties(card) {
+    var _a;
+    const result = {};
+    const nameSet = new Set();
+    let rootObject;
+    if (((_a = card.body[0]) === null || _a === void 0 ? void 0 : _a.type) === ConstantString.ContainerType) {
+        rootObject = card.body[0].items;
+    }
+    else {
+        rootObject = card.body;
+    }
+    for (const element of rootObject) {
+        if (element.type === ConstantString.TextBlockType) {
+            const textElement = element;
+            const index = textElement.text.indexOf("${if(");
+            if (index > 0) {
+                const text = textElement.text.substring(index);
+                const match = text.match(/\${if\(([^,]+),/);
+                const property = match ? match[1] : "";
+                if (property) {
+                    nameSet.add(property);
+                }
+            }
+        }
+        else if (element.type === ConstantString.ImageType) {
+            const imageElement = element;
+            const match = imageElement.url.match(/\${([^,]+)}/);
+            const property = match ? match[1] : "";
+            if (property) {
+                nameSet.add(property);
+            }
+        }
+    }
+    for (const name of nameSet) {
+        if (!result.title && Utils.isWellKnownName(name, ConstantString.WellknownTitleName)) {
+            result.title = name;
+            nameSet.delete(name);
+        }
+        else if (!result.subtitle &&
+            Utils.isWellKnownName(name, ConstantString.WellknownSubtitleName)) {
+            result.subtitle = name;
+            nameSet.delete(name);
+        }
+        else if (!result.imageUrl && Utils.isWellKnownName(name, ConstantString.WellknownImageName)) {
+            result.imageUrl = name;
+            nameSet.delete(name);
+        }
+    }
+    for (const name of nameSet) {
+        if (!result.title) {
+            result.title = name;
+            nameSet.delete(name);
+        }
+        else if (!result.subtitle) {
+            result.subtitle = name;
+            nameSet.delete(name);
+        }
+    }
+    if (!result.title && result.subtitle) {
+        result.title = result.subtitle;
+        delete result.subtitle;
+    }
+    return result;
+}
+
+// Copyright (c) Microsoft Corporation.
+class ManifestUpdater {
+    static async updateManifestWithAiPlugin(manifestPath, outputSpecPath, apiPluginFilePath, spec, options, authInfo) {
+        const manifest = await fs.readJSON(manifestPath);
+        const apiPluginRelativePath = ManifestUpdater.getRelativePath(manifestPath, apiPluginFilePath);
+        // Insert plugins in manifest.json if it is plugin for Copilot.
+        if (!options.isGptPlugin) {
+            manifest.plugins = [
+                {
+                    file: apiPluginRelativePath,
+                    id: ConstantString.DefaultPluginId,
+                },
+            ];
+            ManifestUpdater.updateManifestDescription(manifest, spec);
+        }
+        const appName = this.removeEnvs(manifest.name.short);
+        const specRelativePath = ManifestUpdater.getRelativePath(manifestPath, outputSpecPath);
+        const apiPlugin = await ManifestUpdater.generatePluginManifestSchema(spec, specRelativePath, apiPluginFilePath, appName, authInfo, options);
         return [manifest, apiPlugin];
     }
     static updateManifestDescription(manifest, spec) {
@@ -847,23 +1385,56 @@ class ManifestUpdater {
     }
     static mapOpenAPISchemaToFuncParam(schema, method, pathUrl) {
         let parameter;
-        if (schema.type === "string" ||
+        if (schema.type === "array") {
+            const items = schema.items;
+            parameter = {
+                type: "array",
+                items: ManifestUpdater.mapOpenAPISchemaToFuncParam(items, method, pathUrl),
+            };
+        }
+        else if (schema.type === "string" ||
             schema.type === "boolean" ||
             schema.type === "integer" ||
-            schema.type === "number" ||
-            schema.type === "array") {
-            parameter = schema;
+            schema.type === "number") {
+            parameter = {
+                type: schema.type,
+            };
         }
         else {
             throw new SpecParserError(Utils.format(ConstantString.UnsupportedSchema, method, pathUrl, JSON.stringify(schema)), ErrorType.UpdateManifestFailed);
         }
+        if (schema.enum) {
+            parameter.enum = schema.enum;
+        }
+        if (schema.description) {
+            parameter.description = schema.description;
+        }
+        if (schema.default) {
+            parameter.default = schema.default;
+        }
         return parameter;
     }
-    static generatePluginManifestSchema(spec, specRelativePath, options) {
-        var _a, _b, _c;
+    static async generatePluginManifestSchema(spec, specRelativePath, apiPluginFilePath, appName, authInfo, options) {
+        var _a, _b, _c, _d, _e;
         const functions = [];
         const functionNames = [];
+        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}`);
+                pluginAuthObj.reference_id = `\${{${safeRegistrationIdName}}}`;
+            }
+        }
         for (const pathUrl in paths) {
             const pathItem = paths[pathUrl];
             if (pathItem) {
@@ -871,6 +1442,7 @@ 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 description = (_a = operationItem.description) !== null && _a !== void 0 ? _a : "";
@@ -886,6 +1458,7 @@ class ManifestUpdater {
                                     const param = paramObject[i];
                                     const schema = param.schema;
                                     parameters.properties[param.name] = ManifestUpdater.mapOpenAPISchemaToFuncParam(schema, method, pathUrl);
+                                    confirmationBodies.push(ManifestUpdater.getConfirmationBodyItem(param.name));
                                     if (param.required) {
                                         parameters.required.push(param.name);
                                     }
@@ -904,6 +1477,7 @@ class ManifestUpdater {
                                     for (const property in requestBodySchema.properties) {
                                         const schema = requestBodySchema.properties[property];
                                         parameters.properties[property] = ManifestUpdater.mapOpenAPISchemaToFuncParam(schema, method, pathUrl);
+                                        confirmationBodies.push(ManifestUpdater.getConfirmationBodyItem(property));
                                     }
                                 }
                                 else {
@@ -913,33 +1487,108 @@ class ManifestUpdater {
                             const funcObj = {
                                 name: operationId,
                                 description: description,
-                                parameters: parameters,
                             };
+                            if (paramObject || requestBody) {
+                                funcObj.parameters = parameters;
+                            }
+                            if (options.allowResponseSemantics) {
+                                const { json } = Utils.getResponseJson(operationItem);
+                                if (json.schema) {
+                                    const [card, jsonPath] = AdaptiveCardGenerator.generateAdaptiveCard(operationItem);
+                                    const responseSemantic = wrapResponseSemantics(card, jsonPath);
+                                    funcObj.capabilities = {
+                                        response_semantics: responseSemantic,
+                                    };
+                                }
+                            }
+                            if (options.allowConfirmation && method !== ConstantString.GetMethod) {
+                                if (!funcObj.capabilities) {
+                                    funcObj.capabilities = {};
+                                }
+                                funcObj.capabilities.confirmation = {
+                                    type: "AdaptiveCard",
+                                    title: (_c = operationItem.summary) !== null && _c !== void 0 ? _c : description,
+                                };
+                                if (confirmationBodies.length > 0) {
+                                    funcObj.capabilities.confirmation.body = confirmationBodies.join("\n");
+                                }
+                            }
                             functions.push(funcObj);
                             functionNames.push(operationId);
+                            if (description) {
+                                conversationStarters.push(description);
+                            }
                         }
                     }
                 }
             }
         }
-        const apiPlugin = {
-            schema_version: "v2",
-            name_for_human: spec.info.title,
-            description_for_human: (_c = spec.info.description) !== null && _c !== void 0 ? _c : "<Please add description of the plugin>",
-            functions: functions,
-            runtimes: [
-                {
-                    type: "OpenApi",
-                    auth: {
-                        type: "none", // TODO, support auth in the future
-                    },
-                    spec: {
-                        url: specRelativePath,
-                    },
-                    run_for_functions: functionNames,
+        let apiPlugin;
+        if (await fs.pathExists(apiPluginFilePath)) {
+            apiPlugin = await fs.readJSON(apiPluginFilePath);
+        }
+        else {
+            apiPlugin = {
+                schema_version: "v2.1",
+                name_for_human: "",
+                description_for_human: "",
+                namespace: "",
+                functions: [],
+                runtimes: [],
+            };
+        }
+        apiPlugin.functions = apiPlugin.functions || [];
+        for (const func of functions) {
+            const index = (_d = apiPlugin.functions) === null || _d === void 0 ? void 0 : _d.findIndex((f) => f.name === func.name);
+            if (index === -1) {
+                apiPlugin.functions.push(func);
+            }
+            else {
+                apiPlugin.functions[index] = func;
+            }
+        }
+        apiPlugin.runtimes = apiPlugin.runtimes || [];
+        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,
+            });
+        }
+        else {
+            apiPlugin.runtimes[index].run_for_functions = functionNames;
+        }
+        if (!apiPlugin.name_for_human) {
+            apiPlugin.name_for_human = appName;
+        }
+        if (!apiPlugin.namespace) {
+            apiPlugin.namespace = ManifestUpdater.removeAllSpecialCharacters(appName);
+        }
+        if (!apiPlugin.description_for_human) {
+            apiPlugin.description_for_human =
+                (_e = spec.info.description) !== null && _e !== void 0 ? _e : "<Please add description of the plugin>";
+        }
+        if (options.allowConversationStarters && conversationStarters.length > 0) {
+            if (!apiPlugin.capabilities) {
+                apiPlugin.capabilities = {
+                    localization: {},
+                };
+            }
+            if (!apiPlugin.capabilities.conversation_starters) {
+                apiPlugin.capabilities.conversation_starters = conversationStarters
+                    .slice(0, 5)
+                    .map((text) => ({ text }));
+            }
+        }
         return apiPlugin;
     }
     static async updateManifest(manifestPath, outputSpecPath, spec, options, adaptiveCardFolder, authInfo) {
@@ -959,21 +1608,21 @@ class ManifestUpdater {
                 };
                 if (authInfo) {
                     const auth = authInfo.authScheme;
+                    const safeRegistrationIdName = Utils.getSafeRegistrationIdEnvName(`${authInfo.name}_${ConstantString.RegistrationIdPostfix}`);
                     if (Utils.isAPIKeyAuth(auth) || Utils.isBearerTokenAuth(auth)) {
                         const safeApiSecretRegistrationId = Utils.getSafeRegistrationIdEnvName(`${authInfo.name}_${ConstantString.RegistrationIdPostfix}`);
                         composeExtension.authorization = {
                             authType: "apiSecretServiceAuth",
                             apiSecretServiceAuthConfiguration: {
-                                apiSecretRegistrationId: `\${{${safeApiSecretRegistrationId}}}`,
+                                apiSecretRegistrationId: `\${{${safeRegistrationIdName}}}`,
                             },
                         };
                     }
                     else if (Utils.isOAuthWithAuthCodeFlow(auth)) {
-                        const safeOAuth2RegistrationId = Utils.getSafeRegistrationIdEnvName(`${authInfo.name}_${ConstantString.OAuthRegistrationIdPostFix}`);
                         composeExtension.authorization = {
                             authType: "oAuth2.0",
                             oAuthConfiguration: {
-                                oauthConfigurationId: `\${{${safeOAuth2RegistrationId}}}`,
+                                oauthConfigurationId: `\${{${safeRegistrationIdName}}}`,
                             },
                         };
                         updatedPart.webApplicationInfo = {
@@ -1008,16 +1657,26 @@ class ManifestUpdater {
                         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, options);
+                                const command = Utils.parseApiInfo(operationItem, options);
+                                if (command.parameters &&
+                                    command.parameters.length >= 1 &&
+                                    command.parameters.some((param) => param.isRequired)) {
+                                    command.parameters = command.parameters.filter((param) => param.isRequired);
+                                }
+                                else if (command.parameters && command.parameters.length > 0) {
+                                    command.parameters = [command.parameters[0]];
+                                    warnings.push({
+                                        type: WarningType.OperationOnlyContainsOptionalParam,
+                                        content: Utils.format(ConstantString.OperationOnlyContainsOptionalParam, command.id),
+                                        data: command.id,
+                                    });
+                                }
                                 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);
-                                }
                                 commands.push(command);
                             }
                         }
@@ -1031,255 +1690,21 @@ class ManifestUpdater {
         const relativePath = path.relative(path.dirname(from), to);
         return path.normalize(relativePath).replace(/\\/g, "/");
     }
-}
-
-// Copyright (c) Microsoft Corporation.
-class AdaptiveCardGenerator {
-    static generateAdaptiveCard(operationItem) {
-        try {
-            const json = Utils.getResponseJson(operationItem);
-            let cardBody = [];
-            let schema = json.schema;
-            let jsonPath = "$";
-            if (schema && Object.keys(schema).length > 0) {
-                jsonPath = AdaptiveCardGenerator.getResponseJsonPathFromSchema(schema);
-                if (jsonPath !== "$") {
-                    schema = schema.properties[jsonPath];
-                }
-                cardBody = AdaptiveCardGenerator.generateCardFromResponse(schema, "");
-            }
-            // if no schema, try to use example value
-            if (cardBody.length === 0 && (json.examples || json.example)) {
-                cardBody = [
-                    {
-                        type: ConstantString.TextBlockType,
-                        text: "${jsonStringify($root)}",
-                        wrap: true,
-                    },
-                ];
-            }
-            // if no example value, use default success response
-            if (cardBody.length === 0) {
-                cardBody = [
-                    {
-                        type: ConstantString.TextBlockType,
-                        text: "success",
-                        wrap: true,
-                    },
-                ];
-            }
-            const fullCard = {
-                type: ConstantString.AdaptiveCardType,
-                $schema: ConstantString.AdaptiveCardSchema,
-                version: ConstantString.AdaptiveCardVersion,
-                body: cardBody,
-            };
-            return [fullCard, jsonPath];
-        }
-        catch (err) {
-            throw new SpecParserError(err.toString(), ErrorType.GenerateAdaptiveCardFailed);
-        }
-    }
-    static generateCardFromResponse(schema, name, parentArrayName = "") {
-        if (schema.type === "array") {
-            // schema.items can be arbitrary object: schema { type: array, items: {} }
-            if (Object.keys(schema.items).length === 0) {
-                return [
-                    {
-                        type: ConstantString.TextBlockType,
-                        text: name ? `${name}: \${jsonStringify(${name})}` : "result: ${jsonStringify($root)}",
-                        wrap: true,
-                    },
-                ];
-            }
-            const obj = AdaptiveCardGenerator.generateCardFromResponse(schema.items, "", name);
-            const template = {
-                type: ConstantString.ContainerType,
-                $data: name ? `\${${name}}` : "${$root}",
-                items: Array(),
-            };
-            template.items.push(...obj);
-            return [template];
-        }
-        // some schema may not contain type but contain properties
-        if (schema.type === "object" || (!schema.type && schema.properties)) {
-            const { properties } = schema;
-            const result = [];
-            for (const property in properties) {
-                const obj = AdaptiveCardGenerator.generateCardFromResponse(properties[property], name ? `${name}.${property}` : property, parentArrayName);
-                result.push(...obj);
-            }
-            if (schema.additionalProperties) {
-                // TODO: better ways to handler warnings.
-                console.warn(ConstantString.AdditionalPropertiesNotSupported);
-            }
-            return result;
-        }
-        if (schema.type === "string" ||
-            schema.type === "integer" ||
-            schema.type === "boolean" ||
-            schema.type === "number") {
-            if (!AdaptiveCardGenerator.isImageUrlProperty(schema, name, parentArrayName)) {
-                // string in root: "ddd"
-                let text = "result: ${$root}";
-                if (name) {
-                    // object { id: "1" }
-                    text = `${name}: \${if(${name}, ${name}, 'N/A')}`;
-                    if (parentArrayName) {
-                        // object types inside array: { tags: ["id": 1, "name": "name"] }
-                        text = `${parentArrayName}.${text}`;
-                    }
-                }
-                else if (parentArrayName) {
-                    // string array: photoUrls: ["1", "2"]
-                    text = `${parentArrayName}: ` + "${$data}";
-                }
-                return [
-                    {
-                        type: ConstantString.TextBlockType,
-                        text,
-                        wrap: true,
-                    },
-                ];
-            }
-            else {
-                if (name) {
-                    return [
-                        {
-                            type: "Image",
-                            url: `\${${name}}`,
-                            $when: `\${${name} != null}`,
-                        },
-                    ];
-                }
-                else {
-                    return [
-                        {
-                            type: "Image",
-                            url: "${$data}",
-                            $when: "${$data != null}",
-                        },
-                    ];
-                }
-            }
-        }
-        if (schema.oneOf || schema.anyOf || schema.not || schema.allOf) {
-            throw new Error(Utils.format(ConstantString.SchemaNotSupported, JSON.stringify(schema)));
-        }
-        throw new Error(Utils.format(ConstantString.UnknownSchema, JSON.stringify(schema)));
-    }
-    // Find the first array property in the response schema object with the well-known name
-    static getResponseJsonPathFromSchema(schema) {
-        if (schema.type === "object" || (!schema.type && schema.properties)) {
-            const { properties } = schema;
-            for (const property in properties) {
-                const schema = properties[property];
-                if (schema.type === "array" &&
-                    Utils.isWellKnownName(property, ConstantString.WellknownResultNames)) {
-                    return property;
-                }
-            }
-        }
-        return "$";
-    }
-    static isImageUrlProperty(schema, name, parentArrayName) {
-        const propertyName = name ? name : parentArrayName;
-        return (!!propertyName &&
-            schema.type === "string" &&
-            Utils.isWellKnownName(propertyName, ConstantString.WellknownImageName) &&
-            (propertyName.toLocaleLowerCase().indexOf("url") >= 0 || schema.format === "uri"));
-    }
-}
-
-// Copyright (c) Microsoft Corporation.
-function wrapAdaptiveCard(card, jsonPath) {
-    const result = {
-        version: ConstantString.WrappedCardVersion,
-        $schema: ConstantString.WrappedCardSchema,
-        jsonPath: jsonPath,
-        responseLayout: ConstantString.WrappedCardResponseLayout,
-        responseCardTemplate: card,
-        previewCardTemplate: inferPreviewCardTemplate(card),
-    };
-    return result;
-}
-/**
- * Infers the preview card template from an Adaptive Card and a JSON path.
- * The preview card template includes a title and an optional subtitle and image.
- * It populates the preview card template with the first text block that matches
- * each well-known name, in the order of title, subtitle, and image.
- * If no text block matches the title or subtitle, it uses the first two text block as the title and subtitle.
- * If the title is still empty and the subtitle is not empty, it uses subtitle as the title.
- * @param card The Adaptive Card to infer the preview card template from.
- * @param jsonPath The JSON path to the root object in the card body.
- * @returns The inferred preview card template.
- */
-function inferPreviewCardTemplate(card) {
-    var _a;
-    const result = {
-        title: "",
-    };
-    const textBlockElements = new Set();
-    let rootObject;
-    if (((_a = card.body[0]) === null || _a === void 0 ? void 0 : _a.type) === ConstantString.ContainerType) {
-        rootObject = card.body[0].items;
-    }
-    else {
-        rootObject = card.body;
-    }
-    for (const element of rootObject) {
-        if (element.type === ConstantString.TextBlockType) {
-            const textElement = element;
-            const index = textElement.text.indexOf("${if(");
-            if (index > 0) {
-                textElement.text = textElement.text.substring(index);
-                textBlockElements.add(textElement);
-            }
-        }
-    }
-    for (const element of textBlockElements) {
-        const text = element.text;
-        if (!result.title && Utils.isWellKnownName(text, ConstantString.WellknownTitleName)) {
-            result.title = text;
-            textBlockElements.delete(element);
-        }
-        else if (!result.subtitle &&
-            Utils.isWellKnownName(text, ConstantString.WellknownSubtitleName)) {
-            result.subtitle = text;
-            textBlockElements.delete(element);
-        }
-        else if (!result.image && Utils.isWellKnownName(text, ConstantString.WellknownImageName)) {
-            const match = text.match(/\${if\(([^,]+),/);
-            const property = match ? match[1] : "";
-            if (property) {
-                result.image = {
-                    url: `\${${property}}`,
-                    alt: text,
-                    $when: `\${${property} != null}`,
-                };
-            }
-            textBlockElements.delete(element);
-        }
-    }
-    for (const element of textBlockElements) {
-        const text = element.text;
-        if (!result.title) {
-            result.title = text;
-            textBlockElements.delete(element);
-        }
-        else if (!result.subtitle) {
-            result.subtitle = text;
-            textBlockElements.delete(element);
+    static removeEnvs(str) {
+        const placeHolderReg = /\${{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*}}/g;
+        const matches = placeHolderReg.exec(str);
+        let newStr = str;
+        if (matches != null) {
+            newStr = newStr.replace(matches[0], "");
         }
+        return newStr;
     }
-    if (!result.title && result.subtitle) {
-        result.title = result.subtitle;
-        delete result.subtitle;
+    static removeAllSpecialCharacters(str) {
+        return str.toLowerCase().replace(/[^a-z0-9]/g, "");
     }
-    if (!result.title) {
-        result.title = "result";
+    static getConfirmationBodyItem(paramName) {
+        return `* **${Utils.updateFirstLetter(paramName)}**: {{function.parameters.${paramName}}}`;
     }
-    return result;
 }
 
 // Copyright (c) Microsoft Corporation.
@@ -1301,7 +1726,11 @@ class SpecParser {
             allowMultipleParameters: false,
             allowOauth2: false,
             allowMethods: ["get", "post"],
+            allowConversationStarters: false,
+            allowResponseSemantics: false,
+            allowConfirmation: false,
             projectType: ProjectType.SME,
+            isGptPlugin: false,
         };
         this.pathOrSpec = pathOrDoc;
         this.parser = new SwaggerParser();
@@ -1325,6 +1754,8 @@ class SpecParser {
                     errors: [{ type: ErrorType.SpecNotValid, content: e.toString() }],
                 };
             }
+            const errors = [];
+            const warnings = [];
             if (!this.options.allowSwagger && this.isSwaggerFile) {
                 return {
                     status: ValidationStatus.Error,
@@ -1334,23 +1765,38 @@ class SpecParser {
                     ],
                 };
             }
-            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,
-                            },
-                        ],
-                    };
-                }
+            // Remote reference not supported
+            const refPaths = this.parser.$refs.paths();
+            // refPaths [0] is the current spec file path
+            if (refPaths.length > 1) {
+                errors.push({
+                    type: ErrorType.RemoteRefNotSupported,
+                    content: Utils.format(ConstantString.RemoteRefNotSupported, refPaths.join(", ")),
+                    data: refPaths,
+                });
+            }
+            if (!!this.isSwaggerFile && this.options.allowSwagger) {
+                warnings.push({
+                    type: WarningType.ConvertSwaggerToOpenAPI,
+                    content: ConstantString.ConvertSwaggerToOpenAPI,
+                });
             }
-            return Utils.validateSpec(this.spec, this.parser, !!this.isSwaggerFile, this.options);
+            const validator = this.getValidator(this.spec);
+            const validationResult = validator.validateSpec();
+            warnings.push(...validationResult.warnings);
+            errors.push(...validationResult.errors);
+            let status = ValidationStatus.Valid;
+            if (warnings.length > 0 && errors.length === 0) {
+                status = ValidationStatus.Warning;
+            }
+            else if (errors.length > 0) {
+                status = ValidationStatus.Error;
+            }
+            return {
+                status: status,
+                warnings: warnings,
+                errors: errors,
+            };
         }
         catch (err) {
             throw new SpecParserError(err.toString(), ErrorType.ValidateFailed);
@@ -1370,45 +1816,40 @@ class SpecParser {
         try {
             await this.loadSpec();
             const spec = this.spec;
-            const apiMap = this.getAllSupportedAPIs(spec);
+            const apiMap = this.getAPIs(spec);
             const result = {
-                validAPIs: [],
+                APIs: [],
                 allAPICount: 0,
                 validAPICount: 0,
             };
             for (const apiKey in apiMap) {
+                const { operation, isValid, reason } = apiMap[apiKey];
+                const [method, path] = apiKey.split(" ");
+                const operationId = (_a = operation.operationId) !== null && _a !== void 0 ? _a : `${method.toLowerCase()}${Utils.convertPathToCamelCase(path)}`;
                 const apiResult = {
-                    api: "",
+                    api: apiKey,
                     server: "",
-                    operationId: "",
+                    operationId: operationId,
+                    isValid: isValid,
+                    reason: reason,
                 };
-                const [method, path] = apiKey.split(" ");
-                const operation = apiMap[apiKey];
-                const rootServer = spec.servers && spec.servers[0];
-                const methodServer = spec.paths[path].servers && ((_a = spec.paths[path]) === null || _a === void 0 ? void 0 : _a.servers[0]);
-                const operationServer = operation.servers && operation.servers[0];
-                const serverUrl = operationServer || methodServer || rootServer;
-                if (!serverUrl) {
-                    throw new SpecParserError(ConstantString.NoServerInformation, ErrorType.NoServerInformation);
-                }
-                apiResult.server = Utils.resolveServerUrl(serverUrl.url);
-                let operationId = operation.operationId;
-                if (!operationId) {
-                    operationId = `${method.toLowerCase()}${Utils.convertPathToCamelCase(path)}`;
-                }
-                apiResult.operationId = operationId;
-                const authArray = Utils.getAuthArray(operation.security, spec);
-                for (const auths of authArray) {
-                    if (auths.length === 1) {
-                        apiResult.auth = auths[0];
-                        break;
+                if (isValid) {
+                    const serverObj = Utils.getServerObject(spec, method.toLocaleLowerCase(), path);
+                    if (serverObj) {
+                        apiResult.server = Utils.resolveEnv(serverObj.url);
+                    }
+                    const authArray = Utils.getAuthArray(operation.security, spec);
+                    for (const auths of authArray) {
+                        if (auths.length === 1) {
+                            apiResult.auth = auths[0];
+                            break;
+                        }
                     }
                 }
-                apiResult.api = apiKey;
-                result.validAPIs.push(apiResult);
+                result.APIs.push(apiResult);
             }
-            result.allAPICount = Utils.getAllAPICount(spec);
-            result.validAPICount = result.validAPIs.length;
+            result.allAPICount = result.APIs.length;
+            result.validAPICount = result.APIs.filter((api) => api.isValid).length;
             return result;
         }
         catch (err) {
@@ -1461,18 +1902,12 @@ class SpecParser {
             const newSpecs = await this.getFilteredSpecs(filter, signal);
             const newUnResolvedSpec = newSpecs[0];
             const newSpec = newSpecs[1];
-            let resultStr;
-            if (outputSpecPath.endsWith(".yaml") || outputSpecPath.endsWith(".yml")) {
-                resultStr = jsyaml.dump(newUnResolvedSpec);
-            }
-            else {
-                resultStr = JSON.stringify(newUnResolvedSpec, null, 2);
-            }
-            await fs.outputFile(outputSpecPath, resultStr);
+            const authInfo = Utils.getAuthInfo(newSpec);
+            await this.saveFilterSpec(outputSpecPath, newUnResolvedSpec);
             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, this.options);
+            const [updatedManifest, apiPlugin] = await ManifestUpdater.updateManifestWithAiPlugin(manifestPath, outputSpecPath, pluginFilePath, newSpec, this.options, authInfo);
             await fs.outputJSON(manifestPath, updatedManifest, { spaces: 2 });
             await fs.outputJSON(pluginFilePath, apiPlugin, { spaces: 2 });
         }
@@ -1500,32 +1935,11 @@ class SpecParser {
             const newSpecs = await this.getFilteredSpecs(filter, signal);
             const newUnResolvedSpec = newSpecs[0];
             const newSpec = newSpecs[1];
-            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]);
-                        if (authSet.size > 1) {
-                            hasMultipleAuth = true;
-                            break;
-                        }
-                    }
-                }
-            }
-            if (hasMultipleAuth && this.options.projectType !== ProjectType.TeamsAi) {
-                throw new SpecParserError(ConstantString.MultipleAuthNotSupported, ErrorType.MultipleAuthNotSupported);
-            }
-            let resultStr;
-            if (outputSpecPath.endsWith(".yaml") || outputSpecPath.endsWith(".yml")) {
-                resultStr = jsyaml.dump(newUnResolvedSpec);
-            }
-            else {
-                resultStr = JSON.stringify(newUnResolvedSpec, null, 2);
+            let authInfo = undefined;
+            if (this.options.projectType === ProjectType.SME) {
+                authInfo = Utils.getAuthInfo(newSpec);
             }
-            await fs.outputFile(outputSpecPath, resultStr);
+            await this.saveFilterSpec(outputSpecPath, newUnResolvedSpec);
             if (adaptiveCardFolder) {
                 for (const url in newSpec.paths) {
                     for (const method in newSpec.paths[url]) {
@@ -1555,7 +1969,6 @@ class SpecParser {
             if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
                 throw new SpecParserError(ConstantString.CancelledMessage, ErrorType.Cancelled);
             }
-            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);
@@ -1581,13 +1994,28 @@ class SpecParser {
             this.spec = (await this.parser.dereference(clonedUnResolveSpec));
         }
     }
-    getAllSupportedAPIs(spec) {
-        if (this.apiMap !== undefined) {
-            return this.apiMap;
+    getAPIs(spec) {
+        const validator = this.getValidator(spec);
+        const apiMap = validator.listAPIs();
+        return apiMap;
+    }
+    getValidator(spec) {
+        if (this.validator) {
+            return this.validator;
         }
-        const result = Utils.listSupportedAPIs(spec, this.options);
-        this.apiMap = result;
-        return result;
+        const validator = ValidatorFactory.create(spec, this.options);
+        this.validator = validator;
+        return validator;
+    }
+    async saveFilterSpec(outputSpecPath, unResolvedSpec) {
+        let resultStr;
+        if (outputSpecPath.endsWith(".yaml") || outputSpecPath.endsWith(".yml")) {
+            resultStr = jsyaml.dump(unResolvedSpec);
+        }
+        else {
+            resultStr = JSON.stringify(unResolvedSpec, null, 2);
+        }
+        await fs.outputFile(outputSpecPath, resultStr);
     }
 }