@microsoft/teamsfx-core 3.0.15-beta.2026072312.0 → 3.0.15

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

@@ -8,14 +8,12 @@ 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 openApiParserOptions_1 = require("../../../common/openApiParserOptions");
 const stringUtils_1 = require("../../../common/stringUtils");
 const utils_1 = require("../../../common/utils");
 const constants_1 = 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";
@@ -28,6 +26,17 @@ const ORIGINAL_API_SPEC_PATH = `${API_SPEC_PATH}.original`;
 const DEFAULT_ACTION_ID = "action_1";
 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 });
 }
@@ -42,6 +51,9 @@ 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) {
@@ -52,6 +64,107 @@ 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}`);
 }
@@ -68,11 +181,14 @@ function authType(operation) {
     }
     return undefined;
 }
-function selectedAuthRegistrations(selectedOperations) {
+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));
     const serverUrls = new Set();
     const authNames = new Set();
     const registrations = [];
-    for (const operation of selectedOperations) {
+    for (const operation of selected) {
         const type = authType(operation);
         const authName = operation.auth?.name;
         if (type === undefined || !authName) {
@@ -100,10 +216,6 @@ function selectedAuthRegistrations(selectedOperations) {
     }
     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 [
@@ -160,11 +272,30 @@ function updateAuthYml(ctx, filePath, registrations) {
     ctx.write(filePath, Buffer.from(updated, "utf8"));
 }
 function openApiParseOptions() {
-    // 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);
+    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,
+    };
 }
 function teamsAiParseOptions() {
-    return (0, openApiParserOptions_1.getParserOptions)(m365_spec_parser_1.ProjectType.TeamsAi);
+    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"],
+    };
 }
 function languageParam(params) {
     const language = stringParam(params, "language");
@@ -188,6 +319,384 @@ function teamsAiLanguageFiles(language) {
     }
     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));
@@ -259,48 +768,32 @@ exports.openApiGeneratePluginFiles = {
         if (agent.isErr()) {
             return (0, neverthrow_1.err)(agent.error);
         }
-        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 tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "m365atk-openapi-"));
+        try {
             const temp = await writeTempBaseFiles(tempRoot, manifest.value, agent.value);
             const parser = new m365_spec_parser_1.SpecParser(apiSpecLocation, openApiParseOptions());
-            const listed = await parser.list();
-            const selectedOperations = listed.APIs.filter((operation) => apiOperations.includes(operation.api));
             await parser.generateForCopilot(temp.manifestPath, apiOperations, temp.apiSpecPath, temp.pluginPath);
-            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);
+            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);
             }
-            await fs.writeFile(agentManifestPath, agentManifest.toJSON(), "utf8");
-            const registrations = selectedAuthRegistrations(selectedOperations);
+            const registrations = await selectedAuthRegistrations(apiSpecLocation, apiOperations);
             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));
             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 = {
@@ -323,7 +816,8 @@ exports.openApiGenerateTeamsAiCustomApiFiles = {
         if (apiSpecLocation === undefined || apiOperations === undefined || language === undefined) {
             return (0, neverthrow_1.err)(systemError("OpenApiTeamsAiParams", "resolved parameters are not all valid"));
         }
-        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 tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "m365atk-openapi-teams-ai-"));
+        try {
             const languageFiles = teamsAiLanguageFiles(language);
             const baseFiles = await writeTeamsAiBaseFiles(ctx, tempRoot, languageFiles);
             if (baseFiles.isErr()) {
@@ -350,13 +844,27 @@ exports.openApiGenerateTeamsAiCustomApiFiles = {
             if (filteredSpec === undefined) {
                 return (0, neverthrow_1.err)(systemError("OpenApiTeamsAiFilteredSpecMissing", "Failed to generate the filtered OpenAPI document for the selected operations."));
             }
-            const warnings = await (0, openApiCustomApi_1.generateTeamsAiCustomApiFiles)(filteredSpec, language, tempRoot, openapiSpecFileName);
-            for (const warning of warnings) {
-                ctx.warn?.(warning.content);
+            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);
+                }
             }
             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