@microsoft/teamsfx-core 3.0.15-rc.0 → 3.0.16-alpha.027c46bf2b.0

package/build/v4/runtime/steps/openApi.js

@@ -8,12 +8,17 @@ const m365_spec_parser_1 = require("@microsoft/m365-spec-parser");
 const teamsfx_api_1 = require("@microsoft/teamsfx-api");
 const axios_1 = tslib_1.__importDefault(require("axios"));
 const fs = tslib_1.__importStar(require("fs-extra"));
-const os = tslib_1.__importStar(require("os"));
 const path = tslib_1.__importStar(require("path"));
 const neverthrow_1 = require("neverthrow");
+const constants_1 = require("../../../common/constants");
+const daSpecParser_1 = require("../../../common/daSpecParser");
+const localizeUtils_1 = require("../../../common/localizeUtils");
+const openApiParserOptions_1 = require("../../../common/openApiParserOptions");
 const stringUtils_1 = require("../../../common/stringUtils");
 const utils_1 = require("../../../common/utils");
-const constants_1 = require("../../../question/constants");
+const constants_2 = require("../../../question/constants");
+const withTempDirectory_1 = require("../withTempDirectory");
+const openApiCustomApi_1 = require("./openApiCustomApi");
 /** Generate API plugin files through spec-parser, then copy artifacts back via `ctx.write`. */
 const SOURCE = "Scaffold";
 exports.STEP_GENERATE_OPENAPI_PLUGIN_FILES = "openapi/generate-plugin-files";
@@ -24,19 +29,10 @@ const PLUGIN_PATH = `${teamsfx_api_1.AppPackageFolderName}/${teamsfx_api_1.Defau
 const API_SPEC_PATH = `${teamsfx_api_1.AppPackageFolderName}/${teamsfx_api_1.DefaultApiSpecFolderName}/${teamsfx_api_1.DefaultApiSpecYamlFileName}`;
 const ORIGINAL_API_SPEC_PATH = `${API_SPEC_PATH}.original`;
 const DEFAULT_ACTION_ID = "action_1";
+/** Mirrors `invalidApiSpecErrorName` in the legacy openApiSpec helper, which v4 must not import. */
+const INVALID_API_SPEC_ERROR_NAME = "invalid-api-spec";
 const M365_AGENTS_YML = "m365agents.yml";
 const M365_AGENTS_LOCAL_YML = "m365agents.local.yml";
-const TEAMS_AI_OPERATION_METHODS = [
-    "get",
-    "post",
-    "put",
-    "delete",
-    "patch",
-    "head",
-    "connect",
-    "options",
-    "trace",
-];
 function systemError(name, message) {
     return new teamsfx_api_1.SystemError({ source: SOURCE, name, message });
 }
@@ -51,9 +47,6 @@ function stringArrayParam(params, key) {
     }
     return value;
 }
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function readRequired(ctx, filePath) {
     const current = ctx.read(filePath);
     if (current === undefined) {
@@ -64,107 +57,6 @@ function readRequired(ctx, filePath) {
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
-function parseJsonObject(json, filePath, errorName) {
-    let parsed;
-    try {
-        parsed = JSON.parse(json);
-    }
-    catch (error) {
-        return (0, neverthrow_1.err)(systemError(`${errorName}Parse`, `Cannot parse '${filePath}' as JSON: ${errorMessage(error)}`));
-    }
-    if (!isRecord(parsed)) {
-        return (0, neverthrow_1.err)(systemError(`${errorName}Shape`, `'${filePath}' is not a JSON object`));
-    }
-    return (0, neverthrow_1.ok)(parsed);
-}
-function isConversationStarter(value) {
-    return isRecord(value) && typeof value.text === "string";
-}
-function conversationStartersFromUnknown(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value.filter(isConversationStarter).map((starter) => ({ text: starter.text }));
-}
-function pluginConversationStarters(plugin) {
-    const capabilities = plugin.capabilities;
-    if (!isRecord(capabilities)) {
-        return [];
-    }
-    return conversationStartersFromUnknown(capabilities.conversation_starters);
-}
-function pluginOperationIds(plugin) {
-    const operationIds = new Set();
-    if (!Array.isArray(plugin.functions)) {
-        return operationIds;
-    }
-    for (const func of plugin.functions) {
-        if (!isRecord(func) || typeof func.name !== "string") {
-            continue;
-        }
-        operationIds.add(func.name);
-    }
-    return operationIds;
-}
-async function specConversationStarters(apiSpecPath, operationIds) {
-    if (operationIds.size === 0) {
-        return [];
-    }
-    const parser = new m365_spec_parser_1.SpecParser(apiSpecPath, openApiParseOptions());
-    const listed = await parser.list();
-    const starters = [];
-    for (const operation of listed.APIs) {
-        if (!operation.isValid || !operation.operationId || !operationIds.has(operation.operationId)) {
-            continue;
-        }
-        const text = operation.summary || operation.description;
-        if (text) {
-            starters.push({ text });
-        }
-    }
-    return starters;
-}
-function appendConversationStarters(agent, starters) {
-    if (starters.length === 0) {
-        return;
-    }
-    const nextStarters = Array.isArray(agent.conversation_starters)
-        ? [...agent.conversation_starters]
-        : [];
-    for (const starter of starters) {
-        if (nextStarters.length >= 6) {
-            break;
-        }
-        const alreadyExists = nextStarters.some((existingStarter) => isConversationStarter(existingStarter) && existingStarter.text === starter.text);
-        if (!alreadyExists) {
-            nextStarters.push(starter);
-        }
-    }
-    agent.conversation_starters = nextStarters;
-}
-async function addActionAndConversationStarters(agentJson, pluginJson, apiSpecPath) {
-    const agent = parseJsonObject(agentJson, AGENT_PATH, "OpenApiDeclarativeAgent");
-    if (agent.isErr()) {
-        return (0, neverthrow_1.err)(agent.error);
-    }
-    const plugin = parseJsonObject(pluginJson, PLUGIN_PATH, "OpenApiPluginManifest");
-    if (plugin.isErr()) {
-        return (0, neverthrow_1.err)(plugin.error);
-    }
-    const actions = agent.value.actions;
-    if (actions !== undefined && !Array.isArray(actions)) {
-        return (0, neverthrow_1.err)(systemError("OpenApiDeclarativeAgentActions", `'${AGENT_PATH}' actions is not an array`));
-    }
-    const nextActions = Array.isArray(actions) ? [...actions] : [];
-    nextActions.push({ id: DEFAULT_ACTION_ID, file: teamsfx_api_1.DefaultPluginManifestFileName });
-    agent.value.actions = nextActions;
-    let starters = pluginConversationStarters(plugin.value);
-    if (starters.length === 0) {
-        starters = await specConversationStarters(apiSpecPath, pluginOperationIds(plugin.value));
-    }
-    appendConversationStarters(agent.value, starters);
-    return (0, neverthrow_1.ok)(JSON.stringify(agent.value, null, 4) + "\n");
-}
 function registrationIdEnvName(authName) {
     return m365_spec_parser_1.Utils.getSafeRegistrationIdEnvName(`${authName}_${m365_spec_parser_1.ConstantString.RegistrationIdPostfix}`);
 }
@@ -181,14 +73,11 @@ function authType(operation) {
     }
     return undefined;
 }
-async function selectedAuthRegistrations(apiSpecLocation, apiOperations) {
-    const parser = new m365_spec_parser_1.SpecParser(apiSpecLocation, openApiParseOptions());
-    const listed = await parser.list();
-    const selected = listed.APIs.filter((operation) => apiOperations.includes(operation.api));
+function selectedAuthRegistrations(selectedOperations) {
     const serverUrls = new Set();
     const authNames = new Set();
     const registrations = [];
-    for (const operation of selected) {
+    for (const operation of selectedOperations) {
         const type = authType(operation);
         const authName = operation.auth?.name;
         if (type === undefined || !authName) {
@@ -216,6 +105,10 @@ async function selectedAuthRegistrations(apiSpecLocation, apiOperations) {
     }
     return (0, neverthrow_1.ok)(registrations);
 }
+function conversationStarterText(operation) {
+    const text = operation.summary?.trim() || operation.description?.trim();
+    return text || undefined;
+}
 function authActionBlock(registration) {
     if (registration.authType === "apiKey") {
         return [
@@ -272,431 +165,34 @@ function updateAuthYml(ctx, filePath, registrations) {
     ctx.write(filePath, Buffer.from(updated, "utf8"));
 }
 function openApiParseOptions() {
-    return {
-        isGptPlugin: true,
-        allowAPIKeyAuth: true,
-        allowBearerTokenAuth: true,
-        allowMultipleParameters: true,
-        allowOauth2: true,
-        projectType: m365_spec_parser_1.ProjectType.Copilot,
-        allowMissingId: true,
-        allowSwagger: true,
-        allowMethods: ["get", "post", "put", "delete", "patch", "head", "connect", "options", "trace"],
-        allowResponseSemantics: true,
-        allowConversationStarters: false,
-        allowConfirmation: false,
-    };
+    // Reuse the v3 Copilot parser options (single source of truth) instead of a v4 copy.
+    return (0, openApiParserOptions_1.getParserOptions)(m365_spec_parser_1.ProjectType.Copilot, true);
 }
 function teamsAiParseOptions() {
-    return {
-        allowAPIKeyAuth: true,
-        allowBearerTokenAuth: true,
-        allowMultipleParameters: true,
-        allowOauth2: true,
-        projectType: m365_spec_parser_1.ProjectType.TeamsAi,
-        allowMethods: ["get", "post", "put", "delete", "patch", "head", "connect", "options", "trace"],
-    };
+    return (0, openApiParserOptions_1.getParserOptions)(m365_spec_parser_1.ProjectType.TeamsAi);
 }
 function languageParam(params) {
     const language = stringParam(params, "language");
     switch (language) {
-        case constants_1.ProgrammingLanguage.TS:
-            return constants_1.ProgrammingLanguage.TS;
-        case constants_1.ProgrammingLanguage.JS:
-            return constants_1.ProgrammingLanguage.JS;
-        case constants_1.ProgrammingLanguage.PY:
-            return constants_1.ProgrammingLanguage.PY;
+        case constants_2.ProgrammingLanguage.TS:
+            return constants_2.ProgrammingLanguage.TS;
+        case constants_2.ProgrammingLanguage.JS:
+            return constants_2.ProgrammingLanguage.JS;
+        case constants_2.ProgrammingLanguage.PY:
+            return constants_2.ProgrammingLanguage.PY;
         default:
             return undefined;
     }
 }
 function teamsAiLanguageFiles(language) {
-    if (language === constants_1.ProgrammingLanguage.TS) {
+    if (language === constants_2.ProgrammingLanguage.TS) {
         return { appPath: "src/app/app.ts", handlerPath: "src/app/handlers.ts" };
     }
-    if (language === constants_1.ProgrammingLanguage.JS) {
+    if (language === constants_2.ProgrammingLanguage.JS) {
         return { appPath: "src/app/app.js", handlerPath: "src/app/handlers.js" };
     }
     return { appPath: "src/app.py", handlerPath: "src/handlers.py" };
 }
-function recordProperty(record, key) {
-    const value = record[key];
-    return isRecord(value) ? value : undefined;
-}
-function stringProperty(record, key) {
-    const value = record[key];
-    return typeof value === "string" ? value : undefined;
-}
-function stringArrayProperty(record, key) {
-    const value = record[key];
-    if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
-        return undefined;
-    }
-    return value;
-}
-function teamsAiOperationDescription(operation, method, pathUrl) {
-    return (stringProperty(operation, "description") ??
-        stringProperty(operation, "summary") ??
-        `${method.toUpperCase()} ${pathUrl}`);
-}
-function teamsAiOperationPrompt(operation, method, pathUrl) {
-    return (stringProperty(operation, "summary") ??
-        stringProperty(operation, "description") ??
-        `${method.toUpperCase()} ${pathUrl}`);
-}
-function filterJsonSchema(schema) {
-    if (!isRecord(schema)) {
-        return { type: "object" };
-    }
-    const filtered = {};
-    const type = stringProperty(schema, "type");
-    if (type !== undefined) {
-        filtered.type = type;
-    }
-    const description = stringProperty(schema, "description");
-    if (description !== undefined) {
-        filtered.description = description;
-    }
-    const required = stringArrayProperty(schema, "required");
-    if (required !== undefined) {
-        filtered.required = required;
-    }
-    const properties = recordProperty(schema, "properties");
-    if (properties !== undefined) {
-        const filteredProperties = {};
-        for (const [propertyName, propertySchema] of Object.entries(properties)) {
-            filteredProperties[propertyName] = filterJsonSchema(propertySchema);
-        }
-        filtered.properties = filteredProperties;
-    }
-    if (schema.items !== undefined) {
-        filtered.items = filterJsonSchema(schema.items);
-    }
-    return Object.keys(filtered).length === 0 ? { type: "object" } : filtered;
-}
-function ensureObjectSection(sections, sectionName) {
-    const existing = recordProperty(sections, sectionName);
-    if (existing !== undefined) {
-        return existing;
-    }
-    const section = { type: "object", properties: {}, required: [] };
-    sections[sectionName] = section;
-    return section;
-}
-function addRequiredValue(record, key, value) {
-    const required = stringArrayProperty(record, key) ?? [];
-    if (!required.includes(value)) {
-        required.push(value);
-    }
-    record[key] = required;
-}
-function teamsAiParametersSchema(operation) {
-    const parameterProperties = {};
-    const parameters = operation.parameters;
-    if (Array.isArray(parameters)) {
-        for (const parameter of parameters) {
-            if (!isRecord(parameter)) {
-                continue;
-            }
-            const name = stringProperty(parameter, "name");
-            const location = stringProperty(parameter, "in");
-            if (name === undefined || location === undefined) {
-                continue;
-            }
-            const section = ensureObjectSection(parameterProperties, location);
-            const sectionProperties = recordProperty(section, "properties") ?? {};
-            const schema = filterJsonSchema(parameter.schema);
-            const description = stringProperty(parameter, "description");
-            if (description !== undefined) {
-                schema.description = description;
-            }
-            sectionProperties[name] = schema;
-            section.properties = sectionProperties;
-            if (parameter.required === true) {
-                addRequiredValue(section, "required", name);
-            }
-        }
-    }
-    const requestBody = recordProperty(operation, "requestBody");
-    const content = requestBody === undefined ? undefined : recordProperty(requestBody, "content");
-    const jsonMedia = content === undefined ? undefined : recordProperty(content, "application/json");
-    if (jsonMedia?.schema !== undefined) {
-        const bodySchema = filterJsonSchema(jsonMedia.schema);
-        const description = requestBody === undefined ? undefined : stringProperty(requestBody, "description");
-        if (description !== undefined) {
-            bodySchema.description = description;
-        }
-        parameterProperties.body = bodySchema;
-    }
-    const root = {
-        type: "object",
-        properties: parameterProperties,
-        required: [],
-    };
-    for (const [sectionName, section] of Object.entries(parameterProperties)) {
-        if (isRecord(section) && stringArrayProperty(section, "required")?.length) {
-            addRequiredValue(root, "required", sectionName);
-        }
-    }
-    if (requestBody?.required === true) {
-        addRequiredValue(root, "required", "body");
-    }
-    return root;
-}
-function teamsAiSpecOperations(spec) {
-    if (!isRecord(spec) || !isRecord(spec.paths)) {
-        return [];
-    }
-    const operations = [];
-    for (const [pathUrl, pathItem] of Object.entries(spec.paths)) {
-        if (!isRecord(pathItem)) {
-            continue;
-        }
-        for (const method of TEAMS_AI_OPERATION_METHODS) {
-            const operation = pathItem[method];
-            if (!isRecord(operation)) {
-                continue;
-            }
-            const operationId = stringProperty(operation, "operationId");
-            if (operationId === undefined) {
-                continue;
-            }
-            operations.push({
-                pathUrl,
-                method,
-                operationId,
-                description: teamsAiOperationDescription(operation, method, pathUrl),
-                prompt: teamsAiOperationPrompt(operation, method, pathUrl),
-                parametersSchema: teamsAiParametersSchema(operation),
-                auth: Array.isArray(operation.security) && operation.security.length > 0,
-                source: operation,
-            });
-        }
-    }
-    return operations;
-}
-function safeFileStem(value) {
-    return value.replace(/[^a-zA-Z0-9]/g, "_");
-}
-function teamsAiPromptText(spec) {
-    const description = isRecord(spec) ? recordProperty(spec, "info")?.description : undefined;
-    return `The following is a conversation with an AI assistant.\nThe assistant can help to call APIs for the open api spec file${typeof description === "string" ? ". " + description : "."}\nIf the API doesn't require parameters, invoke it with default JSON object { "path": null, "body": null, "query": null }.\n\n`;
-}
-function teamsAiFunctionDefinitionCode(operationId) {
-    return `.function(
-      functionDefs.${operationId}.name,
-      functionDefs.${operationId}.description,
-      functionDefs.${operationId}.parameters,
-      async (parameter) => {
-        const result = await functionHandlers.${operationId}Handler(parameter);
-        if(result) {
-          await send(result);
-          return "result showed";
-        } else {
-          return "no result";
-        }
-      }
-  )`;
-}
-function teamsAiFunctionHandlerCode(operation, language) {
-    const exportPrefix = language === constants_1.ProgrammingLanguage.TS ? "export " : "";
-    const parameterName = language === constants_1.ProgrammingLanguage.TS ? "parameter: any" : "parameters";
-    const parameterVariable = language === constants_1.ProgrammingLanguage.TS ? "parameter" : "parameters";
-    const authConfig = operation.auth ? "addAuthConfig(client);" : "";
-    const exportSuffix = language === constants_1.ProgrammingLanguage.JS
-        ? `\nmodule.exports = { ${operation.operationId}Handler };`
-        : "";
-    return `${exportPrefix}const ${operation.operationId}Handler = async (
-  ${parameterName}
-) => {
-  const client = await api.getClient();
-  ${authConfig}
-  const apiPath = client.paths["${operation.pathUrl}"];
-  if (apiPath && apiPath.${operation.method}) {
-    const result = await apiPath.${operation.method}(${parameterVariable}.path, ${parameterVariable}.body, {
-      params: ${parameterVariable}.query,
-    });
-    if (!result || !result.data) {
-      throw new Error("Get empty result from api call.");
-    }
-    const cardName = "${operation.operationId}".replace(/[^a-zA-Z0-9]/g, "_");
-    const cardTemplatePath = path.join(__dirname, "../adaptiveCards", cardName + ".json");
-    if (await fs.exists(cardTemplatePath)){
-      const card = generateAdaptiveCard(cardTemplatePath, result);
-      return card;
-    } else {
-      return JSON.stringify(result.data);
-    }
-  } else {
-    return "";
-  }
-
-};${exportSuffix}`;
-}
-function pythonTeamsAiFunctionDefinitionCode(operationId) {
-    return `.with_function(
-      Function(
-            name=function_defs["${operationId}"]["name"],
-            description=function_defs["${operationId}"]["description"],
-            parameter_schema=function_defs["${operationId}"]["parameters"],
-            handler=make_handler(${operationId}, ctx)
-      )
-    )`;
-}
-function pythonTeamsAiFunctionHandlerCode(operation) {
-    return `async def ${operation.operationId}(
-  parameters,
-):
-  path = getattr(parameters, "path", {})
-  body = getattr(parameters, "body", None)
-  query = getattr(parameters, "query", {}) or {}
-  resp = client.${operation.operationId}(**path, json=body, _headers={}, _params=query, _cookies={})
-
-  if resp.status_code != 200:
-    return resp.reason
-  else:
-    card_template_path = os.path.join(current_dir, 'adaptiveCards/${operation.operationId}.json')
-    if not os.path.exists(card_template_path):
-      json_resoponse_str = resp.text
-      return json_resoponse_str
-    else:
-      with open(card_template_path) as card_template_file:
-        adaptive_card_template = card_template_file.read()
-
-      renderer = AdaptiveCardRenderer(adaptive_card_template)
-
-      json_resoponse_str = resp.text
-      rendered_card_str = renderer.render(json_resoponse_str)
-      rendered_card_json = json.loads(rendered_card_str)
-      return AdaptiveCard.model_validate(rendered_card_json)
-  `;
-}
-function teamsAiAdaptiveCard(operation) {
-    return {
-        type: "AdaptiveCard",
-        version: "1.5",
-        body: [
-            { type: "TextBlock", text: operation.description, wrap: true },
-            { type: "TextBlock", text: "${JSON.stringify($root)}", wrap: true },
-        ],
-    };
-}
-function teamsAiAdaptiveCardWithMockData(operation) {
-    try {
-        const [card, jsonPath, jsonData] = m365_spec_parser_1.AdaptiveCardGenerator.generateAdaptiveCard(operation.source, true, 5);
-        const body = isRecord(card) ? card.body : undefined;
-        if (jsonPath !== "$" && Array.isArray(body) && isRecord(body[0])) {
-            body[0].$data = `\${${jsonPath}}`;
-        }
-        return { card, data: jsonData };
-    }
-    catch {
-        return { card: teamsAiAdaptiveCard(operation), data: {} };
-    }
-}
-async function updatePromptSuggestions(destinationPath, operations) {
-    const manifestPath = path.join(destinationPath, teamsfx_api_1.AppPackageFolderName, teamsfx_api_1.ManifestTemplateFileName);
-    let manifest;
-    try {
-        const parsed = parseJsonObject(await fs.readFile(manifestPath, "utf8"), MANIFEST_PATH, "TeamsAiManifest");
-        if (parsed.isErr()) {
-            return;
-        }
-        manifest = parsed.value;
-    }
-    catch {
-        return;
-    }
-    const bots = manifest.bots;
-    if (!Array.isArray(bots) || !isRecord(bots[0])) {
-        return;
-    }
-    bots[0].commandLists = [
-        {
-            scopes: ["personal"],
-            commands: operations.slice(0, 10).map((operation) => ({
-                title: operation.prompt.slice(0, 32),
-                description: operation.prompt.slice(0, 128),
-            })),
-        },
-    ];
-    await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 4) + "\n");
-}
-async function updateTypescriptJavascriptTeamsAiCustomApi(spec, language, destinationPath, openapiSpecFileName) {
-    const operations = teamsAiSpecOperations(spec);
-    if (operations.length === 0) {
-        return (0, neverthrow_1.err)(systemError("OpenApiTeamsAiOperationsMissing", "Failed to find generated OpenAPI operations for the Teams AI custom API template."));
-    }
-    const appFolder = path.join(destinationPath, "src", "app");
-    const adaptiveCardsFolder = path.join(destinationPath, "src", "adaptiveCards");
-    await fs.ensureDir(appFolder);
-    await fs.ensureDir(adaptiveCardsFolder);
-    await fs.writeFile(path.join(appFolder, "instructions.txt"), teamsAiPromptText(spec));
-    const actions = {};
-    for (const operation of operations) {
-        actions[operation.operationId] = {
-            name: operation.operationId,
-            description: operation.description,
-            parameters: operation.parametersSchema,
-        };
-        const cardName = safeFileStem(operation.operationId);
-        const adaptiveCard = teamsAiAdaptiveCardWithMockData(operation);
-        await fs.writeFile(path.join(adaptiveCardsFolder, `${cardName}.json`), JSON.stringify(adaptiveCard.card, null, 2));
-        await fs.writeFile(path.join(adaptiveCardsFolder, `${cardName}.data.json`), JSON.stringify(adaptiveCard.data, null, 2));
-    }
-    await fs.writeFile(path.join(appFolder, "functions.json"), JSON.stringify(actions, null, 2));
-    const appFilePath = path.join(appFolder, language === constants_1.ProgrammingLanguage.JS ? "app.js" : "app.ts");
-    const handlerFilePath = path.join(appFolder, language === constants_1.ProgrammingLanguage.JS ? "handlers.js" : "handlers.ts");
-    const appFileContent = await fs.readFile(appFilePath, "utf8");
-    await fs.writeFile(appFilePath, appFileContent.replace("// Replace with function definition code", `${operations.map((operation) => teamsAiFunctionDefinitionCode(operation.operationId)).join("\n")};`));
-    const handlerFileContent = await fs.readFile(handlerFilePath, "utf8");
-    await fs.writeFile(handlerFilePath, handlerFileContent
-        .replace("{{OPENAPI_SPEC_PATH}}", openapiSpecFileName)
-        .replace("// Replace with function handler code", operations.map((operation) => teamsAiFunctionHandlerCode(operation, language)).join("\n\n")));
-    await updatePromptSuggestions(destinationPath, operations);
-    return (0, neverthrow_1.ok)(undefined);
-}
-async function updatePythonTeamsAiCustomApi(spec, destinationPath, openapiSpecFileName) {
-    const operations = teamsAiSpecOperations(spec);
-    if (operations.length === 0) {
-        return (0, neverthrow_1.err)(systemError("OpenApiTeamsAiPythonOperationsMissing", "Failed to find generated OpenAPI operations for the Python custom API template."));
-    }
-    const srcFolder = path.join(destinationPath, "src");
-    const adaptiveCardsFolder = path.join(srcFolder, "adaptiveCards");
-    await fs.ensureDir(adaptiveCardsFolder);
-    await fs.writeFile(path.join(srcFolder, "instructions.txt"), teamsAiPromptText(spec));
-    const functions = {};
-    const functionDefinitions = [];
-    const functionHandlers = [];
-    const operationIds = [];
-    for (const operation of operations) {
-        functions[operation.operationId] = {
-            name: operation.operationId,
-            description: operation.description,
-            parameters: operation.parametersSchema,
-        };
-        functionDefinitions.push(pythonTeamsAiFunctionDefinitionCode(operation.operationId));
-        functionHandlers.push(pythonTeamsAiFunctionHandlerCode(operation));
-        operationIds.push(operation.operationId);
-        const cardName = safeFileStem(operation.operationId);
-        const adaptiveCard = teamsAiAdaptiveCardWithMockData(operation);
-        await fs.writeFile(path.join(adaptiveCardsFolder, `${cardName}.json`), JSON.stringify(adaptiveCard.card, null, 2));
-        await fs.writeFile(path.join(adaptiveCardsFolder, `${cardName}.data.json`), JSON.stringify(adaptiveCard.data, null, 2));
-    }
-    await fs.writeFile(path.join(srcFolder, "functions.json"), JSON.stringify(functions, null, 2));
-    const appPath = path.join(srcFolder, "app.py");
-    const appContent = await fs.readFile(appPath, "utf8");
-    await fs.writeFile(appPath, appContent
-        .replace("// Replace with function definition code", `prompt${functionDefinitions.join("")}`)
-        .replace("//Replace with functions to be imported", operationIds.join(", ")));
-    const handlerPath = path.join(srcFolder, "handlers.py");
-    const handlerContent = await fs.readFile(handlerPath, "utf8");
-    await fs.writeFile(handlerPath, handlerContent
-        .replace("{{OPENAPI_SPEC_PATH}}", openapiSpecFileName)
-        .replace("// Replace with function handler code", functionHandlers.join("\n\n")));
-    await updatePromptSuggestions(destinationPath, operations);
-    return (0, neverthrow_1.ok)(undefined);
-}
 async function writeTempFile(root, relativePath, data) {
     const destination = path.join(root, relativePath);
     await fs.ensureDir(path.dirname(destination));
@@ -768,32 +264,70 @@ exports.openApiGeneratePluginFiles = {
         if (agent.isErr()) {
             return (0, neverthrow_1.err)(agent.error);
         }
-        const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "m365atk-openapi-"));
-        try {
+        // Same shared gate the legacy path runs, so an incompatible document fails before generation.
+        const validation = await (0, daSpecParser_1.validateOpenAPISpec)(apiSpecLocation);
+        if (validation.status === m365_spec_parser_1.ValidationStatus.Error) {
+            const message = (0, localizeUtils_1.getLocalizedString)("core.createProjectQuestion.apiSpec.multipleValidationErrors.message");
+            return (0, neverthrow_1.err)(new teamsfx_api_1.UserError(SOURCE, INVALID_API_SPEC_ERROR_NAME, message, message));
+        }
+        return (0, withTempDirectory_1.withTempDirectory)("m365atk-openapi-", (phase, error) => systemError("OpenApiGenerateFailed", `Failed to generate OpenAPI plugin files during temporary file ${phase}: ${errorMessage(error)}`), async (tempRoot) => {
             const temp = await writeTempBaseFiles(tempRoot, manifest.value, agent.value);
             const parser = new m365_spec_parser_1.SpecParser(apiSpecLocation, openApiParseOptions());
-            await parser.generateForCopilot(temp.manifestPath, apiOperations, temp.apiSpecPath, temp.pluginPath);
-            const updatedAgent = await addActionAndConversationStarters((await fs.readFile(path.join(tempRoot, AGENT_PATH))).toString("utf8"), (await fs.readFile(temp.pluginPath)).toString("utf8"), temp.apiSpecPath);
-            if (updatedAgent.isErr()) {
-                return (0, neverthrow_1.err)(updatedAgent.error);
+            const listed = await parser.list();
+            const selectedOperations = listed.APIs.filter((operation) => apiOperations.includes(operation.api));
+            // Share the v3 declarative-agent generator so the Kiota-integration flag selects the same branch.
+            let generated;
+            try {
+                generated = await (0, daSpecParser_1.generatePlugin)(apiSpecLocation, temp.manifestPath, temp.apiSpecPath, temp.pluginPath, apiOperations, m365_spec_parser_1.AdaptiveCardUpdateStrategy.CreateNew);
+            }
+            catch (error) {
+                if (!(error instanceof m365_spec_parser_1.SpecParserError)) {
+                    throw error;
+                }
+                return (0, neverthrow_1.err)(new teamsfx_api_1.SystemError(constants_1.SpecParserSource, error.errorType.toString(), error.message, error.message));
+            }
+            for (const warning of generated.warnings) {
+                ctx.warn?.({ type: String(warning.type), content: warning.content });
             }
-            const registrations = await selectedAuthRegistrations(apiSpecLocation, apiOperations);
+            const agentManifestPath = path.join(tempRoot, AGENT_PATH);
+            let agentManifest;
+            try {
+                agentManifest = teamsfx_api_1.DeclarativeAgentManifestWrapper.fromJSON(await fs.readFile(agentManifestPath, "utf8"));
+            }
+            catch (error) {
+                return (0, neverthrow_1.err)(systemError("JSONSyntaxError", `The declarative agent manifest is not valid JSON: ${errorMessage(error)}`));
+            }
+            agentManifest.upsertAction(DEFAULT_ACTION_ID, teamsfx_api_1.DefaultPluginManifestFileName);
+            const remainingStarterSlots = Math.max(0, 6 - agentManifest.conversationStarters.length);
+            const seenStarterTexts = new Set(agentManifest.conversationStarters.map((starter) => starter.text));
+            const starterTexts = selectedOperations
+                .map(conversationStarterText)
+                .filter((text) => text !== undefined)
+                .filter((text) => {
+                if (seenStarterTexts.has(text)) {
+                    return false;
+                }
+                seenStarterTexts.add(text);
+                return true;
+            })
+                .slice(0, remainingStarterSlots);
+            for (const text of starterTexts) {
+                agentManifest.addConversationStarter(text);
+            }
+            await fs.writeFile(agentManifestPath, agentManifest.toJSON(), "utf8");
+            const registrations = selectedAuthRegistrations(selectedOperations);
             if (registrations.isErr()) {
                 return (0, neverthrow_1.err)(registrations.error);
             }
-            await fs.writeFile(path.join(tempRoot, AGENT_PATH), updatedAgent.value);
             await writeTempTreeToContext(tempRoot, ctx);
-            ctx.write(ORIGINAL_API_SPEC_PATH, await readOriginalOpenApiSpec(apiSpecLocation));
+            if (ctx.read(ORIGINAL_API_SPEC_PATH) === undefined) {
+                // The Kiota branch already emits the unfiltered document beside the generated spec.
+                ctx.write(ORIGINAL_API_SPEC_PATH, await readOriginalOpenApiSpec(apiSpecLocation));
+            }
             updateAuthYml(ctx, M365_AGENTS_YML, registrations.value);
             updateAuthYml(ctx, M365_AGENTS_LOCAL_YML, registrations.value);
             return (0, neverthrow_1.ok)(undefined);
-        }
-        catch (error) {
-            return (0, neverthrow_1.err)(systemError("OpenApiGenerateFailed", `Failed to generate OpenAPI plugin files: ${errorMessage(error)}`));
-        }
-        finally {
-            await fs.remove(tempRoot);
-        }
+        });
     },
 };
 exports.openApiGenerateTeamsAiCustomApiFiles = {
@@ -816,8 +350,7 @@ exports.openApiGenerateTeamsAiCustomApiFiles = {
         if (apiSpecLocation === undefined || apiOperations === undefined || language === undefined) {
             return (0, neverthrow_1.err)(systemError("OpenApiTeamsAiParams", "resolved parameters are not all valid"));
         }
-        const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "m365atk-openapi-teams-ai-"));
-        try {
+        return (0, withTempDirectory_1.withTempDirectory)("m365atk-openapi-teams-ai-", (phase, error) => systemError("OpenApiTeamsAiGenerateFailed", `Failed to generate Teams AI custom API files during temporary file ${phase}: ${errorMessage(error)}`), async (tempRoot) => {
             const languageFiles = teamsAiLanguageFiles(language);
             const baseFiles = await writeTeamsAiBaseFiles(ctx, tempRoot, languageFiles);
             if (baseFiles.isErr()) {
@@ -844,27 +377,13 @@ exports.openApiGenerateTeamsAiCustomApiFiles = {
             if (filteredSpec === undefined) {
                 return (0, neverthrow_1.err)(systemError("OpenApiTeamsAiFilteredSpecMissing", "Failed to generate the filtered OpenAPI document for the selected operations."));
             }
-            if (language === constants_1.ProgrammingLanguage.PY) {
-                const updatePythonResult = await updatePythonTeamsAiCustomApi(filteredSpec, tempRoot, openapiSpecFileName);
-                if (updatePythonResult.isErr()) {
-                    return (0, neverthrow_1.err)(updatePythonResult.error);
-                }
-            }
-            else {
-                const updateResult = await updateTypescriptJavascriptTeamsAiCustomApi(filteredSpec, language, tempRoot, openapiSpecFileName);
-                if (updateResult.isErr()) {
-                    return (0, neverthrow_1.err)(updateResult.error);
-                }
+            const warnings = await (0, openApiCustomApi_1.generateTeamsAiCustomApiFiles)(filteredSpec, language, tempRoot, openapiSpecFileName);
+            for (const warning of warnings) {
+                ctx.warn?.({ type: String(warning.type), content: warning.content });
             }
             await writeTempTreeToContext(tempRoot, ctx);
             return (0, neverthrow_1.ok)(undefined);
-        }
-        catch (error) {
-            return (0, neverthrow_1.err)(systemError("OpenApiTeamsAiGenerateFailed", `Failed to generate Teams AI custom API files: ${errorMessage(error)}`));
-        }
-        finally {
-            await fs.remove(tempRoot);
-        }
+        });
     },
 };
 //# sourceMappingURL=openApi.js.map